@disco_trooper/apple-notes-mcp 1.2.0 → 1.3.0

package/src/graph/queries.test.ts

@@ -0,0 +1,156 @@
+// src/graph/queries.test.ts
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { listTags, searchByTag, findRelatedNotes } from "./queries.js";
+
+// Create a shared mock store object
+const mockStore = {
+  getAll: vi.fn(),
+  search: vi.fn(),
+};
+
+// Mock the vector store module
+vi.mock("../db/lancedb.js", () => ({
+  getVectorStore: () => mockStore,
+}));
+
+describe("listTags", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("aggregates tags with counts", async () => {
+    mockStore.getAll.mockResolvedValue([
+      { id: "1", title: "Note 1", tags: ["project", "idea"], outlinks: [] },
+      { id: "2", title: "Note 2", tags: ["project", "todo"], outlinks: [] },
+      { id: "3", title: "Note 3", tags: ["idea"], outlinks: [] },
+    ]);
+
+    const result = await listTags();
+
+    expect(result).toEqual([
+      { tag: "project", count: 2 },
+      { tag: "idea", count: 2 },
+      { tag: "todo", count: 1 },
+    ]);
+  });
+
+  it("returns empty array when no tags", async () => {
+    mockStore.getAll.mockResolvedValue([
+      { id: "1", title: "Note 1", tags: [], outlinks: [] },
+    ]);
+
+    const result = await listTags();
+    expect(result).toEqual([]);
+  });
+});
+
+describe("searchByTag", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("finds notes with specific tag", async () => {
+    mockStore.getAll.mockResolvedValue([
+      { id: "1", title: "Note 1", folder: "Work", tags: ["project"], content: "Content 1", modified: "2026-01-01" },
+      { id: "2", title: "Note 2", folder: "Personal", tags: ["project", "idea"], content: "Content 2", modified: "2026-01-02" },
+      { id: "3", title: "Note 3", folder: "Work", tags: ["todo"], content: "Content 3", modified: "2026-01-03" },
+    ]);
+
+    const result = await searchByTag("project");
+
+    expect(result).toHaveLength(2);
+    expect(result[0].title).toBe("Note 1");
+    expect(result[1].title).toBe("Note 2");
+  });
+
+  it("filters by folder", async () => {
+    mockStore.getAll.mockResolvedValue([
+      { id: "1", title: "Note 1", folder: "Work", tags: ["project"], content: "...", modified: "2026-01-01" },
+      { id: "2", title: "Note 2", folder: "Personal", tags: ["project"], content: "...", modified: "2026-01-02" },
+    ]);
+
+    const result = await searchByTag("project", { folder: "Work" });
+
+    expect(result).toHaveLength(1);
+    expect(result[0].folder).toBe("Work");
+  });
+});
+
+describe("findRelatedNotes", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("finds notes by shared tags", async () => {
+    mockStore.getAll.mockResolvedValue([
+      { id: "1", title: "Source", folder: "Work", tags: ["project", "idea"], outlinks: [], vector: [1,0,0] },
+      { id: "2", title: "Related", folder: "Work", tags: ["project"], outlinks: [], vector: [0,1,0] },
+      { id: "3", title: "Unrelated", folder: "Work", tags: ["todo"], outlinks: [], vector: [0,0,1] },
+    ]);
+
+    const result = await findRelatedNotes("1", { types: ["tag"] });
+
+    expect(result).toHaveLength(1);
+    expect(result[0].title).toBe("Related");
+    expect(result[0].relationship).toBe("tag");
+  });
+
+  it("finds notes by outlinks", async () => {
+    mockStore.getAll.mockResolvedValue([
+      { id: "1", title: "Source", folder: "Work", tags: [], outlinks: ["Target"], vector: [1,0,0] },
+      { id: "2", title: "Target", folder: "Work", tags: [], outlinks: [], vector: [0,1,0] },
+    ]);
+
+    const result = await findRelatedNotes("1", { types: ["link"] });
+
+    expect(result).toHaveLength(1);
+    expect(result[0].title).toBe("Target");
+    expect(result[0].relationship).toBe("link");
+    expect(result[0].direction).toBe("outgoing");
+  });
+
+  it("finds backlinks", async () => {
+    mockStore.getAll.mockResolvedValue([
+      { id: "1", title: "Target", folder: "Work", tags: [], outlinks: [], vector: [1,0,0] },
+      { id: "2", title: "Source", folder: "Work", tags: [], outlinks: ["Target"], vector: [0,1,0] },
+    ]);
+
+    const result = await findRelatedNotes("1", { types: ["link"] });
+
+    expect(result).toHaveLength(1);
+    expect(result[0].title).toBe("Source");
+    expect(result[0].direction).toBe("incoming");
+  });
+
+  it("throws NoteNotFoundError for non-existent source note", async () => {
+    mockStore.getAll.mockResolvedValue([]);
+    await expect(findRelatedNotes("nonexistent-id")).rejects.toThrow("Note not found");
+  });
+
+  it("finds notes by semantic similarity", async () => {
+    mockStore.getAll.mockResolvedValue([
+      { id: "1", title: "Source", folder: "Work", tags: [], outlinks: [], vector: [1,0,0] },
+    ]);
+    mockStore.search.mockResolvedValue([
+      { id: "2", title: "Similar", folder: "Work", content: "...", modified: "2026-01-01", score: 0.95 }
+    ]);
+
+    const result = await findRelatedNotes("1", { types: ["similar"] });
+    expect(result).toHaveLength(1);
+    expect(result[0].relationship).toBe("similar");
+  });
+});
+
+describe("searchByTag", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("searches tags case-insensitively", async () => {
+    mockStore.getAll.mockResolvedValue([
+      { id: "1", title: "Note", folder: "Work", tags: ["project"], content: "...", modified: "2026-01-01" },
+    ]);
+    const result = await searchByTag("PROJECT");
+    expect(result).toHaveLength(1);
+  });
+});

package/src/graph/queries.ts

@@ -0,0 +1,224 @@
+/**
+ * Knowledge graph query operations.
+ */
+
+import { getVectorStore } from "../db/lancedb.js";
+import { createDebugLogger } from "../utils/debug.js";
+import { NoteNotFoundError } from "../errors/index.js";
+import { generatePreview } from "../search/index.js";
+import {
+  DEFAULT_SEARCH_LIMIT,
+  DEFAULT_RELATED_NOTES_LIMIT,
+  GRAPH_TAG_WEIGHT,
+  GRAPH_LINK_WEIGHT,
+  GRAPH_SIMILAR_WEIGHT,
+} from "../config/constants.js";
+import type { SearchResult } from "../types/index.js";
+
+const debug = createDebugLogger("GRAPH");
+
+export interface TagCount {
+  tag: string;
+  count: number;
+}
+
+/**
+ * List all tags with occurrence counts.
+ * Sorted by count descending.
+ */
+export async function listTags(): Promise<TagCount[]> {
+  debug("Listing all tags");
+
+  const store = getVectorStore();
+  const records = await store.getAll();
+
+  // Aggregate tag counts
+  const counts = new Map<string, number>();
+  for (const record of records) {
+    for (const tag of record.tags ?? []) {
+      counts.set(tag, (counts.get(tag) ?? 0) + 1);
+    }
+  }
+
+  // Sort by count descending
+  const result = Array.from(counts.entries())
+    .map(([tag, count]) => ({ tag, count }))
+    .sort((a, b) => b.count - a.count);
+
+  debug(`Found ${result.length} unique tags`);
+  return result;
+}
+
+export interface SearchByTagOptions {
+  folder?: string;
+  limit?: number;
+}
+
+/**
+ * Find notes with a specific tag.
+ */
+export async function searchByTag(
+  tag: string,
+  options: SearchByTagOptions = {}
+): Promise<SearchResult[]> {
+  const { folder, limit = DEFAULT_SEARCH_LIMIT } = options;
+
+  debug(`Searching for tag: ${tag}`);
+
+  const store = getVectorStore();
+  const records = await store.getAll();
+
+  // Filter by tag (case-insensitive)
+  let matches = records.filter((r) =>
+    (r.tags ?? []).includes(tag.toLowerCase())
+  );
+
+  // Filter by folder if specified
+  if (folder) {
+    const normalizedFolder = folder.toLowerCase();
+    matches = matches.filter(
+      (r) => r.folder.toLowerCase() === normalizedFolder
+    );
+  }
+
+  // Transform to SearchResult and limit
+  const results: SearchResult[] = matches.slice(0, limit).map((r, i) => ({
+    id: r.id,
+    title: r.title,
+    folder: r.folder,
+    preview: generatePreview(r.content),
+    modified: r.modified,
+    score: 1 / (1 + i),
+  }));
+
+  debug(`Found ${results.length} notes with tag: ${tag}`);
+  return results;
+}
+
+export type RelationshipType = "tag" | "link" | "similar";
+
+export interface RelatedNote {
+  id: string;
+  title: string;
+  folder: string;
+  relationship: RelationshipType;
+  score: number;
+  sharedTags?: string[];
+  direction?: "outgoing" | "incoming";
+}
+
+export interface FindRelatedOptions {
+  types?: RelationshipType[];
+  limit?: number;
+}
+
+/**
+ * Find notes related to a source note by tags, links, or semantic similarity.
+ */
+export async function findRelatedNotes(
+  sourceId: string,
+  options: FindRelatedOptions = {}
+): Promise<RelatedNote[]> {
+  const { types = ["tag", "link", "similar"], limit = DEFAULT_RELATED_NOTES_LIMIT } = options;
+
+  debug(`Finding related notes for: ${sourceId}`);
+
+  const store = getVectorStore();
+  const allRecords = await store.getAll();
+
+  // Find source note
+  const source = allRecords.find((r) => r.id === sourceId);
+  if (!source) {
+    throw new NoteNotFoundError(sourceId);
+  }
+
+  const results: RelatedNote[] = [];
+  const seen = new Set<string>();
+
+  // Find by shared tags
+  if (types.includes("tag") && source.tags?.length > 0) {
+    for (const record of allRecords) {
+      if (record.id === sourceId || seen.has(record.id)) continue;
+
+      const shared = (record.tags ?? []).filter((t) => source.tags.includes(t));
+      if (shared.length > 0) {
+        results.push({
+          id: record.id,
+          title: record.title,
+          folder: record.folder,
+          relationship: "tag",
+          score: GRAPH_TAG_WEIGHT * (shared.length / source.tags.length),
+          sharedTags: shared,
+        });
+        seen.add(record.id);
+      }
+    }
+  }
+
+  // Find by outlinks (notes this note links to)
+  if (types.includes("link")) {
+    for (const linkTitle of source.outlinks ?? []) {
+      const linked = allRecords.find(
+        (r) =>
+          r.title.toLowerCase() === linkTitle.toLowerCase() &&
+          r.id !== sourceId &&
+          !seen.has(r.id)
+      );
+      if (linked) {
+        results.push({
+          id: linked.id,
+          title: linked.title,
+          folder: linked.folder,
+          relationship: "link",
+          score: GRAPH_LINK_WEIGHT,
+          direction: "outgoing",
+        });
+        seen.add(linked.id);
+      }
+    }
+
+    // Find backlinks (notes that link to this note)
+    for (const record of allRecords) {
+      if (record.id === sourceId || seen.has(record.id)) continue;
+
+      const linksToSource = (record.outlinks ?? []).some(
+        (l) => l.toLowerCase() === source.title.toLowerCase()
+      );
+      if (linksToSource) {
+        results.push({
+          id: record.id,
+          title: record.title,
+          folder: record.folder,
+          relationship: "link",
+          score: GRAPH_LINK_WEIGHT,
+          direction: "incoming",
+        });
+        seen.add(record.id);
+      }
+    }
+  }
+
+  // Find by semantic similarity
+  if (types.includes("similar") && source.vector?.length > 0) {
+    const similarResults = await store.search(source.vector, limit + 1);
+
+    for (const similar of similarResults) {
+      if (similar.id === sourceId || seen.has(similar.id ?? "")) continue;
+
+      results.push({
+        id: similar.id ?? "",
+        title: similar.title,
+        folder: similar.folder,
+        relationship: "similar",
+        score: GRAPH_SIMILAR_WEIGHT * similar.score,
+      });
+      seen.add(similar.id ?? "");
+    }
+  }
+
+  // Sort by score and limit
+  results.sort((a, b) => b.score - a.score);
+
+  debug(`Found ${results.length} related notes`);
+  return results.slice(0, limit);
+}