@disco_trooper/apple-notes-mcp 1.2.0 → 1.4.0

package/src/db/arrow-fix.test.ts

@@ -0,0 +1,101 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { LanceDBStore } from "./lancedb.js";
+
+describe("Arrow type inference fix", () => {
+  let tempDir: string;
+  let store: LanceDBStore;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "arrow-test-"));
+    store = new LanceDBStore(tempDir);
+  });
+
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it("handles records where ALL tags and outlinks are empty", async () => {
+    // This is the exact scenario that triggers the Arrow bug
+    const records = [
+      {
+        id: "1",
+        title: "Note 1",
+        content: "Hello world",
+        vector: new Array(384).fill(0.1),
+        folder: "Notes",
+        created: new Date().toISOString(),
+        modified: new Date().toISOString(),
+        indexed_at: new Date().toISOString(),
+        tags: [],  // Empty!
+        outlinks: [],  // Empty!
+      },
+      {
+        id: "2",
+        title: "Note 2",
+        content: "Test content",
+        vector: new Array(384).fill(0.2),
+        folder: "Notes",
+        created: new Date().toISOString(),
+        modified: new Date().toISOString(),
+        indexed_at: new Date().toISOString(),
+        tags: [],  // Empty!
+        outlinks: [],  // Empty!
+      },
+    ];
+
+    // This should NOT throw "Cannot infer list vector from empty array"
+    await store.index(records);
+
+    // Verify data was stored
+    const count = await store.count();
+    expect(count).toBe(2);
+
+    // Verify tags are empty (placeholders removed)
+    const all = await store.getAll();
+    expect(all[0].tags).toEqual([]);
+    expect(all[0].outlinks).toEqual([]);
+  });
+
+  it("handles mixed empty and non-empty arrays", async () => {
+    const records = [
+      {
+        id: "1",
+        title: "Note with tags",
+        content: "Hello",
+        vector: new Array(384).fill(0.1),
+        folder: "Notes",
+        created: new Date().toISOString(),
+        modified: new Date().toISOString(),
+        indexed_at: new Date().toISOString(),
+        tags: ["tag1", "tag2"],
+        outlinks: [],
+      },
+      {
+        id: "2",
+        title: "Note without tags",
+        content: "World",
+        vector: new Array(384).fill(0.2),
+        folder: "Notes",
+        created: new Date().toISOString(),
+        modified: new Date().toISOString(),
+        indexed_at: new Date().toISOString(),
+        tags: [],
+        outlinks: ["Note 1"],
+      },
+    ];
+
+    await store.index(records);
+
+    const all = await store.getAll();
+    const note1 = all.find(n => n.id === "1");
+    const note2 = all.find(n => n.id === "2");
+
+    expect(note1?.tags).toEqual(["tag1", "tag2"]);
+    expect(note1?.outlinks).toEqual([]);
+    expect(note2?.tags).toEqual([]);
+    expect(note2?.outlinks).toEqual(["Note 1"]);
+  });
+});

package/src/db/lancedb.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { LanceDBStore } from "./lancedb.js";
-import type { NoteRecord } from "./lancedb.js";
+import { LanceDBStore, ChunkStore } from "./lancedb.js";
+import type { NoteRecord, ChunkRecord } from "./lancedb.js";
 import * as fs from "node:fs";
 import * as path from "node:path";
 
@@ -28,6 +28,9 @@ describe("LanceDBStore", () => {
     created: new Date().toISOString(),
     indexed_at: new Date().toISOString(),
     vector: Array(384).fill(0.1),
+    // LanceDB requires at least one element to infer the list type
+    tags: ["test-tag"],
+    outlinks: ["test-link"],
   });
 
   describe("index and getByTitle", () => {
@@ -184,3 +187,207 @@ describe("LanceDBStore", () => {
     });
   });
 });
+
+describe("ChunkStore", () => {
+  let chunkStore: ChunkStore;
+  let testDbPath: string;
+
+  beforeEach(() => {
+    testDbPath = path.join("/tmp", `lancedb-chunk-test-${Date.now()}`);
+    chunkStore = new ChunkStore(testDbPath);
+  });
+
+  afterEach(() => {
+    if (fs.existsSync(testDbPath)) {
+      fs.rmSync(testDbPath, { recursive: true, force: true });
+    }
+  });
+
+  const createTestChunk = (
+    noteId: string,
+    chunkIndex: number,
+    totalChunks: number,
+    content?: string
+  ): ChunkRecord => ({
+    chunk_id: `${noteId}_chunk_${chunkIndex}`,
+    note_id: noteId,
+    note_title: `Note ${noteId}`,
+    folder: "Test",
+    chunk_index: chunkIndex,
+    total_chunks: totalChunks,
+    content: content ?? `Chunk ${chunkIndex} content for note ${noteId}`,
+    vector: Array(384).fill(0.1),
+    created: new Date().toISOString(),
+    modified: new Date().toISOString(),
+    indexed_at: new Date().toISOString(),
+    tags: ["test-tag"],
+    outlinks: ["test-link"],
+  });
+
+  describe("indexChunks", () => {
+    it("indexes chunks and allows retrieval", async () => {
+      const chunks = [
+        createTestChunk("note-1", 0, 2),
+        createTestChunk("note-1", 1, 2),
+        createTestChunk("note-2", 0, 1),
+      ];
+
+      await chunkStore.indexChunks(chunks);
+      const count = await chunkStore.count();
+
+      expect(count).toBe(3);
+    });
+
+    it("handles empty chunks array", async () => {
+      await chunkStore.indexChunks([]);
+      const count = await chunkStore.count();
+      expect(count).toBe(0);
+    });
+
+    it("handles chunks with empty tags and outlinks", async () => {
+      const chunks = [
+        { ...createTestChunk("note-1", 0, 1), tags: [], outlinks: [] },
+      ];
+
+      await chunkStore.indexChunks(chunks);
+      const count = await chunkStore.count();
+      expect(count).toBe(1);
+    });
+  });
+
+  describe("searchChunks", () => {
+    it("returns results based on vector similarity", async () => {
+      const chunks = [
+        createTestChunk("note-1", 0, 2),
+        createTestChunk("note-1", 1, 2),
+      ];
+      await chunkStore.indexChunks(chunks);
+
+      const queryVector = Array(384).fill(0.1);
+      const results = await chunkStore.searchChunks(queryVector, 2);
+
+      expect(results).toHaveLength(2);
+      expect(results[0]).toHaveProperty("chunk_id");
+      expect(results[0]).toHaveProperty("note_id");
+      expect(results[0]).toHaveProperty("score");
+    });
+  });
+
+  describe("searchChunksFTS", () => {
+    it("returns results matching query text", async () => {
+      const chunks = [
+        createTestChunk("note-1", 0, 1, "Meeting notes about project planning"),
+        createTestChunk("note-2", 0, 1, "Shopping list for groceries"),
+      ];
+      await chunkStore.indexChunks(chunks);
+      await chunkStore.rebuildFtsIndex();
+
+      const results = await chunkStore.searchChunksFTS("Meeting", 10);
+      expect(results.length).toBeGreaterThanOrEqual(1);
+      expect(results[0].content).toContain("Meeting");
+    });
+
+    it("returns empty array for no matches", async () => {
+      const chunks = [createTestChunk("note-1", 0, 1)];
+      await chunkStore.indexChunks(chunks);
+      await chunkStore.rebuildFtsIndex();
+
+      const results = await chunkStore.searchChunksFTS("nonexistentquery12345", 10);
+      expect(results).toHaveLength(0);
+    });
+  });
+
+  describe("getChunksByNoteId", () => {
+    it("returns all chunks for a note sorted by chunk_index", async () => {
+      const chunks = [
+        createTestChunk("note-1", 2, 3),
+        createTestChunk("note-1", 0, 3),
+        createTestChunk("note-1", 1, 3),
+        createTestChunk("note-2", 0, 1),
+      ];
+      await chunkStore.indexChunks(chunks);
+
+      const noteChunks = await chunkStore.getChunksByNoteId("note-1");
+
+      expect(noteChunks).toHaveLength(3);
+      expect(noteChunks[0].chunk_index).toBe(0);
+      expect(noteChunks[1].chunk_index).toBe(1);
+      expect(noteChunks[2].chunk_index).toBe(2);
+    });
+
+    it("returns empty array for non-existent note", async () => {
+      await chunkStore.indexChunks([createTestChunk("note-1", 0, 1)]);
+
+      const chunks = await chunkStore.getChunksByNoteId("non-existent");
+      expect(chunks).toHaveLength(0);
+    });
+  });
+
+  describe("deleteNoteChunks", () => {
+    it("deletes all chunks for a note", async () => {
+      const chunks = [
+        createTestChunk("note-1", 0, 2),
+        createTestChunk("note-1", 1, 2),
+        createTestChunk("note-2", 0, 1),
+      ];
+      await chunkStore.indexChunks(chunks);
+
+      await chunkStore.deleteNoteChunks("note-1");
+
+      const remaining = await chunkStore.count();
+      expect(remaining).toBe(1);
+
+      const note1Chunks = await chunkStore.getChunksByNoteId("note-1");
+      expect(note1Chunks).toHaveLength(0);
+
+      const note2Chunks = await chunkStore.getChunksByNoteId("note-2");
+      expect(note2Chunks).toHaveLength(1);
+    });
+
+    it("does not throw when deleting non-existent note chunks", async () => {
+      await chunkStore.indexChunks([createTestChunk("note-1", 0, 1)]);
+      await expect(chunkStore.deleteNoteChunks("non-existent")).resolves.not.toThrow();
+    });
+  });
+
+  describe("count", () => {
+    it("returns correct count", async () => {
+      const chunks = [
+        createTestChunk("note-1", 0, 2),
+        createTestChunk("note-1", 1, 2),
+        createTestChunk("note-2", 0, 1),
+      ];
+      await chunkStore.indexChunks(chunks);
+
+      expect(await chunkStore.count()).toBe(3);
+    });
+
+    it("returns 0 for empty store", async () => {
+      expect(await chunkStore.count()).toBe(0);
+    });
+  });
+
+  describe("clear", () => {
+    it("removes all chunks", async () => {
+      await chunkStore.indexChunks([
+        createTestChunk("note-1", 0, 1),
+        createTestChunk("note-2", 0, 1),
+      ]);
+      expect(await chunkStore.count()).toBe(2);
+
+      await chunkStore.clear();
+      expect(await chunkStore.count()).toBe(0);
+    });
+  });
+
+  describe("rebuildFtsIndex", () => {
+    it("rebuilds FTS index without error", async () => {
+      await chunkStore.indexChunks([
+        createTestChunk("note-1", 0, 1),
+        createTestChunk("note-2", 0, 1),
+      ]);
+
+      await expect(chunkStore.rebuildFtsIndex()).resolves.not.toThrow();
+    });
+  });
+});