@winci/local-rag 0.2.1

package/src/tools/annotation-tools.ts

@@ -0,0 +1,89 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { type AnnotationRow } from "../db";
+import { embed } from "../embeddings/embed";
+import { type GetDB, resolveProject } from "./index";
+
+export function registerAnnotationTools(server: McpServer, getDB: GetDB) {
+  server.tool(
+    "annotate",
+    "Attach a persistent note to a file or specific symbol. Notes survive sessions and surface inline in read_relevant results. Use for: known issues, caveats, architectural decisions tied to specific code, or 'don't change this until X lands'. Calling again with the same path+symbol updates the existing note.",
+    {
+      path: z.string().describe("File path (relative to project root) the note applies to"),
+      note: z.string().describe("The note text"),
+      symbol: z
+        .string()
+        .optional()
+        .describe("Symbol name (function, class, etc.) the note applies to — omit for file-level notes"),
+      author: z
+        .string()
+        .optional()
+        .describe("Label for who wrote the note — e.g. 'agent', 'human' (default: 'agent')"),
+      directory: z
+        .string()
+        .optional()
+        .describe("Project directory. Defaults to RAG_PROJECT_DIR env or cwd"),
+    },
+    async ({ path, note, symbol, author, directory }) => {
+      const { db: ragDb } = await resolveProject(directory, getDB);
+
+      const embText = symbol ? `${symbol}: ${note}` : note;
+      const embedding = await embed(embText);
+      const id = ragDb.upsertAnnotation(path, note, embedding, symbol ?? null, author ?? "agent");
+
+      const target = symbol ? `${path}  •  ${symbol}` : path;
+      return {
+        content: [{ type: "text" as const, text: `Annotation #${id} saved for ${target}` }],
+      };
+    }
+  );
+
+  server.tool(
+    "get_annotations",
+    "Retrieve persistent notes attached to files or symbols. Pass path to get all notes for a file. Pass query to search semantically across all annotations. Pass both to filter by file and rank by relevance.",
+    {
+      path: z
+        .string()
+        .optional()
+        .describe("File path to retrieve annotations for"),
+      query: z
+        .string()
+        .optional()
+        .describe("Semantic search query — finds annotations by meaning across all files"),
+      directory: z
+        .string()
+        .optional()
+        .describe("Project directory. Defaults to RAG_PROJECT_DIR env or cwd"),
+    },
+    async ({ path, query, directory }) => {
+      const { db: ragDb } = await resolveProject(directory, getDB);
+
+      let results: AnnotationRow[];
+      if (query) {
+        const embedding = await embed(query);
+        const searchResults = ragDb.searchAnnotations(embedding, 10);
+        results = path ? searchResults.filter((r) => r.path === path) : searchResults;
+      } else if (path) {
+        results = ragDb.getAnnotations(path);
+      } else {
+        results = ragDb.getAnnotations();
+      }
+
+      if (results.length === 0) {
+        return {
+          content: [{ type: "text" as const, text: "No annotations found." }],
+        };
+      }
+
+      const text = results
+        .map((r) => {
+          const target = r.symbolName ? `${r.path}  •  ${r.symbolName}` : r.path;
+          const authorStr = r.author ? ` [${r.author}]` : "";
+          return `#${r.id}  ${target}${authorStr}\n  ${r.note}\n  (${r.updatedAt})`;
+        })
+        .join("\n\n");
+
+      return { content: [{ type: "text" as const, text }] };
+    }
+  );
+}

package/src/tools/checkpoint-tools.ts

@@ -0,0 +1,147 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { embed } from "../embeddings/embed";
+import { discoverSessions } from "../conversation/parser";
+import { type GetDB, resolveProject } from "./index";
+
+export function registerCheckpointTools(server: McpServer, getDB: GetDB) {
+  server.tool(
+    "create_checkpoint",
+    "Create a named checkpoint marking an important moment. Call this liberally: after completing any feature or task, after adding or modifying tools, after key technical decisions, before and after large refactors, when hitting a blocker, or when changing direction. Checkpoints are the only way future sessions can know what was done and why — if in doubt, create one.",
+    {
+      type: z
+        .enum(["decision", "milestone", "blocker", "direction_change", "handoff"])
+        .describe("Type of checkpoint"),
+      title: z.string().describe("Short label, e.g. 'Chose JWT over session cookies'"),
+      summary: z
+        .string()
+        .describe("2-3 sentence description of what happened and why"),
+      filesInvolved: z
+        .array(z.string())
+        .optional()
+        .describe("Files relevant to this checkpoint"),
+      tags: z
+        .array(z.string())
+        .optional()
+        .describe("Freeform tags for filtering"),
+      directory: z
+        .string()
+        .optional()
+        .describe("Project directory. Defaults to RAG_PROJECT_DIR env or cwd"),
+    },
+    async ({ type, title, summary, filesInvolved, tags, directory }) => {
+      const { projectDir, db: ragDb } = await resolveProject(directory, getDB);
+
+      // Get current session's latest turn index
+      const sessions = discoverSessions(projectDir);
+      const sessionId = sessions.length > 0 ? sessions[0].sessionId : "unknown";
+
+      // Determine turn index from DB
+      const turnCount = ragDb.getTurnCount(sessionId);
+      const turnIndex = Math.max(0, turnCount - 1);
+
+      // Embed title + summary for semantic search
+      const embText = `${title}. ${summary}`;
+      const embedding = await embed(embText);
+
+      const id = ragDb.createCheckpoint(
+        sessionId,
+        turnIndex,
+        new Date().toISOString(),
+        type,
+        title,
+        summary,
+        filesInvolved ?? [],
+        tags ?? [],
+        embedding
+      );
+
+      return {
+        content: [{
+          type: "text" as const,
+          text: `Checkpoint #${id} created: [${type}] ${title}`,
+        }],
+      };
+    }
+  );
+
+  server.tool(
+    "list_checkpoints",
+    "List conversation checkpoints, most recent first. Cross-session by default.",
+    {
+      sessionId: z.string().optional().describe("Limit to a specific session ID"),
+      type: z
+        .enum(["decision", "milestone", "blocker", "direction_change", "handoff"])
+        .optional()
+        .describe("Filter by checkpoint type"),
+      limit: z.number().optional().default(20).describe("Max results (default: 20)"),
+      directory: z
+        .string()
+        .optional()
+        .describe("Project directory. Defaults to RAG_PROJECT_DIR env or cwd"),
+    },
+    async ({ sessionId, type, limit, directory }) => {
+      const { projectDir, db: ragDb } = await resolveProject(directory, getDB);
+
+      const checkpoints = ragDb.listCheckpoints(sessionId, type, limit);
+
+      if (checkpoints.length === 0) {
+        return {
+          content: [{ type: "text" as const, text: "No checkpoints found." }],
+        };
+      }
+
+      const text = checkpoints
+        .map((cp) => {
+          const files = cp.filesInvolved.length > 0
+            ? `\n  Files: ${cp.filesInvolved.join(", ")}`
+            : "";
+          const tagStr = cp.tags.length > 0 ? ` [${cp.tags.join(", ")}]` : "";
+          return `#${cp.id} [${cp.type}] ${cp.title}${tagStr}\n  ${cp.timestamp} (turn ${cp.turnIndex})\n  ${cp.summary}${files}`;
+        })
+        .join("\n\n");
+
+      return { content: [{ type: "text" as const, text }] };
+    }
+  );
+
+  server.tool(
+    "search_checkpoints",
+    "Semantic search over checkpoint titles and summaries.",
+    {
+      query: z.string().describe("What to search for in checkpoints"),
+      type: z
+        .enum(["decision", "milestone", "blocker", "direction_change", "handoff"])
+        .optional()
+        .describe("Filter by checkpoint type"),
+      limit: z.number().optional().default(5).describe("Max results (default: 5)"),
+      directory: z
+        .string()
+        .optional()
+        .describe("Project directory. Defaults to RAG_PROJECT_DIR env or cwd"),
+    },
+    async ({ query, type, limit, directory }) => {
+      const { projectDir, db: ragDb } = await resolveProject(directory, getDB);
+
+      const queryEmb = await embed(query);
+      const results = ragDb.searchCheckpoints(queryEmb, limit, type);
+
+      if (results.length === 0) {
+        return {
+          content: [{ type: "text" as const, text: "No matching checkpoints found." }],
+        };
+      }
+
+      const text = results
+        .map((cp) => {
+          const files = cp.filesInvolved.length > 0
+            ? `\n  Files: ${cp.filesInvolved.join(", ")}`
+            : "";
+          return `${cp.score.toFixed(4)}  #${cp.id} [${cp.type}] ${cp.title}\n  ${cp.summary}${files}`;
+        })
+        .join("\n\n");
+
+      return { content: [{ type: "text" as const, text }] };
+    }
+  );
+}

package/src/tools/conversation-tools.ts

@@ -0,0 +1,86 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { embed } from "../embeddings/embed";
+import { log } from "../utils/log";
+import { type GetDB, resolveProject } from "./index";
+
+export function registerConversationTools(server: McpServer, getDB: GetDB) {
+  server.tool(
+    "search_conversation",
+    "Search through conversation history. Finds past decisions, discussions, and tool outputs from current or previous sessions.",
+    {
+      query: z.string().describe("What to search for in conversation history"),
+      directory: z
+        .string()
+        .optional()
+        .describe("Project directory. Defaults to RAG_PROJECT_DIR env or cwd"),
+      sessionId: z
+        .string()
+        .optional()
+        .describe("Limit search to a specific session ID. Omit to search all sessions."),
+      top: z
+        .number()
+        .optional()
+        .default(5)
+        .describe("Number of results to return (default: 5)"),
+    },
+    async ({ query, directory, sessionId, top }) => {
+      const { db: ragDb, config } = await resolveProject(directory, getDB);
+
+      // Hybrid search: vector + BM25
+      const queryEmb = await embed(query);
+      const vecResults = ragDb.searchConversation(queryEmb, top, sessionId);
+
+      let bm25Results: typeof vecResults = [];
+      try {
+        bm25Results = ragDb.textSearchConversation(query, top, sessionId);
+      } catch (err) {
+        log.debug(`Conversation FTS query failed, falling back to vector-only: ${err instanceof Error ? err.message : err}`, "conversation");
+      }
+
+      // Merge and deduplicate by turnId using hybrid scoring
+      const { hybridWeight } = config;
+      const scoreMap = new Map<number, { item: (typeof vecResults)[0]; vecScore: number; txtScore: number }>();
+
+      for (const r of vecResults) {
+        scoreMap.set(r.turnId, { item: r, vecScore: r.score, txtScore: 0 });
+      }
+      for (const r of bm25Results) {
+        const existing = scoreMap.get(r.turnId);
+        if (existing) {
+          existing.txtScore = r.score;
+        } else {
+          scoreMap.set(r.turnId, { item: r, vecScore: 0, txtScore: r.score });
+        }
+      }
+
+      const results = [...scoreMap.values()]
+        .map((e) => ({ ...e.item, score: hybridWeight * e.vecScore + (1 - hybridWeight) * e.txtScore }))
+        .sort((a, b) => b.score - a.score)
+        .slice(0, top);
+
+      if (results.length === 0) {
+        return {
+          content: [{
+            type: "text" as const,
+            text: "No conversation results found. The conversation may not be indexed yet.",
+          }],
+        };
+      }
+
+      const text = results
+        .map((r) => {
+          const tools = r.toolsUsed.length > 0 ? ` [${r.toolsUsed.join(", ")}]` : "";
+          const files = r.filesReferenced.length > 0
+            ? `\n  Files: ${r.filesReferenced.slice(0, 5).join(", ")}`
+            : "";
+          return `Turn ${r.turnIndex} (${r.timestamp})${tools}\n  ${r.snippet.slice(0, 200)}...${files}`;
+        })
+        .join("\n\n");
+
+      return {
+        content: [{ type: "text" as const, text }],
+      };
+    }
+  );
+}

package/src/tools/git-tools.ts

@@ -0,0 +1,103 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { resolve } from "path";
+import { type GetDB, resolveProject } from "./index";
+
+async function runGit(args: string[], cwd: string): Promise<string | null> {
+  try {
+    const proc = Bun.spawn(["git", ...args], { cwd, stdout: "pipe", stderr: "pipe" });
+    const output = await new Response(proc.stdout).text();
+    const exitCode = await proc.exited;
+    return exitCode === 0 ? output.trim() : null;
+  } catch {
+    return null;
+  }
+}
+
+async function findGitRoot(dir: string): Promise<string | null> {
+  return runGit(["rev-parse", "--show-toplevel"], dir);
+}
+
+export function registerGitTools(server: McpServer, getDB: GetDB) {
+  server.tool(
+    "git_context",
+    "Show git context for the working tree: uncommitted changes annotated with index status, recent commits, and changed files. Use this at the start of a session to understand what has already been modified before searching or editing.",
+    {
+      since: z
+        .string()
+        .optional()
+        .describe("Commit ref, branch, or ISO date to look back to (default: HEAD~5)"),
+      include_diff: z
+        .boolean()
+        .optional()
+        .describe("Include full unified diff of uncommitted changes, truncated to 200 lines (default: false)"),
+      files_only: z
+        .boolean()
+        .optional()
+        .describe("Return file paths only — omit commit messages and diff body (default: false)"),
+      directory: z
+        .string()
+        .optional()
+        .describe("Project directory. Defaults to RAG_PROJECT_DIR env or cwd"),
+    },
+    async ({ since, include_diff, files_only, directory }) => {
+      const { projectDir, db: ragDb } = await resolveProject(directory, getDB);
+
+      const gitRoot = await findGitRoot(resolve(projectDir));
+      if (!gitRoot) {
+        return { content: [{ type: "text" as const, text: "Not a git repository." }] };
+      }
+
+      const sinceRef = since ?? "HEAD~5";
+      const sections: string[] = [];
+
+      // 1. Uncommitted changes
+      const statusOutput = await runGit(["status", "--short"], gitRoot);
+      if (statusOutput) {
+        const statusLines = statusOutput.split("\n").filter(Boolean);
+        if (statusLines.length > 0) {
+          const annotated = statusLines.map((line) => {
+            const filePart = line.slice(3).trim();
+            const filePath = filePart.includes(" -> ") ? filePart.split(" -> ")[1] : filePart;
+            const absPath = resolve(gitRoot, filePath);
+            const tag = ragDb.getFileByPath(absPath) != null ? "[indexed]" : "[not indexed]";
+            return files_only ? `${filePath}  ${tag}` : `${line}  ${tag}`;
+          });
+          sections.push("## Uncommitted changes\n" + annotated.join("\n"));
+        }
+      }
+
+      // 2. Recent commits (omit body when files_only)
+      if (!files_only) {
+        const logOutput = await runGit(["log", "--oneline", `${sinceRef}..HEAD`], gitRoot);
+        if (logOutput) {
+          sections.push(`## Recent commits (since ${sinceRef})\n` + logOutput);
+        }
+      }
+
+      // 3. Changed files since sinceRef
+      const diffFilesOutput = await runGit(["diff", "--name-only", `${sinceRef}..HEAD`], gitRoot);
+      if (diffFilesOutput) {
+        sections.push(`## Changed files (since ${sinceRef})\n` + diffFilesOutput);
+      }
+
+      // 4. Diff (opt-in, truncated to 200 lines)
+      if (include_diff && !files_only) {
+        const diffOutput = await runGit(["diff", "HEAD"], gitRoot);
+        if (diffOutput) {
+          const diffLines = diffOutput.split("\n");
+          const truncated = diffLines.length > 200;
+          const body = diffLines.slice(0, 200).join("\n");
+          sections.push("## Diff\n" + body + (truncated ? "\n[truncated]" : ""));
+        }
+      }
+
+      const text =
+        sections.length > 0
+          ? sections.join("\n\n")
+          : "Nothing to report (clean working tree, no recent commits in range).";
+
+      return { content: [{ type: "text" as const, text }] };
+    }
+  );
+}

package/src/tools/graph-tools.ts

@@ -0,0 +1,163 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { resolve, relative } from "path";
+import { generateProjectMap } from "../graph/resolver";
+import { type GetDB, resolveProject } from "./index";
+
+export function registerGraphTools(server: McpServer, getDB: GetDB) {
+  server.tool(
+    "project_map",
+    "Generate a structured dependency map of the project. Shows files, their exports, depends_on (imports), and depended_on_by (importers). Entry points are listed separately.",
+    {
+      directory: z
+        .string()
+        .optional()
+        .describe("Project directory. Defaults to RAG_PROJECT_DIR env or cwd"),
+      focus: z
+        .string()
+        .optional()
+        .describe("File path (relative to project) to focus on — shows only nearby files"),
+      zoom: z
+        .enum(["file", "directory"])
+        .optional()
+        .describe("Zoom level: 'file' (default) or 'directory' for large projects"),
+      maxNodes: z
+        .number()
+        .optional()
+        .describe("Max nodes in graph (default: 50, auto-switches to directory view if exceeded)"),
+    },
+    async ({ directory, focus, zoom, maxNodes }) => {
+      const { projectDir, db: ragDb } = await resolveProject(directory, getDB);
+
+      const map = generateProjectMap(ragDb, {
+        projectDir,
+        focus,
+        zoom: zoom ?? "file",
+        maxNodes: maxNodes ?? 50,
+      });
+
+      return {
+        content: [{ type: "text" as const, text: map }],
+      };
+    }
+  );
+
+  server.tool(
+    "find_usages",
+    "Find every usage (call site or reference) of a symbol across the codebase. Returns file paths, line numbers, and the matching line. Excludes the file that defines the symbol. Use this before renaming or changing a function signature to understand the blast radius.",
+    {
+      symbol: z.string().describe("Symbol name to search for"),
+      exact: z
+        .boolean()
+        .optional()
+        .describe("Require exact word-boundary match (default: true). Set false for prefix/substring matching."),
+      directory: z
+        .string()
+        .optional()
+        .describe("Project directory. Defaults to RAG_PROJECT_DIR env or cwd"),
+      top: z.number().optional().describe("Max results to return (default: 30)"),
+    },
+    async ({ symbol, exact, directory, top }) => {
+      const { projectDir, db: ragDb } = await resolveProject(directory, getDB);
+
+      const results = ragDb.findUsages(symbol, exact ?? true, top ?? 30);
+
+      if (results.length === 0) {
+        return {
+          content: [{ type: "text" as const, text: `No usages of "${symbol}" found. The symbol may only appear in its definition file, or the index may need re-running.` }],
+        };
+      }
+
+      // Group by file
+      const byFile = new Map<string, { line: number | null; snippet: string }[]>();
+      for (const r of results) {
+        if (!byFile.has(r.path)) byFile.set(r.path, []);
+        byFile.get(r.path)!.push({ line: r.line, snippet: r.snippet });
+      }
+
+      const fileCount = byFile.size;
+      const lines: string[] = [
+        `Found ${results.length} usage${results.length !== 1 ? "s" : ""} of "${symbol}" across ${fileCount} file${fileCount !== 1 ? "s" : ""}:\n`,
+      ];
+
+      for (const [path, usages] of byFile) {
+        lines.push(path);
+        for (const u of usages) {
+          const lineStr = u.line != null ? `:${u.line}` : "";
+          lines.push(`  ${lineStr}  ${u.snippet}`);
+        }
+        lines.push("");
+      }
+
+      return {
+        content: [{ type: "text" as const, text: lines.join("\n") }],
+      };
+    }
+  );
+
+  server.tool(
+    "depends_on",
+    "List all files that a given file imports (its dependencies). Returns resolved file paths only — unresolved or external imports are excluded.",
+    {
+      file: z.string().describe("File path (relative to project) to query"),
+      directory: z
+        .string()
+        .optional()
+        .describe("Project directory. Defaults to RAG_PROJECT_DIR env or cwd"),
+    },
+    async ({ file, directory }) => {
+      const { projectDir, db: ragDb } = await resolveProject(directory, getDB);
+
+      const absPath = resolve(projectDir, file);
+      const fileRecord = ragDb.getFileByPath(absPath);
+      if (!fileRecord) {
+        return { content: [{ type: "text" as const, text: `File "${file}" not found in index.` }] };
+      }
+
+      const deps = ragDb.getDependsOn(fileRecord.id);
+      if (deps.length === 0) {
+        return { content: [{ type: "text" as const, text: `${file} has no indexed dependencies.` }] };
+      }
+
+      const lines = [`${file} depends on ${deps.length} file${deps.length !== 1 ? "s" : ""}:\n`];
+      for (const dep of deps) {
+        lines.push(`  ${relative(projectDir, dep.path)}  (import: ${dep.source})`);
+      }
+
+      return { content: [{ type: "text" as const, text: lines.join("\n") }] };
+    }
+  );
+
+  server.tool(
+    "depended_on_by",
+    "List all files that import a given file (its reverse dependencies / importers). Use this to understand the blast radius before modifying a file.",
+    {
+      file: z.string().describe("File path (relative to project) to query"),
+      directory: z
+        .string()
+        .optional()
+        .describe("Project directory. Defaults to RAG_PROJECT_DIR env or cwd"),
+    },
+    async ({ file, directory }) => {
+      const { projectDir, db: ragDb } = await resolveProject(directory, getDB);
+
+      const absPath = resolve(projectDir, file);
+      const fileRecord = ragDb.getFileByPath(absPath);
+      if (!fileRecord) {
+        return { content: [{ type: "text" as const, text: `File "${file}" not found in index.` }] };
+      }
+
+      const importers = ragDb.getDependedOnBy(fileRecord.id);
+      if (importers.length === 0) {
+        return { content: [{ type: "text" as const, text: `No files import ${file}.` }] };
+      }
+
+      const lines = [`${file} is imported by ${importers.length} file${importers.length !== 1 ? "s" : ""}:\n`];
+      for (const imp of importers) {
+        lines.push(`  ${relative(projectDir, imp.path)}  (import: ${imp.source})`);
+      }
+
+      return { content: [{ type: "text" as const, text: lines.join("\n") }] };
+    }
+  );
+}

package/src/tools/index-tools.ts

@@ -0,0 +1,91 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { indexDirectory } from "../indexing/indexer";
+import { type GetDB, resolveProject } from "./index";
+
+export function registerIndexTools(server: McpServer, getDB: GetDB) {
+  server.tool(
+    "index_files",
+    "Index files in a directory for semantic search. Skips unchanged files and prunes deleted ones.",
+    {
+      directory: z
+        .string()
+        .optional()
+        .describe(
+          "Directory to index. Defaults to RAG_PROJECT_DIR env or cwd"
+        ),
+      patterns: z
+        .array(z.string())
+        .optional()
+        .describe(
+          "Override include patterns (e.g. ['**/*.md', '**/*.ts']). Uses .rag/config.json if not provided"
+        ),
+    },
+    async ({ directory, patterns }) => {
+      const { projectDir, db: ragDb, config: baseConfig } = await resolveProject(directory, getDB);
+      const config = patterns ? { ...baseConfig, include: patterns } : baseConfig;
+
+      const result = await indexDirectory(projectDir, ragDb, config);
+
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: `Indexing complete:\n  Indexed: ${result.indexed}\n  Skipped (unchanged): ${result.skipped}\n  Pruned (deleted): ${result.pruned}${result.errors.length > 0 ? `\n  Errors: ${result.errors.join("; ")}` : ""}`,
+          },
+        ],
+      };
+    }
+  );
+
+  server.tool(
+    "index_status",
+    "Show the current state of the RAG index for a project directory.",
+    {
+      directory: z
+        .string()
+        .optional()
+        .describe("Project directory. Defaults to RAG_PROJECT_DIR env or cwd"),
+    },
+    async ({ directory }) => {
+      const { db: ragDb } = await resolveProject(directory, getDB);
+      const status = ragDb.getStatus();
+
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: `Index status:\n  Files: ${status.totalFiles}\n  Chunks: ${status.totalChunks}\n  Last indexed: ${status.lastIndexed || "never"}`,
+          },
+        ],
+      };
+    }
+  );
+
+  server.tool(
+    "remove_file",
+    "Remove a specific file from the RAG index.",
+    {
+      path: z.string().describe("Absolute path of the file to remove"),
+      directory: z
+        .string()
+        .optional()
+        .describe("Project directory. Defaults to RAG_PROJECT_DIR env or cwd"),
+    },
+    async ({ path, directory }) => {
+      const { db: ragDb } = await resolveProject(directory, getDB);
+      const removed = ragDb.removeFile(path);
+
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: removed
+              ? `Removed ${path} from index`
+              : `${path} was not in the index`,
+          },
+        ],
+      };
+    }
+  );
+}