@disco_trooper/apple-notes-mcp 1.2.0 → 1.4.0

package/src/index.ts

@@ -1,3 +1,11 @@
+#!/usr/bin/env bun
+import { hasConfig, getEnvPath } from "./config/paths.js";
+import { checkBunRuntime, isTTY } from "./utils/runtime.js";
+import * as dotenv from "dotenv";
+
+// Load config from unified location
+dotenv.config({ path: getEnvPath() });
+
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import {
@@ -5,7 +13,6 @@ import {
   ListToolsRequestSchema,
 } from "@modelcontextprotocol/sdk/types.js";
 import { z } from "zod";
-import "dotenv/config";
 
 // Import constants
 import {
@@ -17,17 +24,54 @@ import {
 import { validateEnv } from "./config/env.js";
 
 // Import implementations
-import { getVectorStore } from "./db/lancedb.js";
+import { getVectorStore, getChunkStore } from "./db/lancedb.js";
 import { getNoteByTitle, getAllFolders } from "./notes/read.js";
-import { createNote, updateNote, deleteNote, moveNote, editTable } from "./notes/crud.js";
+import { createNote, updateNote, deleteNote, moveNote, editTable, batchDelete, batchMove } from "./notes/crud.js";
 import { searchNotes } from "./search/index.js";
 import { indexNotes, reindexNote } from "./search/indexer.js";
+import { fullChunkIndex, hasChunkIndex } from "./search/chunk-indexer.js";
+import { searchChunks } from "./search/chunk-search.js";
+import { refreshIfNeeded } from "./search/refresh.js";
+import { listTags, searchByTag, findRelatedNotes } from "./graph/queries.js";
+import { exportGraph } from "./graph/export.js";
 
 // Debug logging and error handling
 import { createDebugLogger } from "./utils/debug.js";
 import { sanitizeErrorMessage } from "./utils/errors.js";
 const debug = createDebugLogger("MCP");
 
+// Runtime and config checks
+checkBunRuntime();
+
+if (!hasConfig()) {
+  if (isTTY()) {
+    // Interactive terminal - run setup wizard
+    console.log("No configuration found. Starting setup wizard...\n");
+    const { spawn } = await import("node:child_process");
+    const setupPath = new URL("./setup.ts", import.meta.url).pathname;
+    const child = spawn("bun", ["run", setupPath], {
+      stdio: "inherit",
+    });
+    child.on("exit", (code) => process.exit(code ?? 0));
+    // Wait for setup to complete
+    await new Promise(() => {}); // Setup will exit the process
+  } else {
+    // Non-interactive (MCP server mode) - show error
+    console.error(`
+╭─────────────────────────────────────────────────────────────╮
+│  apple-notes-mcp: Configuration required                    │
+│                                                             │
+│  Run this command in your terminal first:                   │
+│                                                             │
+│      apple-notes-mcp                                        │
+│                                                             │
+│  The setup wizard will guide you through configuration.     │
+╰─────────────────────────────────────────────────────────────╯
+`);
+    process.exit(1);
+  }
+}
+
 // Tool parameter schemas
 const SearchNotesSchema = z.object({
   query: z.string().min(1, "Query cannot be empty").max(MAX_INPUT_LENGTH),
@@ -82,6 +126,48 @@ const EditTableSchema = z.object({
   })).min(1).max(100),
 });
 
+const BatchDeleteSchema = z.object({
+  titles: z.array(z.string().max(MAX_TITLE_LENGTH)).optional(),
+  folder: z.string().max(200).optional(),
+  confirm: z.literal(true),
+}).refine(
+  (data) => (data.titles && !data.folder) || (!data.titles && data.folder),
+  { message: "Specify either titles or folder, not both" }
+);
+
+const BatchMoveSchema = z.object({
+  titles: z.array(z.string().max(MAX_TITLE_LENGTH)).optional(),
+  sourceFolder: z.string().max(200).optional(),
+  targetFolder: z.string().min(1).max(200),
+}).refine(
+  (data) => (data.titles && !data.sourceFolder) || (!data.titles && data.sourceFolder),
+  { message: "Specify either titles or sourceFolder, not both" }
+);
+
+const PurgeIndexSchema = z.object({
+  confirm: z.literal(true),
+});
+
+// Knowledge Graph tool schemas
+const ListTagsSchema = z.object({});
+
+const SearchByTagSchema = z.object({
+  tag: z.string().min(1).max(100),
+  folder: z.string().max(200).optional(),
+  limit: z.number().min(1).max(MAX_SEARCH_LIMIT).default(DEFAULT_SEARCH_LIMIT),
+});
+
+const RelatedNotesSchema = z.object({
+  title: z.string().min(1).max(MAX_TITLE_LENGTH),
+  types: z.array(z.enum(["tag", "link", "similar"])).default(["tag", "link", "similar"]),
+  limit: z.number().min(1).max(50).default(10),
+});
+
+const ExportGraphSchema = z.object({
+  format: z.enum(["json", "graphml"]),
+  folder: z.string().max(200).optional(),
+});
+
 // Create MCP server
 const server = new Server(
   {
@@ -166,6 +252,17 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
           required: ["title"],
         },
       },
+      {
+        name: "purge-index",
+        description: "Delete all indexed data (notes and chunks). Use when switching embedding models or to fix corrupted index.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            confirm: { type: "boolean", description: "Must be true to confirm deletion" },
+          },
+          required: ["confirm"],
+        },
+      },
       {
         name: "list-notes",
         description: "Count how many notes are indexed",
@@ -271,6 +368,108 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
           required: ["title", "edits"],
         },
       },
+      {
+        name: "batch-delete",
+        description: "Delete multiple notes at once. Requires confirm: true for safety.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            titles: {
+              type: "array",
+              items: { type: "string" },
+              description: "Note titles to delete (supports folder/title and id:xxx formats)",
+            },
+            folder: {
+              type: "string",
+              description: "Delete ALL notes in this folder",
+            },
+            confirm: {
+              type: "boolean",
+              description: "Must be true to confirm deletion",
+            },
+          },
+          required: ["confirm"],
+        },
+      },
+      {
+        name: "batch-move",
+        description: "Move multiple notes to a target folder at once.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            titles: {
+              type: "array",
+              items: { type: "string" },
+              description: "Note titles to move (supports folder/title and id:xxx formats)",
+            },
+            sourceFolder: {
+              type: "string",
+              description: "Move ALL notes from this folder",
+            },
+            targetFolder: {
+              type: "string",
+              description: "Target folder to move notes to",
+            },
+          },
+          required: ["targetFolder"],
+        },
+      },
+      // Knowledge Graph tools
+      {
+        name: "list-tags",
+        description: "List all tags with occurrence counts",
+        inputSchema: {
+          type: "object",
+          properties: {},
+          required: [],
+        },
+      },
+      {
+        name: "search-by-tag",
+        description: "Find notes with a specific tag",
+        inputSchema: {
+          type: "object",
+          properties: {
+            tag: { type: "string", description: "Tag to search for (without #)" },
+            folder: { type: "string", description: "Filter by folder (optional)" },
+            limit: { type: "number", description: "Max results (default: 20)" },
+          },
+          required: ["tag"],
+        },
+      },
+      {
+        name: "related-notes",
+        description: "Find notes related to a source note by tags, links, or semantic similarity",
+        inputSchema: {
+          type: "object",
+          properties: {
+            title: { type: "string", description: "Source note title (use folder/title or id:xxx)" },
+            types: {
+              type: "array",
+              items: { type: "string", enum: ["tag", "link", "similar"] },
+              description: "Relationship types to include (default: all)"
+            },
+            limit: { type: "number", description: "Max results (default: 10)" },
+          },
+          required: ["title"],
+        },
+      },
+      {
+        name: "export-graph",
+        description: "Export knowledge graph to JSON or GraphML format for visualization",
+        inputSchema: {
+          type: "object",
+          properties: {
+            format: {
+              type: "string",
+              enum: ["json", "graphml"],
+              description: "Export format: json (for D3.js, custom viz) or graphml (for Gephi, yEd)"
+            },
+            folder: { type: "string", description: "Filter by folder (optional)" },
+          },
+          required: ["format"],
+        },
+      },
     ],
   };
 });
@@ -285,6 +484,44 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       // Read tools
       case "search-notes": {
         const params = SearchNotesSchema.parse(args);
+
+        // Smart refresh: check for changes before search
+        const refreshed = await refreshIfNeeded();
+        if (refreshed) {
+          debug("Index refreshed before search");
+        }
+
+        // Use chunk-based search if chunk index exists (better for long notes)
+        const useChunkSearch = await hasChunkIndex();
+
+        if (useChunkSearch) {
+          debug("Using chunk-based search");
+          const chunkResults = await searchChunks(params.query, {
+            folder: params.folder,
+            limit: params.limit,
+            mode: params.mode,
+          });
+
+          if (chunkResults.length === 0) {
+            return textResponse("No notes found matching your query.");
+          }
+
+          // Transform chunk results to match expected format
+          const results = chunkResults.map((r) => ({
+            id: r.note_id,
+            title: r.note_title,
+            folder: r.folder,
+            preview: r.matchedChunk.slice(0, 200) + (r.matchedChunk.length > 200 ? "..." : ""),
+            modified: r.modified,
+            score: r.score,
+            matchedChunkIndex: r.matchedChunkIndex,
+          }));
+
+          return textResponse(JSON.stringify(results, null, 2));
+        }
+
+        // Fall back to legacy search if no chunk index
+        debug("Using legacy search (no chunk index)");
         const results = await searchNotes(params.query, {
           folder: params.folder,
           limit: params.limit,
@@ -316,6 +553,13 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           }
         }
 
+        // Run chunk indexing for full mode (for semantic search on long notes)
+        if (params.mode === "full") {
+          debug("Running chunk indexing for full mode...");
+          const chunkResult = await fullChunkIndex();
+          message += `\nChunk index: ${chunkResult.totalChunks} chunks from ${chunkResult.totalNotes} notes in ${(chunkResult.timeMs / 1000).toFixed(1)}s`;
+        }
+
         return textResponse(message);
       }
 
@@ -325,10 +569,34 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         return textResponse(`Reindexed note: "${params.title}"`);
       }
 
+      case "purge-index": {
+        PurgeIndexSchema.parse(args);
+        const store = getVectorStore();
+        const chunkStore = getChunkStore();
+
+        await store.clear();
+        await chunkStore.clear();
+
+        return textResponse("Index purged. Run index-notes to rebuild.");
+      }
+
       case "list-notes": {
         const store = getVectorStore();
-        const count = await store.count();
-        return textResponse(`${count} notes indexed. Run index-notes to update the index.`);
+        const noteCount = await store.count();
+
+        let message = `${noteCount} notes indexed.`;
+
+        // Show chunk statistics if chunk index exists
+        const hasChunks = await hasChunkIndex();
+        if (hasChunks) {
+          const chunkStore = getChunkStore();
+          const chunkCount = await chunkStore.count();
+          message += ` ${chunkCount} chunks indexed for semantic search.`;
+        } else {
+          message += " Run index-notes with mode='full' to enable chunk-based search.";
+        }
+
+        return textResponse(message);
       }
 
       case "get-note": {
@@ -363,19 +631,27 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 
       case "update-note": {
         const params = UpdateNoteSchema.parse(args);
-        await updateNote(params.title, params.content);
+        const result = await updateNote(params.title, params.content);
+
+        // Build location string for messages
+        const location = `${result.folder}/${result.newTitle}`;
+        const renamedMsg = result.titleChanged
+          ? ` (renamed from "${result.originalTitle}")`
+          : "";
 
         if (params.reindex) {
           try {
-            await reindexNote(params.title);
-            return textResponse(`Updated and reindexed note: "${params.title}"`);
+            // Use new title for reindexing (Apple Notes may have renamed it)
+            const reindexTitle = `${result.folder}/${result.newTitle}`;
+            await reindexNote(reindexTitle);
+            return textResponse(`Updated and reindexed note: "${location}"${renamedMsg}`);
           } catch (reindexError) {
             debug("Reindex after update failed:", reindexError);
-            return textResponse(`Updated note: "${params.title}" (reindexing failed, run index-notes to update)`);
+            return textResponse(`Updated note: "${location}"${renamedMsg} (reindexing failed, run index-notes to update)`);
           }
         }
 
-        return textResponse(`Updated note: "${params.title}"`);
+        return textResponse(`Updated note: "${location}"${renamedMsg}`);
       }
 
       case "delete-note": {
@@ -399,6 +675,96 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         return textResponse(`Updated ${params.edits.length} cell(s) in table ${params.table_index}`);
       }
 
+      case "batch-delete": {
+        const params = BatchDeleteSchema.parse(args);
+        const result = await batchDelete({
+          titles: params.titles,
+          folder: params.folder,
+        });
+
+        let message = `Deleted ${result.deleted} notes.`;
+        if (result.failed.length > 0) {
+          message += `\nFailed to delete: ${result.failed.join(", ")}`;
+        }
+        return textResponse(message);
+      }
+
+      case "batch-move": {
+        const params = BatchMoveSchema.parse(args);
+        const result = await batchMove({
+          titles: params.titles,
+          sourceFolder: params.sourceFolder,
+          targetFolder: params.targetFolder,
+        });
+
+        let message = `Moved ${result.moved} notes to "${params.targetFolder}".`;
+        if (result.failed.length > 0) {
+          message += `\nFailed to move: ${result.failed.join(", ")}`;
+        }
+        return textResponse(message);
+      }
+
+      // Knowledge Graph tools
+      case "list-tags": {
+        ListTagsSchema.parse(args);
+        const tags = await listTags();
+
+        if (tags.length === 0) {
+          return textResponse("No tags found. Add #tags to your notes and reindex.");
+        }
+
+        return textResponse(JSON.stringify(tags, null, 2));
+      }
+
+      case "search-by-tag": {
+        const params = SearchByTagSchema.parse(args);
+        const results = await searchByTag(params.tag, {
+          folder: params.folder,
+          limit: params.limit,
+        });
+
+        if (results.length === 0) {
+          return textResponse(`No notes found with tag: #${params.tag}`);
+        }
+
+        return textResponse(JSON.stringify(results, null, 2));
+      }
+
+      case "related-notes": {
+        const params = RelatedNotesSchema.parse(args);
+
+        // Resolve note to get ID
+        const note = await getNoteByTitle(params.title);
+        if (!note) {
+          return errorResponse(`Note not found: "${params.title}"`);
+        }
+
+        const results = await findRelatedNotes(note.id, {
+          types: params.types,
+          limit: params.limit,
+        });
+
+        if (results.length === 0) {
+          return textResponse("No related notes found.");
+        }
+
+        return textResponse(JSON.stringify(results, null, 2));
+      }
+
+      case "export-graph": {
+        const params = ExportGraphSchema.parse(args);
+        const result = await exportGraph({
+          format: params.format,
+          folder: params.folder,
+        });
+
+        if (typeof result === "string") {
+          return textResponse(result);
+        }
+
+        return textResponse(JSON.stringify(result, null, 2));
+      }
+
       default:
         return errorResponse(`Unknown tool: ${name}`);
     }

package/src/notes/crud.test.ts

@@ -28,7 +28,7 @@ vi.mock("./tables.js", () => ({
 }));
 
 import { runJxa } from "run-jxa";
-import { checkReadOnly, createNote, updateNote, deleteNote, moveNote, editTable } from "./crud.js";
+import { checkReadOnly, createNote, updateNote, deleteNote, moveNote, editTable, batchDelete, batchMove } from "./crud.js";
 import { resolveNoteTitle } from "./read.js";
 import { findTables, updateTableCell } from "./tables.js";
 
@@ -111,9 +111,33 @@ describe("updateNote", () => {
       success: true,
       note: { id: "123", title: "Test", folder: "Work" },
     });
-    vi.mocked(runJxa).mockResolvedValueOnce("ok");
+    // Mock JXA returning the new title (same as original in this case)
+    vi.mocked(runJxa).mockResolvedValueOnce(JSON.stringify({ newTitle: "Test" }));
+
+    const result = await updateNote("Test", "New Content");
+    expect(result).toEqual({
+      originalTitle: "Test",
+      newTitle: "Test",
+      folder: "Work",
+      titleChanged: false,
+    });
+  });
 
-    await expect(updateNote("Test", "New Content")).resolves.toBeUndefined();
+  it("should detect when Apple Notes renames the note", async () => {
+    vi.mocked(resolveNoteTitle).mockResolvedValueOnce({
+      success: true,
+      note: { id: "123", title: "Original Title", folder: "Work" },
+    });
+    // Mock JXA returning a different title (Apple Notes renamed it)
+    vi.mocked(runJxa).mockResolvedValueOnce(JSON.stringify({ newTitle: "New Heading" }));
+
+    const result = await updateNote("Original Title", "# New Heading\n\nContent");
+    expect(result).toEqual({
+      originalTitle: "Original Title",
+      newTitle: "New Heading",
+      folder: "Work",
+      titleChanged: true,
+    });
   });
 
   it("should include suggestions in error when multiple notes found", async () => {
@@ -266,3 +290,124 @@ describe("editTable", () => {
     );
   });
 });
+
+describe("batchDelete", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    delete process.env.READONLY_MODE;
+  });
+
+  it("should throw if both titles and folder provided", async () => {
+    await expect(
+      batchDelete({ titles: ["Note"], folder: "Folder" })
+    ).rejects.toThrow("Specify either titles or folder, not both");
+  });
+
+  it("should throw if neither titles nor folder provided", async () => {
+    await expect(batchDelete({})).rejects.toThrow("Specify either titles or folder");
+  });
+
+  it("should throw in readonly mode", async () => {
+    process.env.READONLY_MODE = "true";
+    await expect(batchDelete({ titles: ["Note"] })).rejects.toThrow("read-only mode");
+  });
+
+  it("should delete all notes in a folder", async () => {
+    vi.mocked(runJxa).mockResolvedValue(JSON.stringify({ deletedCount: 5 }));
+
+    const result = await batchDelete({ folder: "Old Project" });
+
+    expect(result.deleted).toBe(5);
+    expect(result.failed).toEqual([]);
+  });
+
+  it("should delete individual notes by title", async () => {
+    vi.mocked(resolveNoteTitle)
+      .mockResolvedValueOnce({ success: true, note: { id: "1", title: "Note 1", folder: "Work" } })
+      .mockResolvedValueOnce({ success: true, note: { id: "2", title: "Note 2", folder: "Work" } });
+    vi.mocked(runJxa).mockResolvedValue("ok");
+
+    const result = await batchDelete({ titles: ["Note 1", "Note 2"] });
+
+    expect(result.deleted).toBe(2);
+    expect(result.failed).toEqual([]);
+  });
+
+  it("should track failed deletions", async () => {
+    vi.mocked(resolveNoteTitle)
+      .mockResolvedValueOnce({ success: true, note: { id: "1", title: "Note 1", folder: "Work" } })
+      .mockResolvedValueOnce({ success: false, error: "Note not found" });
+    vi.mocked(runJxa).mockResolvedValue("ok");
+
+    const result = await batchDelete({ titles: ["Note 1", "Missing Note"] });
+
+    expect(result.deleted).toBe(1);
+    expect(result.failed).toEqual(["Missing Note"]);
+  });
+});
+
+describe("batchMove", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    delete process.env.READONLY_MODE;
+  });
+
+  it("should throw if targetFolder missing", async () => {
+    await expect(
+      batchMove({ titles: ["Note"], targetFolder: "" })
+    ).rejects.toThrow("targetFolder is required");
+  });
+
+  it("should throw if both titles and sourceFolder provided", async () => {
+    await expect(
+      batchMove({ titles: ["Note"], sourceFolder: "Folder", targetFolder: "Archive" })
+    ).rejects.toThrow("Specify either titles or sourceFolder, not both");
+  });
+
+  it("should throw if neither titles nor sourceFolder provided", async () => {
+    await expect(
+      batchMove({ targetFolder: "Archive" })
+    ).rejects.toThrow("Specify either titles or sourceFolder");
+  });
+
+  it("should throw in readonly mode", async () => {
+    process.env.READONLY_MODE = "true";
+    await expect(batchMove({ sourceFolder: "Temp", targetFolder: "Archive" })).rejects.toThrow("read-only mode");
+  });
+
+  it("should move all notes from source folder", async () => {
+    vi.mocked(runJxa).mockResolvedValue(JSON.stringify({ movedCount: 3 }));
+
+    const result = await batchMove({
+      sourceFolder: "Temp",
+      targetFolder: "Archive",
+    });
+
+    expect(result.moved).toBe(3);
+    expect(result.failed).toEqual([]);
+  });
+
+  it("should move individual notes by title", async () => {
+    vi.mocked(resolveNoteTitle)
+      .mockResolvedValueOnce({ success: true, note: { id: "1", title: "Note 1", folder: "Work" } })
+      .mockResolvedValueOnce({ success: true, note: { id: "2", title: "Note 2", folder: "Work" } });
+    vi.mocked(runJxa).mockResolvedValue("ok");
+
+    const result = await batchMove({ titles: ["Note 1", "Note 2"], targetFolder: "Archive" });
+
+    expect(result.moved).toBe(2);
+    expect(result.failed).toEqual([]);
+  });
+
+  it("should track failed moves", async () => {
+    vi.mocked(resolveNoteTitle)
+      .mockResolvedValueOnce({ success: true, note: { id: "1", title: "Note 1", folder: "Work" } })
+      .mockResolvedValueOnce({ success: false, error: "Note not found" });
+    vi.mocked(runJxa).mockResolvedValue("ok");
+
+    const result = await batchMove({ titles: ["Note 1", "Missing Note"], targetFolder: "Archive" });
+
+    expect(result.moved).toBe(1);
+    expect(result.failed).toEqual(["Missing Note"]);
+  });
+});