Add classify, compare tools

Author: dvcrn

README.md

@@ -85,9 +85,21 @@ This MCP server provides access to DEVONthink functionality via the Model Contex
     - Input: record ID and tags
 
 14. `remove_tags`
+
     - Removes tags from a specific record
     - Input: record ID and tags
 
+15. `classify`
+
+    - Gets classification proposals for a record using DEVONthink's AI
+    - Input: record UUID, optional database name, comparison type, and tags option
+    - Returns: Array of classification proposals (groups or tags) with scores
+
+16. `compare`
+    - Compares records to find similarities (hybrid approach)
+    - Input: primary record UUID, optional second record UUID, database name, and comparison type
+    - Returns: Either similar records (single mode) or detailed comparison analysis (two-record mode)
+
 ### Example: Search Tool
 
 ```json

src/devonthink.ts

@@ -22,6 +22,8 @@ import { getRecordContentTool } from "./tools/getRecordContent.js";
 import { renameRecordTool } from "./tools/renameRecord.js";
 import { addTagsTool } from "./tools/addTags.js";
 import { removeTagsTool } from "./tools/removeTags.js";
+import { classifyTool } from "./tools/classify.js";
+import { compareTool } from "./tools/compare.js";
 
 export const createServer = async () => {
   const server = new Server(
@@ -53,6 +55,8 @@ export const createServer = async () => {
     renameRecordTool,
     addTagsTool,
     removeTagsTool,
+    classifyTool,
+    compareTool,
   ];
 
   server.setRequestHandler(ListToolsRequestSchema, async () => {

src/tools/classify.ts

@@ -0,0 +1,142 @@
+import { z } from "zod";
+import { zodToJsonSchema } from "zod-to-json-schema";
+import { Tool, ToolSchema } from "@modelcontextprotocol/sdk/types.js";
+import { executeJxa } from "../applescript/execute.js";
+
+const ToolInputSchema = ToolSchema.shape.inputSchema;
+type ToolInput = z.infer<typeof ToolInputSchema>;
+
+const ClassifySchema = z
+  .object({
+    recordUuid: z.string().describe("The UUID of the record to classify"),
+    databaseName: z
+      .string()
+      .optional()
+      .describe(
+        "The name of the database to search in (defaults to current database)"
+      ),
+    comparison: z
+      .enum(["data comparison", "tags comparison"])
+      .optional()
+      .describe("The comparison type for classification"),
+    tags: z
+      .boolean()
+      .optional()
+      .describe("Whether to propose tags instead of groups"),
+  })
+  .strict();
+
+type ClassifyInput = z.infer<typeof ClassifySchema>;
+
+interface ClassifyResult {
+  success: boolean;
+  error?: string;
+  proposals?: Array<{
+    name: string;
+    type: string;
+    location?: string;
+    score?: number;
+  }>;
+  totalCount?: number;
+}
+
+const classify = async (input: ClassifyInput): Promise<ClassifyResult> => {
+  const { recordUuid, databaseName, comparison, tags } = input;
+
+  const script = `
+    (() => {
+      const theApp = Application("DEVONthink");
+      theApp.includeStandardAdditions = true;
+      
+      try {
+        let targetDatabase;
+        if ("${databaseName || ""}") {
+          const databases = theApp.databases();
+          targetDatabase = databases.find(db => db.name() === "${databaseName}");
+          if (!targetDatabase) {
+            throw new Error("Database not found: ${databaseName}");
+          }
+        } else {
+          targetDatabase = theApp.currentDatabase();
+        }
+
+        // Get the record to classify
+        const targetRecord = theApp.getRecordWithUuid("${recordUuid}");
+        if (!targetRecord) {
+          return JSON.stringify({
+            success: false,
+            error: "Record not found with UUID: ${recordUuid}"
+          });
+        }
+        
+        // Build classify options
+        const classifyOptions = { record: targetRecord };
+        if (targetDatabase) {
+          classifyOptions.in = targetDatabase;
+        }
+        ${comparison ? `classifyOptions.comparison = "${comparison}";` : ""}
+        ${tags ? `classifyOptions.tags = ${tags};` : ""}
+        
+        // Perform classification
+        const classifyResults = theApp.classify(classifyOptions);
+        
+        if (!classifyResults || classifyResults.length === 0) {
+          return JSON.stringify({
+            success: true,
+            proposals: [],
+            totalCount: 0
+          });
+        }
+        
+        // Extract proposal information
+        const proposals = classifyResults.map(proposal => {
+          const result = {
+            name: proposal.name(),
+            type: proposal.recordType ? proposal.recordType() : "group"
+          };
+          
+          // Add location if available
+          try {
+            if (proposal.location) {
+              result.location = proposal.location();
+            }
+          } catch (e) {
+            // Location might not be available for all proposals
+          }
+          
+          // Add score if available
+          try {
+            if (proposal.score && proposal.score() !== undefined) {
+              result.score = proposal.score();
+            }
+          } catch (e) {
+            // Score might not be available for all proposals
+          }
+          
+          return result;
+        });
+        
+        return JSON.stringify({
+          success: true,
+          proposals: proposals,
+          totalCount: classifyResults.length
+        });
+      } catch (error) {
+        return JSON.stringify({
+          success: false,
+          error: error.toString()
+        });
+      }
+    })();
+  `;
+
+  return await executeJxa<ClassifyResult>(script);
+};
+
+export const classifyTool: Tool = {
+  name: "classify",
+  description:
+    "Get classification proposals for a DEVONthink record. This tool uses DEVONthink's AI to suggest appropriate groups or tags for organizing the record. Use the `recordUuid` to specify which record to classify.",
+  inputSchema: zodToJsonSchema(ClassifySchema) as ToolInput,
+  run: classify,
+};