@disco_trooper/apple-notes-mcp 1.1.0 → 1.3.0

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);
+}

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,28 +13,68 @@ import {
   ListToolsRequestSchema,
 } from "@modelcontextprotocol/sdk/types.js";
 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 { getVectorStore, getChunkStore } 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";
+import { fullChunkIndex, hasChunkIndex } from "./search/chunk-indexer.js";
+import { searchChunks } from "./search/chunk-search.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"),
-  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 +86,63 @@ 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),
+});
+
+// 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
@@ -231,6 +309,87 @@ 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"],
+        },
+      },
+      // 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"],
+        },
+      },
     ],
   };
 });
@@ -245,6 +404,38 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       // Read tools
       case "search-notes": {
         const params = SearchNotesSchema.parse(args);
+
+        // 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,
@@ -276,6 +467,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);
       }
 
@@ -287,8 +485,21 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 
       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": {
@@ -323,19 +534,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": {
@@ -353,6 +572,73 @@ 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}`);
+      }
+
+      // 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}`);
     }