@disco_trooper/apple-notes-mcp 1.7.0 → 1.8.2

package/src/search/write-sync.test.ts

@@ -0,0 +1,133 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const mockVectorStore = {
+  deleteByFolderAndTitle: vi.fn(),
+  deleteByIdAndFolderAndTitle: vi.fn(),
+};
+
+const mockChunkStore = {
+  deleteChunksByNoteIds: vi.fn(),
+};
+
+vi.mock("../db/lancedb.js", () => ({
+  getVectorStore: vi.fn(() => mockVectorStore),
+  getChunkStore: vi.fn(() => mockChunkStore),
+}));
+
+vi.mock("./indexer.js", () => ({
+  reindexNote: vi.fn(),
+}));
+
+vi.mock("./chunk-indexer.js", () => ({
+  hasChunkIndex: vi.fn().mockResolvedValue(true),
+  updateChunksForNotes: vi.fn(),
+}));
+
+vi.mock("../notes/read.js", () => ({
+  getNoteById: vi.fn().mockResolvedValue({
+    id: "note-1",
+    title: "A",
+    folder: "Work",
+    content: "Content",
+    htmlContent: "<p>Content</p>",
+    created: "2026-01-01T00:00:00.000Z",
+    modified: "2026-01-01T00:00:00.000Z",
+  }),
+}));
+
+vi.mock("../utils/debug.js", () => ({
+  createDebugLogger: vi.fn(() => vi.fn()),
+}));
+
+describe("write-sync", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("syncAfterCreate reindexes vector and chunks by note id", async () => {
+    const { syncAfterCreate } = await import("./write-sync.js");
+    const { reindexNote } = await import("./indexer.js");
+    const { updateChunksForNotes } = await import("./chunk-indexer.js");
+
+    const result = await syncAfterCreate({
+      id: "note-1",
+      title: "A",
+      folder: "Work",
+      requestedTitle: "A",
+      titleChanged: false,
+    });
+
+    expect(reindexNote).toHaveBeenCalledWith("id:note-1");
+    expect(updateChunksForNotes).toHaveBeenCalled();
+    expect(result.ok).toBe(true);
+  });
+
+  it("syncAfterDelete removes vector and chunk records", async () => {
+    const { syncAfterDelete } = await import("./write-sync.js");
+
+    const result = await syncAfterDelete({
+      id: "note-1",
+      title: "A",
+      folder: "Work",
+    });
+
+    expect(mockVectorStore.deleteByIdAndFolderAndTitle).toHaveBeenCalledWith("note-1", "Work", "A");
+    expect(mockChunkStore.deleteChunksByNoteIds).toHaveBeenCalledWith(["note-1"]);
+    expect(result.ok).toBe(true);
+  });
+
+  it("syncAfterMove deletes old folder/title and reindexes by id", async () => {
+    const { syncAfterMove } = await import("./write-sync.js");
+    const { reindexNote } = await import("./indexer.js");
+
+    const result = await syncAfterMove({
+      id: "note-1",
+      title: "A",
+      fromFolder: "Work",
+      toFolder: "Archive",
+    });
+
+    expect(mockVectorStore.deleteByIdAndFolderAndTitle).toHaveBeenCalledWith("note-1", "Work", "A");
+    expect(reindexNote).toHaveBeenCalledWith("id:note-1");
+    expect(result.ok).toBe(true);
+  });
+
+  it("syncAfterUpdate deletes stale title entry when renamed", async () => {
+    const { syncAfterUpdate } = await import("./write-sync.js");
+    const { reindexNote } = await import("./indexer.js");
+
+    const result = await syncAfterUpdate({
+      id: "note-1",
+      originalTitle: "Old A",
+      newTitle: "New A",
+      folder: "Work",
+      titleChanged: true,
+    });
+
+    expect(mockVectorStore.deleteByIdAndFolderAndTitle).toHaveBeenCalledWith("note-1", "Work", "Old A");
+    expect(reindexNote).toHaveBeenCalledWith("id:note-1");
+    expect(result.ok).toBe(true);
+  });
+
+  it("reindexes before stale cleanup on move", async () => {
+    const { syncAfterMove } = await import("./write-sync.js");
+    const { reindexNote } = await import("./indexer.js");
+
+    const order: string[] = [];
+    vi.mocked(reindexNote).mockImplementation(async () => {
+      order.push("reindex");
+    });
+    mockVectorStore.deleteByIdAndFolderAndTitle.mockImplementation(async () => {
+      order.push("cleanup");
+    });
+
+    await syncAfterMove({
+      id: "note-1",
+      title: "A",
+      fromFolder: "Work",
+      toFolder: "Archive",
+    });
+
+    expect(order).toEqual(["reindex", "cleanup"]);
+  });
+});

package/src/search/write-sync.ts

@@ -0,0 +1,155 @@
+import { getVectorStore, getChunkStore } from "../db/lancedb.js";
+import { getNoteById } from "../notes/read.js";
+import {
+  hasChunkIndex,
+  updateChunksForNotes,
+} from "./chunk-indexer.js";
+import { reindexNote } from "./indexer.js";
+import type {
+  CreateResult,
+  DeleteResult,
+  MoveResult,
+  UpdateResult,
+} from "../notes/crud.js";
+import { createDebugLogger } from "../utils/debug.js";
+
+const debug = createDebugLogger("WRITE-SYNC");
+
+export interface WriteSyncResult {
+  ok: boolean;
+  warnings: string[];
+}
+
+async function trySync(action: string, operation: () => Promise<void>): Promise<string | null> {
+  try {
+    await operation();
+    return null;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    debug(`Write sync step failed (${action}):`, error);
+    return `${action}: ${message}`;
+  }
+}
+
+async function syncChunksForNoteId(noteId: string): Promise<string | null> {
+  try {
+    const hasChunks = await hasChunkIndex();
+    if (!hasChunks) {
+      return null;
+    }
+
+    const note = await getNoteById(noteId);
+    if (!note) {
+      return `chunk-sync: note not found for id ${noteId}`;
+    }
+
+    await updateChunksForNotes([note]);
+    return null;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return `chunk-sync: ${message}`;
+  }
+}
+
+function toResult(warnings: Array<string | null>): WriteSyncResult {
+  const filtered = warnings.filter((w): w is string => w !== null);
+  return {
+    ok: filtered.length === 0,
+    warnings: filtered,
+  };
+}
+
+export async function syncAfterCreate(createResult: CreateResult): Promise<WriteSyncResult> {
+  const warnings: Array<string | null> = [];
+
+  warnings.push(
+    await trySync("vector-reindex", async () => {
+      await reindexNote(`id:${createResult.id}`);
+    })
+  );
+
+  warnings.push(await syncChunksForNoteId(createResult.id));
+
+  return toResult(warnings);
+}
+
+export async function syncAfterUpdate(updateResult: UpdateResult): Promise<WriteSyncResult> {
+  const warnings: Array<string | null> = [];
+
+  const reindexWarning = await trySync("vector-reindex", async () => {
+    await reindexNote(`id:${updateResult.id}`);
+  });
+  warnings.push(reindexWarning);
+
+  // If title changed, remove stale vector entries only after successful reindex.
+  if (updateResult.titleChanged && reindexWarning === null) {
+    warnings.push(
+      await trySync("vector-delete-old-title", async () => {
+        const store = getVectorStore();
+        await store.deleteByIdAndFolderAndTitle(
+          updateResult.id,
+          updateResult.folder,
+          updateResult.originalTitle
+        );
+      })
+    );
+  }
+
+  warnings.push(await syncChunksForNoteId(updateResult.id));
+
+  return toResult(warnings);
+}
+
+export async function syncAfterDelete(deleteResult: DeleteResult): Promise<WriteSyncResult> {
+  const warnings: Array<string | null> = [];
+
+  warnings.push(
+    await trySync("vector-delete", async () => {
+      const store = getVectorStore();
+      await store.deleteByIdAndFolderAndTitle(
+        deleteResult.id,
+        deleteResult.folder,
+        deleteResult.title
+      );
+    })
+  );
+
+  warnings.push(
+    await trySync("chunk-delete", async () => {
+      const hasChunks = await hasChunkIndex();
+      if (!hasChunks) {
+        return;
+      }
+      const chunkStore = getChunkStore();
+      await chunkStore.deleteChunksByNoteIds([deleteResult.id]);
+    })
+  );
+
+  return toResult(warnings);
+}
+
+export async function syncAfterMove(moveResult: MoveResult): Promise<WriteSyncResult> {
+  const warnings: Array<string | null> = [];
+
+  const reindexWarning = await trySync("vector-reindex", async () => {
+    await reindexNote(`id:${moveResult.id}`);
+  });
+  warnings.push(reindexWarning);
+
+  if (reindexWarning === null) {
+    warnings.push(
+      await trySync("vector-delete-old-folder", async () => {
+        const store = getVectorStore();
+        await store.deleteByIdAndFolderAndTitle(
+          moveResult.id,
+          moveResult.fromFolder,
+          moveResult.title
+        );
+      })
+    );
+  }
+
+  warnings.push(await syncChunksForNoteId(moveResult.id));
+
+  return toResult(warnings);
+}