@disco_trooper/apple-notes-mcp 1.0.1 → 1.2.0

package/package.json

@@ -1,10 +1,9 @@
 {
   "name": "@disco_trooper/apple-notes-mcp",
-  "version": "1.0.1",
+  "version": "1.2.0",
   "description": "MCP server for Apple Notes with semantic search and CRUD operations",
   "type": "module",
   "main": "src/index.ts",
-  "module": "src/server.ts",
   "scripts": {
     "start": "bun run src/index.ts",
     "setup": "bun run src/setup.ts",
@@ -25,7 +24,6 @@
     "dotenv": "^16.4.0"
   },
   "devDependencies": {
-    "@smithery/cli": "^3.0.3",
     "@types/bun": "^1.1.0",
     "@types/turndown": "^5.0.0",
     "typescript": "^5.7.0",
@@ -45,8 +43,7 @@
   },
   "files": [
     "src",
-    "README.md",
-    "CLAUDE.md"
+    "README.md"
   ],
   "engines": {
     "node": ">=18"

package/src/db/lancedb.test.ts

@@ -20,6 +20,7 @@ describe("LanceDBStore", () => {
   });
 
   const createTestRecord = (title: string): NoteRecord => ({
+    id: `test-id-${title.toLowerCase().replace(/\s+/g, "-")}`,
     title,
     folder: "Test",
     content: `Content of ${title}`,
@@ -138,4 +139,48 @@ describe("LanceDBStore", () => {
       expect(results[0]).toHaveProperty("score");
     });
   });
+
+  describe("rebuildFtsIndex", () => {
+    it("rebuilds FTS index without error", async () => {
+      await store.index([
+        createTestRecord("FTS Note 1"),
+        createTestRecord("FTS Note 2"),
+      ]);
+
+      await expect(store.rebuildFtsIndex()).resolves.not.toThrow();
+    });
+
+    it("works after indexing records", async () => {
+      await store.index([createTestRecord("Note A")]);
+
+      // Rebuild should work on existing table
+      await expect(store.rebuildFtsIndex()).resolves.not.toThrow();
+
+      // Index more records and rebuild again
+      await store.index([createTestRecord("Note B")]);
+      await expect(store.rebuildFtsIndex()).resolves.not.toThrow();
+    });
+  });
+
+  describe("searchFTS", () => {
+    it("returns results matching query text", async () => {
+      await store.index([
+        createTestRecord("Meeting notes"),
+        createTestRecord("Shopping list"),
+      ]);
+      await store.rebuildFtsIndex();
+
+      const results = await store.searchFTS("Meeting", 10);
+      expect(results.length).toBeGreaterThanOrEqual(1);
+      expect(results[0].title).toBe("Meeting notes");
+    });
+
+    it("returns empty array for no matches", async () => {
+      await store.index([createTestRecord("Test note")]);
+      await store.rebuildFtsIndex();
+
+      const results = await store.searchFTS("nonexistentquery12345", 10);
+      expect(results).toHaveLength(0);
+    });
+  });
 });

package/src/db/lancedb.ts

@@ -7,6 +7,7 @@ import { createDebugLogger } from "../utils/debug.js";
 
 // Schema for stored notes
 export interface NoteRecord {
+  id: string;           // Apple Notes unique identifier
   title: string;
   content: string;
   vector: number[];
@@ -32,11 +33,26 @@ export interface VectorStore {
   getAll(): Promise<NoteRecord[]>;
   count(): Promise<number>;
   clear(): Promise<void>;
+  rebuildFtsIndex(): Promise<void>;
 }
 
 // Debug logging
 const debug = createDebugLogger("DB");
 
+/**
+ * Convert a database row to a SearchResult with rank-based score.
+ */
+function rowToSearchResult(row: Record<string, unknown>, index: number): SearchResult {
+  return {
+    id: row.id as string | undefined,
+    title: row.title as string,
+    folder: row.folder as string,
+    content: row.content as string,
+    modified: row.modified as string,
+    score: 1 / (1 + index),
+  };
+}
+
 // LanceDB implementation
 export class LanceDBStore implements VectorStore {
   private db: lancedb.Connection | null = null;
@@ -83,8 +99,8 @@ export class LanceDBStore implements VectorStore {
     try {
       await db.dropTable(this.tableName);
       debug(`Dropped existing table: ${this.tableName}`);
-    } catch {
-      // Table didn't exist, that's fine
+    } catch (error) {
+      debug("Table drop skipped (table may not exist):", error);
     }
 
     // Create new table with records
@@ -106,13 +122,8 @@ export class LanceDBStore implements VectorStore {
 
     // Add new record first (LanceDB allows duplicates with same title)
     // This ensures we never lose data - if add fails, old record still exists
-    try {
-      await table.add([record]);
-      debug(`Added new version of record: ${record.title}`);
-    } catch (addError) {
-      // If add fails, old record still exists, throw original error
-      throw addError;
-    }
+    await table.add([record]);
+    debug(`Added new version of record: ${record.title}`);
 
     // Now delete old record(s) - use indexed_at to identify which is old
     const validTitle = validateTitle(record.title);
@@ -165,35 +176,21 @@ export class LanceDBStore implements VectorStore {
       .limit(limit)
       .toArray();
 
-    return results.map((row, index) => ({
-      title: row.title as string,
-      folder: row.folder as string,
-      content: row.content as string,
-      modified: row.modified as string,
-      score: 1 / (1 + index), // Simple rank-based score
-    }));
+    return results.map(rowToSearchResult);
   }
 
   async searchFTS(query: string, limit: number): Promise<SearchResult[]> {
     const table = await this.ensureTable();
 
     try {
-      // LanceDB FTS search - use queryType option
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      const results = await (table as any)
-        .search(query, { queryType: "fts" })
+      const results = await table
+        .query()
+        .fullTextSearch(query)
         .limit(limit)
         .toArray();
 
-      return results.map((row: Record<string, unknown>, index: number) => ({
-        title: row.title as string,
-        folder: row.folder as string,
-        content: row.content as string,
-        modified: row.modified as string,
-        score: 1 / (1 + index),
-      }));
+      return results.map(rowToSearchResult);
     } catch (error) {
-      // FTS might fail if no index or no matches
       debug("FTS search failed, returning empty results. Error:", error);
       return [];
     }
@@ -221,6 +218,7 @@ export class LanceDBStore implements VectorStore {
     const results = await table.query().toArray();
 
     return results.map((row) => ({
+      id: (row.id as string) ?? "",
       title: row.title as string,
       content: row.content as string,
       vector: row.vector as number[],
@@ -235,7 +233,8 @@ export class LanceDBStore implements VectorStore {
     try {
       const table = await this.ensureTable();
       return await table.countRows();
-    } catch {
+    } catch (error) {
+      debug("Count failed (table may not exist):", error);
       return 0;
     }
   }
@@ -246,10 +245,20 @@ export class LanceDBStore implements VectorStore {
       await db.dropTable(this.tableName);
       this.table = null;
       debug("Cleared table");
-    } catch {
-      // Table didn't exist
+    } catch (error) {
+      debug("Clear skipped (table may not exist):", error);
     }
   }
+
+  async rebuildFtsIndex(): Promise<void> {
+    const table = await this.ensureTable();
+    debug("Rebuilding FTS index on content");
+    await table.createIndex("content", {
+      config: lancedb.Index.fts(),
+      replace: true,
+    });
+    debug("FTS index rebuilt");
+  }
 }
 
 // Singleton instance

package/src/embeddings/index.ts

@@ -41,10 +41,9 @@ export function detectProvider(): EmbeddingProvider {
 
 /**
  * Get the current embedding provider.
- * Call detectProvider() first to ensure detection has occurred.
  */
 export function getProvider(): EmbeddingProvider {
-  return detectedProvider || detectProvider();
+  return detectedProvider ?? detectProvider();
 }
 
 /**

package/src/embeddings/local.ts

@@ -31,7 +31,6 @@ type FeatureExtractionPipeline = (
 
 let pipelineInstance: FeatureExtractionPipeline | null = null;
 let pipelinePromise: Promise<FeatureExtractionPipeline> | null = null;
-let resolvedModel: string | null = null;
 
 /**
  * Get the configured model name.
@@ -82,8 +81,6 @@ async function getPipeline(): Promise<FeatureExtractionPipeline> {
       debug(`Model loaded in ${loadTime}ms`);
 
       pipelineInstance = pipe;
-      resolvedModel = modelName;
-
       return pipe;
     } catch (error) {
       // Reset promise so next call retries
@@ -181,11 +178,3 @@ export function getLocalModelName(): string {
 export function isModelLoaded(): boolean {
   return pipelineInstance !== null;
 }
-
-/**
- * Get the name of the actually loaded model.
- * Returns null if no model has been loaded yet.
- */
-export function getLoadedModelName(): string | null {
-  return resolvedModel;
-}

package/src/errors/index.test.ts

@@ -0,0 +1,64 @@
+// src/errors/index.test.ts
+import { describe, it, expect } from "vitest";
+import {
+  NoteNotFoundError,
+  ReadOnlyModeError,
+  DuplicateNoteError,
+  FolderNotFoundError,
+  TableOutOfBoundsError,
+} from "./index.js";
+
+describe("Error Classes", () => {
+  describe("NoteNotFoundError", () => {
+    it("should have correct name and message", () => {
+      const error = new NoteNotFoundError("My Note");
+      expect(error.name).toBe("NoteNotFoundError");
+      expect(error.message).toBe('Note not found: "My Note"');
+      expect(error.title).toBe("My Note");
+      expect(error instanceof Error).toBe(true);
+    });
+  });
+
+  describe("ReadOnlyModeError", () => {
+    it("should have correct name and message", () => {
+      const error = new ReadOnlyModeError();
+      expect(error.name).toBe("ReadOnlyModeError");
+      expect(error.message).toBe("Operation disabled in read-only mode");
+      expect(error instanceof Error).toBe(true);
+    });
+  });
+
+  describe("DuplicateNoteError", () => {
+    it("should have correct name and suggestions", () => {
+      const suggestions = [
+        { id: "id-1", folder: "Work", title: "Note", created: "2026-01-09T10:00:00.000Z" },
+        { id: "id-2", folder: "Personal", title: "Note", created: "2026-01-09T11:00:00.000Z" },
+      ];
+      const error = new DuplicateNoteError("Note", suggestions);
+      expect(error.name).toBe("DuplicateNoteError");
+      expect(error.title).toBe("Note");
+      expect(error.suggestions).toEqual(suggestions);
+      expect(error.message).toContain("Multiple notes found");
+      expect(error.message).toContain("id:id-1");
+      expect(error.message).toContain("id:id-2");
+    });
+  });
+
+  describe("FolderNotFoundError", () => {
+    it("should have correct name and message", () => {
+      const error = new FolderNotFoundError("Work");
+      expect(error.name).toBe("FolderNotFoundError");
+      expect(error.folder).toBe("Work");
+      expect(error.message).toBe('Folder not found: "Work"');
+    });
+  });
+
+  describe("TableOutOfBoundsError", () => {
+    it("should have correct name and message", () => {
+      const error = new TableOutOfBoundsError("Row 5 out of bounds (table has 3 rows)");
+      expect(error.name).toBe("TableOutOfBoundsError");
+      expect(error.message).toBe("Row 5 out of bounds (table has 3 rows)");
+      expect(error instanceof Error).toBe(true);
+    });
+  });
+});

package/src/errors/index.ts

@@ -0,0 +1,62 @@
+/**
+ * Typed error classes for better error handling.
+ */
+
+export class NoteNotFoundError extends Error {
+  readonly title: string;
+
+  constructor(title: string) {
+    super(`Note not found: "${title}"`);
+    this.name = "NoteNotFoundError";
+    this.title = title;
+  }
+}
+
+export class ReadOnlyModeError extends Error {
+  constructor() {
+    super("Operation disabled in read-only mode");
+    this.name = "ReadOnlyModeError";
+  }
+}
+
+/**
+ * Rich suggestion for duplicate note disambiguation.
+ */
+export interface NoteSuggestion {
+  id: string;
+  folder: string;
+  title: string;
+  created: string;
+}
+
+export class DuplicateNoteError extends Error {
+  readonly title: string;
+  readonly suggestions: NoteSuggestion[];
+
+  constructor(title: string, suggestions: NoteSuggestion[]) {
+    const suggestionList = suggestions
+      .map(s => `id:${s.id} (${s.folder}, created: ${s.created.split("T")[0]})`)
+      .join("\n  - ");
+    super(`Multiple notes found with title "${title}". Use ID prefix:\n  - ${suggestionList}`);
+    this.name = "DuplicateNoteError";
+    this.title = title;
+    this.suggestions = suggestions;
+  }
+}
+
+export class FolderNotFoundError extends Error {
+  readonly folder: string;
+
+  constructor(folder: string) {
+    super(`Folder not found: "${folder}"`);
+    this.name = "FolderNotFoundError";
+    this.folder = folder;
+  }
+}
+
+export class TableOutOfBoundsError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "TableOutOfBoundsError";
+  }
+}

package/src/index.ts

@@ -8,13 +8,18 @@ import { z } from "zod";
 import "dotenv/config";
 
 // Import constants
-import { DEFAULT_SEARCH_LIMIT, MAX_SEARCH_LIMIT } from "./config/constants.js";
+import {
+  DEFAULT_SEARCH_LIMIT,
+  MAX_SEARCH_LIMIT,
+  MAX_INPUT_LENGTH,
+  MAX_TITLE_LENGTH
+} from "./config/constants.js";
 import { validateEnv } from "./config/env.js";
 
 // Import implementations
 import { getVectorStore } from "./db/lancedb.js";
 import { getNoteByTitle, getAllFolders } from "./notes/read.js";
-import { createNote, updateNote, deleteNote, moveNote } from "./notes/crud.js";
+import { createNote, updateNote, deleteNote, moveNote, editTable } from "./notes/crud.js";
 import { searchNotes } from "./search/index.js";
 import { indexNotes, reindexNote } from "./search/indexer.js";
 
@@ -25,8 +30,8 @@ const debug = createDebugLogger("MCP");
 
 // Tool parameter schemas
 const SearchNotesSchema = z.object({
-  query: z.string().min(1, "Query cannot be empty"),
-  folder: z.string().optional(),
+  query: z.string().min(1, "Query cannot be empty").max(MAX_INPUT_LENGTH),
+  folder: z.string().max(200).optional(),
   limit: z.number().min(1).max(MAX_SEARCH_LIMIT).default(DEFAULT_SEARCH_LIMIT),
   mode: z.enum(["hybrid", "keyword", "semantic"]).default("hybrid"),
   include_content: z.boolean().default(false),
@@ -38,33 +43,43 @@ const IndexNotesSchema = z.object({
 });
 
 const ReindexNoteSchema = z.object({
-  title: z.string(),
+  title: z.string().min(1).max(MAX_TITLE_LENGTH),
 });
 
 const GetNoteSchema = z.object({
-  title: z.string(),
+  title: z.string().min(1).max(MAX_TITLE_LENGTH),
 });
 
 const CreateNoteSchema = z.object({
-  title: z.string(),
-  content: z.string(),
-  folder: z.string().optional(),
+  title: z.string().min(1).max(MAX_TITLE_LENGTH),
+  content: z.string().min(1).max(MAX_INPUT_LENGTH),
+  folder: z.string().max(200).optional(),
 });
 
 const UpdateNoteSchema = z.object({
-  title: z.string(),
-  content: z.string(),
+  title: z.string().min(1).max(MAX_TITLE_LENGTH),
+  content: z.string().min(1).max(MAX_INPUT_LENGTH),
   reindex: z.boolean().default(true),
 });
 
 const DeleteNoteSchema = z.object({
-  title: z.string(),
+  title: z.string().min(1).max(MAX_TITLE_LENGTH),
   confirm: z.boolean(),
 });
 
 const MoveNoteSchema = z.object({
-  title: z.string(),
-  folder: z.string(),
+  title: z.string().min(1).max(MAX_TITLE_LENGTH),
+  folder: z.string().min(1).max(200),
+});
+
+const EditTableSchema = z.object({
+  title: z.string().min(1).max(MAX_TITLE_LENGTH),
+  table_index: z.number().min(0).default(0),
+  edits: z.array(z.object({
+    row: z.number().min(0),
+    column: z.number().min(0),
+    value: z.string().max(10000),
+  })).min(1).max(100),
 });
 
 // Create MCP server
@@ -231,6 +246,31 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
           required: ["title", "folder"],
         },
       },
+      {
+        name: "edit-table",
+        description: "Edit cells in a table within a note. Use for updating table data without rewriting the entire note.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            title: { type: "string", description: "Note title (use folder/title for disambiguation)" },
+            table_index: { type: "number", description: "Which table to edit (0 = first table, default: 0)" },
+            edits: {
+              type: "array",
+              description: "Array of cell edits",
+              items: {
+                type: "object",
+                properties: {
+                  row: { type: "number", description: "Row index (0 = header row)" },
+                  column: { type: "number", description: "Column index (0 = first column)" },
+                  value: { type: "string", description: "New cell value" },
+                },
+                required: ["row", "column", "value"],
+              },
+            },
+          },
+          required: ["title", "edits"],
+        },
+      },
     ],
   };
 });
@@ -353,6 +393,12 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         return textResponse(`Moved note: "${params.title}" to folder "${params.folder}"`);
       }
 
+      case "edit-table": {
+        const params = EditTableSchema.parse(args);
+        await editTable(params.title, params.table_index, params.edits);
+        return textResponse(`Updated ${params.edits.length} cell(s) in table ${params.table_index}`);
+      }
+
       default:
         return errorResponse(`Unknown tool: ${name}`);
     }

package/src/notes/conversion.ts

@@ -0,0 +1,62 @@
+/**
+ * HTML to Markdown conversion for Apple Notes content.
+ */
+
+import TurndownService from "turndown";
+
+// Initialize Turndown for HTML to Markdown conversion
+const turndownService = new TurndownService({
+  headingStyle: "atx",
+  codeBlockStyle: "fenced",
+  bulletListMarker: "-",
+});
+
+// Add custom rule to handle Apple Notes attachment placeholders
+turndownService.addRule("attachments", {
+  filter: (node) => {
+    // Apple Notes uses object tags for attachments
+    return node.nodeName === "OBJECT" || node.nodeName === "IMG";
+  },
+  replacement: (_content, node) => {
+    // Turndown uses its own Node type, cast to access attributes
+    const element = node as unknown as {
+      getAttribute: (name: string) => string | null;
+    };
+    const filename =
+      element.getAttribute("data-filename") ||
+      element.getAttribute("alt") ||
+      element.getAttribute("src")?.split("/").pop() ||
+      "unknown";
+    return `[Attachment: ${filename}]`;
+  },
+});
+
+/**
+ * Convert HTML content to Markdown, handling Apple Notes specifics.
+ */
+export function htmlToMarkdown(html: string): string {
+  if (!html) return "";
+
+  // Pre-process: handle Apple Notes specific markup
+  let processed = html;
+
+  // Replace attachment objects with placeholder text before Turndown
+  processed = processed.replace(
+    /<object[^>]*data-filename="([^"]*)"[^>]*>.*?<\/object>/gi,
+    "[Attachment: $1]"
+  );
+
+  // Handle inline images
+  processed = processed.replace(
+    /<img[^>]*(?:alt="([^"]*)")?[^>]*>/gi,
+    (_match, alt) => {
+      const filename = alt || "image";
+      return `[Attachment: ${filename}]`;
+    }
+  );
+
+  // Convert to Markdown
+  const markdown = turndownService.turndown(processed);
+
+  return markdown.trim();
+}