@documentation-robotics/cli 0.3.0 → 0.4.0

package/dist/mcp/tools/codebase-shared.js

@@ -0,0 +1,265 @@
+import { execFile } from "node:child_process";
+import { createHash } from "node:crypto";
+import { mkdir, readFile, realpath, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { AnalyzerRegistry } from "../../analyzers/registry.js";
+import { analyzerHomepage, currentGitHead, readIndexFreshness } from "../../analyzers/active-analyzer.js";
+import { SOURCE_EXT, VENDOR_EXCLUDE } from "../../analyzers/cards/build.js";
+import { readIndexJob } from "../../analyzers/index-job.js";
+import { readSession } from "../../analyzers/session-state.js";
+import { performDiscover } from "../../commands/discover-logic.js";
+import { CLIError, ErrorCategory } from "../../utils/errors.js";
+const defaultCodebaseToolDeps = {
+  async getAnalyzer(name) {
+    const registry = AnalyzerRegistry.getInstance();
+    return await registry.initialize(), registry.getAnalyzer(name);
+  },
+  async discover() {
+    const registry = AnalyzerRegistry.getInstance();
+    await registry.initialize();
+    const { discoveryResult } = await performDiscover(registry, { json: !0, isTTY: !1 });
+    return { found: discoveryResult.found, selected: discoveryResult.selected ?? void 0 };
+  },
+  gitHead: currentGitHead
+};
+async function canonicalRoots(model) {
+  const resolve = async (dir) => {
+    try {
+      return await realpath(dir);
+    } catch {
+      return dir;
+    }
+  };
+  return { projectRoot: await resolve(model.rootPath), codebaseRoot: await resolve(model.codebaseRoot) };
+}
+async function installSuggestions(name) {
+  return [
+    `Install codebase-memory-mcp (${await analyzerHomepage(name)}), for example: npm install -g codebase-memory-mcp`,
+    "Make sure the binary is on the PATH the dr MCP server runs with (restart the client after installing)",
+    "Then call codebase_index again"
+  ];
+}
+async function notInstalledError(name) {
+  return new CLIError(`The code analyzer is not installed: ${name}`, ErrorCategory.USER, await installSuggestions(name));
+}
+function analyzerNotFoundError(name) {
+  return new CLIError(`Analyzer not found: ${name}`, ErrorCategory.NOT_FOUND, [
+    "Run `dr analyzer discover --reselect` in the project to select an installed analyzer"
+  ]);
+}
+const runGit = (args, cwd) => new Promise((resolve) => {
+  execFile("git", args, {
+    cwd,
+    timeout: 1e4,
+    maxBuffer: 32 * 1024 * 1024,
+    env: { ...process.env, GIT_OPTIONAL_LOCKS: "0", GIT_TERMINAL_PROMPT: "0" }
+  }, (error, stdout, stderr) => {
+    if (!error)
+      return resolve({ ok: !0, stdout: String(stdout) });
+    const missing = error.code === "ENOENT";
+    resolve({ ok: !1, missing, error: String(stderr).trim() || error.message });
+  });
+}), DR_FOLDERS = /* @__PURE__ */ new Set(["documentation-robotics", ".dr"]), INDEXED_EXT = /\.(mts|cts|kts|c|cc|cpp|cxx|h|hh|hpp|hxx|lua|dart|groovy)$/i;
+function isIndexedSource(file) {
+  const posix = file.replace(/\\/g, "/");
+  return posix.split("/").some((segment) => DR_FOLDERS.has(segment)) || VENDOR_EXCLUDE.test(posix) ? !1 : SOURCE_EXT.test(posix) || INDEXED_EXT.test(posix);
+}
+async function workingChanges(git, codebaseRoot) {
+  const prefix = await git(["rev-parse", "--show-prefix"], codebaseRoot);
+  if (!prefix.ok)
+    return null;
+  const status = await git(["status", "--porcelain", "-z", "--untracked-files=all", "--", "."], codebaseRoot);
+  if (!status.ok)
+    return null;
+  const top = prefix.stdout.trim(), local = (file) => top ? file.startsWith(top) ? file.slice(top.length) : null : file, changes = [], add = (file, gone) => {
+    const l = file ? local(file) : null;
+    l && isIndexedSource(l) && changes.push({ file: l, gone });
+  }, parts = status.stdout.split("\0");
+  for (let i = 0; i < parts.length; i++) {
+    const entry = parts[i];
+    if (entry.length < 4)
+      continue;
+    const code = entry.slice(0, 2), file = entry.slice(3);
+    if (code[0] === "R" || code[0] === "C") {
+      const from = parts[++i];
+      add(file, !1), code[0] === "R" && add(from, !0);
+      continue;
+    }
+    add(file, code.includes("D"));
+  }
+  return changes;
+}
+async function hashWorkingChanges(codebaseRoot, changes) {
+  const files = {};
+  for (const change of changes) {
+    if (change.gone) {
+      files[change.file] = null;
+      continue;
+    }
+    try {
+      files[change.file] = createHash("sha1").update(await readFile(path.join(codebaseRoot, change.file))).digest("hex");
+    } catch {
+      files[change.file] = null;
+    }
+  }
+  return files;
+}
+const snapshotPath = (projectRoot, analyzer) => path.join(projectRoot, ".dr", "analyzers", analyzer, "index-worktree.json");
+async function takeWorktreeSnapshot(codebaseRoot, git = runGit) {
+  const takenAt = (/* @__PURE__ */ new Date()).toISOString(), changes = await workingChanges(git, codebaseRoot);
+  return changes ? { version: 1, takenAt, files: await hashWorkingChanges(codebaseRoot, changes) } : null;
+}
+async function writeWorktreeSnapshot(projectRoot, analyzer, snapshot) {
+  await mkdir(path.dirname(snapshotPath(projectRoot, analyzer)), { recursive: !0 }), await writeFile(snapshotPath(projectRoot, analyzer), JSON.stringify(snapshot, null, 2));
+}
+async function readWorktreeSnapshot(projectRoot, analyzer, indexedAt, isAlive) {
+  let snapshot;
+  try {
+    snapshot = JSON.parse(await readFile(snapshotPath(projectRoot, analyzer), "utf-8"));
+  } catch {
+    return null;
+  }
+  const job = await readIndexJob(projectRoot, { isAlive }), at = Date.parse(indexedAt);
+  return !job || job.jobId !== snapshot.jobId || job.state !== "done" || snapshot.version !== 1 || !(Date.parse(snapshot.takenAt) <= at) || job.finishedAt && Date.parse(job.finishedAt) < at ? null : snapshot;
+}
+const CLOCK_SKEW_MS = 1e3;
+function indexProbe(codebaseRoot, options = {}) {
+  const git = options.git ?? runGit;
+  return {
+    async changedBetween(from, to) {
+      if (options.committedChanges)
+        return options.committedChanges(codebaseRoot, from, to);
+      const result = await git(["diff", "--name-only", "--no-renames", "-z", "--relative", from, to, "--"], codebaseRoot);
+      return result.ok ? result.stdout.split("\0").filter((file) => file.length > 0) : null;
+    },
+    async editedSince(sinceMs) {
+      if (options.sourceEdits)
+        return options.sourceEdits(codebaseRoot, sinceMs, isIndexedSource);
+      const changes = await workingChanges(git, codebaseRoot);
+      if (!changes)
+        return [];
+      if (options.snapshot) {
+        const now = await hashWorkingChanges(codebaseRoot, changes), then = options.snapshot.files;
+        return [.../* @__PURE__ */ new Set([...Object.keys(now), ...Object.keys(then)])].filter((file) => !(file in now) || !(file in then) || now[file] !== then[file]);
+      }
+      const limit = Date.now() + CLOCK_SKEW_MS, edited = [];
+      for (const change of changes) {
+        if (change.gone) {
+          edited.push(change.file);
+          continue;
+        }
+        try {
+          const mtime = (await stat(path.join(codebaseRoot, change.file))).mtimeMs;
+          mtime > sinceMs && mtime <= limit && edited.push(change.file);
+        } catch {
+          edited.push(change.file);
+        }
+      }
+      return [...new Set(edited)];
+    }
+  };
+}
+const short = (sha) => sha.slice(0, 7);
+function listed(files) {
+  return files.length > 5 ? `${files.slice(0, 5).join(", ")} and ${files.length - 5} more` : files.join(", ");
+}
+async function judgeIndex(index, head, probe) {
+  if (head === null)
+    return { state: "stale", reason: "the code's git HEAD can't be read", committedSince: [], editedSince: [] };
+  let committedSince = [], moved;
+  if (head !== index.indexedCommit) {
+    const changed = await probe.changedBetween(index.indexedCommit, head);
+    if (changed === null)
+      return {
+        state: "stale",
+        reason: `it was taken at git HEAD ${index.indexedCommit}, and the code is now at ${head}`,
+        committedSince: [],
+        editedSince: []
+      };
+    if (committedSince = changed.filter(isIndexedSource).sort(), committedSince.length > 0) {
+      const n = committedSince.length;
+      return {
+        state: "stale",
+        reason: `${n} source file${n === 1 ? "" : "s"} changed in commits since it was taken at ${short(index.indexedCommit)} (the code is now at ${short(head)}): ${listed(committedSince)}`,
+        committedSince,
+        editedSince: []
+      };
+    }
+    moved = `the code moved from ${short(index.indexedCommit)} to ${short(head)}, but no commit since changed a source file`;
+  }
+  const at = Date.parse(index.indexedAt), editedSince = Number.isNaN(at) ? [] : [...await probe.editedSince(at)].sort();
+  if (editedSince.length > 0) {
+    const n = editedSince.length;
+    return {
+      state: "fresh-with-uncommitted-edits",
+      reason: `${n} source file${n === 1 ? " has" : "s have"} uncommitted changes (edits, deletes or renames) the index hasn't seen: ${listed(editedSince)}`,
+      committedSince,
+      editedSince
+    };
+  }
+  return { state: "fresh", ...moved ? { reason: moved } : {}, committedSince, editedSince };
+}
+async function assessIndex(projectRoot, analyzer, codebaseRoot, deps, options = {}) {
+  const freshness = await readIndexFreshness(projectRoot, analyzer, codebaseRoot, deps.gitHead);
+  if (!freshness.indexed)
+    return { freshness, judgement: null };
+  const snapshot = options.uncommittedEdits === !1 ? null : await readWorktreeSnapshot(projectRoot, analyzer, freshness.meta.timestamp, deps.isAlive), probe = indexProbe(codebaseRoot, { ...deps, snapshot }), judgement = await judgeIndex({ indexedCommit: freshness.meta.git_head, indexedAt: freshness.meta.timestamp }, freshness.currentGitHead, options.uncommittedEdits === !1 ? { ...probe, editedSince: async () => [] } : probe);
+  return { freshness, judgement };
+}
+function describeIndex(freshness, judgement) {
+  if (!freshness.indexed)
+    return { indexed: !1, fresh: !1 };
+  const state = judgement?.state ?? (freshness.fresh ? "fresh" : "unknown");
+  return {
+    indexed: !0,
+    fresh: state === "fresh",
+    state,
+    ...judgement?.reason ? { reason: judgement.reason } : {},
+    ...judgement?.editedSince.length ? { uncommittedEdits: judgement.editedSince } : {},
+    lastIndexed: freshness.meta.timestamp,
+    gitHead: freshness.meta.git_head,
+    currentGitHead: freshness.currentGitHead,
+    nodeCount: freshness.meta.node_count,
+    edgeCount: freshness.meta.edge_count
+  };
+}
+const WAIT_FOR_INDEX = "Call codebase_index with status: true and wait: 30 until job.state is done";
+async function requireFreshIndex(projectRoot, codebaseRoot, deps, tool, options = {}) {
+  const reindex = `Call codebase_index with wait: 30 (then with status: true and wait: 30 until job.state is done), then call ${tool} again`, job = await readIndexJob(projectRoot, { isAlive: deps.isAlive });
+  if (job?.state === "running")
+    throw new CLIError(`An index run is in progress (started ${job.startedAt})`, ErrorCategory.USER, [
+      `${WAIT_FOR_INDEX}, then call ${tool} again`
+    ]);
+  const analyzer = (await readSession(projectRoot))?.active_analyzer, { freshness, judgement } = analyzer ? await assessIndex(projectRoot, analyzer, codebaseRoot, deps, { uncommittedEdits: options.uncommittedEdits === !0 }) : { freshness: { indexed: !1, fresh: !1 }, judgement: null };
+  if (!analyzer || !freshness.indexed || !judgement)
+    throw new CLIError("The code is not indexed", ErrorCategory.USER, [reindex]);
+  if (judgement.state === "stale" || freshness.currentGitHead === null) {
+    const why = freshness.currentGitHead === null ? `the code's git HEAD can't be read in ${codebaseRoot}` : judgement.reason;
+    throw new CLIError(`The index is stale: ${why}`, ErrorCategory.USER, [reindex]);
+  }
+  return {
+    analyzer,
+    // `fresh` by the rule, not by HEAD equality, for callers that describe it (describeIndex).
+    freshness: { ...freshness, fresh: !0 },
+    index: judgement
+  };
+}
+export {
+  WAIT_FOR_INDEX,
+  analyzerNotFoundError,
+  assessIndex,
+  canonicalRoots,
+  defaultCodebaseToolDeps,
+  describeIndex,
+  indexProbe,
+  installSuggestions,
+  isIndexedSource,
+  judgeIndex,
+  notInstalledError,
+  readWorktreeSnapshot,
+  requireFreshIndex,
+  runGit,
+  takeWorktreeSnapshot,
+  writeWorktreeSnapshot
+};
+//# sourceMappingURL=codebase-shared.js.map

package/dist/mcp/tools/codebase-shared.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/mcp/tools/codebase-shared.ts"],
+  "sourcesContent": ["/**\n * Shared pieces of the codebase tools (codebase_index, codebase_verify, codebase_extract): the\n * analyzer access they need, injectable so tests run without codebase-memory-mcp, the errors that\n * tell the agent what to do next, and the one rule for whether the code index is fresh (also used\n * by project_status).\n */\n\nimport { execFile } from \"node:child_process\";\nimport { createHash } from \"node:crypto\";\nimport { mkdir, readFile, realpath, stat, writeFile } from \"node:fs/promises\";\nimport path from \"node:path\";\nimport { AnalyzerRegistry } from \"../../analyzers/registry.js\";\nimport { analyzerHomepage, currentGitHead, readIndexFreshness, type IndexFreshness } from \"../../analyzers/active-analyzer.js\";\nimport { SOURCE_EXT, VENDOR_EXCLUDE } from \"../../analyzers/cards/build.js\";\nimport { readIndexJob } from \"../../analyzers/index-job.js\";\nimport { readSession } from \"../../analyzers/session-state.js\";\nimport type { CodeChangesResult } from \"../../analyzers/code-changes.js\";\nimport type { AnalyzerBackend } from \"../../analyzers/base-analyzer.js\";\nimport type { AvailableAnalyzer } from \"../../analyzers/types.js\";\nimport type { SpawnFn } from \"../../analyzers/index-job.js\";\nimport type { DrCommand } from \"../../coding-agents/drbot-mcp.js\";\nimport { performDiscover } from \"../../commands/discover-logic.js\";\nimport { CLIError, ErrorCategory } from \"../../utils/errors.js\";\n\nexport interface CodebaseToolDeps {\n  /** The registered backend for an analyzer name. */\n  getAnalyzer(name: string): Promise<AnalyzerBackend | undefined>;\n  /** Non-interactive discovery: the analyzers found, and the first installed one. */\n  discover(): Promise<{ found: AvailableAnalyzer[]; selected?: string }>;\n  /** Spawns the background `dr analyzer index` (defaults to node's spawn). */\n  spawn?: SpawnFn;\n  /** How to run this dr installation (defaults to the running one). */\n  drCommand?: DrCommand;\n  /** Whether a job's process is still the job (defaults to the pid's liveness and command line). */\n  isAlive?: (pid: number) => boolean;\n  /** Sends signals, to stop a run that `force` replaces (defaults to `process.kill`). */\n  kill?: (pid: number, signal: NodeJS.Signals) => void;\n  /** The code's git HEAD (defaults to `git rev-parse HEAD`). */\n  gitHead?: (dir: string) => string | null;\n  /** Files a git range changed, for codebase_extract's `since` (defaults to git). */\n  codeChanges?: (codebaseRoot: string, since: string) => Promise<CodeChangesResult>;\n  /** Source files with uncommitted edits newer than a time (defaults to git status and mtimes). */\n  sourceEdits?: (codebaseRoot: string, sinceMs: number, isSource: (file: string) => boolean) => Promise<string[]>;\n  /**\n   * Files changed between two commits, relative to the codebase root; null when git can't say\n   * (defaults to git diff). Index freshness reads it when HEAD has moved since the index.\n   */\n  committedChanges?: (codebaseRoot: string, from: string, to: string) => Promise<string[] | null>;\n  /** How long codebase_index's `wait` sleeps between reads of the job (default 1 s). */\n  pollIntervalMs?: number;\n  /** codebase_extract's time budget in milliseconds (default 100 s). */\n  budgetMs?: number;\n}\n\nexport const defaultCodebaseToolDeps: CodebaseToolDeps = {\n  async getAnalyzer(name) {\n    const registry = AnalyzerRegistry.getInstance();\n    await registry.initialize();\n    return registry.getAnalyzer(name);\n  },\n  async discover() {\n    const registry = AnalyzerRegistry.getInstance();\n    await registry.initialize();\n    const { discoveryResult } = await performDiscover(registry, { json: true, isTTY: false });\n    return { found: discoveryResult.found, selected: discoveryResult.selected ?? undefined };\n  },\n  gitHead: currentGitHead,\n};\n\n/**\n * The project and codebase roots, spelled canonically (symlinks resolved). The background child\n * finds its project from its working directory, which the OS reports resolved, and the analyzer\n * matches projects by the exact root string, so both sides must use these spellings.\n */\nexport async function canonicalRoots(model: { rootPath: string; codebaseRoot: string }): Promise<{\n  projectRoot: string;\n  codebaseRoot: string;\n}> {\n  const resolve = async (dir: string) => {\n    try {\n      return await realpath(dir);\n    } catch {\n      return dir;\n    }\n  };\n  return { projectRoot: await resolve(model.rootPath), codebaseRoot: await resolve(model.codebaseRoot) };\n}\n\n/** How to install an analyzer, for an agent to relay. */\nexport async function installSuggestions(name: string): Promise<string[]> {\n  const homepage = await analyzerHomepage(name);\n  return [\n    `Install codebase-memory-mcp (${homepage}), for example: npm install -g codebase-memory-mcp`,\n    \"Make sure the binary is on the PATH the dr MCP server runs with (restart the client after installing)\",\n    \"Then call codebase_index again\",\n  ];\n}\n\nexport async function notInstalledError(name: string): Promise<CLIError> {\n  return new CLIError(`The code analyzer is not installed: ${name}`, ErrorCategory.USER, await installSuggestions(name));\n}\n\nexport function analyzerNotFoundError(name: string): CLIError {\n  return new CLIError(`Analyzer not found: ${name}`, ErrorCategory.NOT_FOUND, [\n    \"Run `dr analyzer discover --reselect` in the project to select an installed analyzer\",\n  ]);\n}\n\n// ---------------------------------------------------------------------------------------------\n// git\n\nexport type GitResult = { ok: true; stdout: string } | { ok: false; error: string; missing?: boolean };\nexport type GitRunner = (args: string[], cwd: string) => Promise<GitResult>;\n\n/** Runs git read-only: no shell, no optional locks (so it never contends for index.lock), a timeout. */\nexport const runGit: GitRunner = (args, cwd) =>\n  new Promise((resolve) => {\n    execFile(\n      \"git\",\n      args,\n      {\n        cwd,\n        timeout: 10_000,\n        maxBuffer: 32 * 1024 * 1024,\n        env: { ...process.env, GIT_OPTIONAL_LOCKS: \"0\", GIT_TERMINAL_PROMPT: \"0\" },\n      },\n      (error, stdout, stderr) => {\n        if (!error) return resolve({ ok: true, stdout: String(stdout) });\n        const missing = (error as NodeJS.ErrnoException).code === \"ENOENT\";\n        resolve({ ok: false, missing, error: String(stderr).trim() || error.message });\n      }\n    );\n  });\n\n// ---------------------------------------------------------------------------------------------\n// index freshness: the one rule\n\n/** DR's own folders. Changes under them never make the code index stale. */\nconst DR_FOLDERS = new Set([\"documentation-robotics\", \".dr\"]);\n\n/**\n * Source files the analyzer indexes: what extraction reads (SOURCE_EXT), plus the other languages\n * codebase-memory-mcp supports (spec/analyzers/cbm/analyzer.json) and their header and module\n * variants.\n */\nconst INDEXED_EXT = /\\.(mts|cts|kts|c|cc|cpp|cxx|h|hh|hpp|hxx|lua|dart|groovy)$/i;\n\n/**\n * Whether a change to `file` (relative to the codebase root) can change what the index holds: a\n * source file the analyzer reads, outside DR's own folders and vendored or built code.\n */\nexport function isIndexedSource(file: string): boolean {\n  const posix = file.replace(/\\\\/g, \"/\");\n  if (posix.split(\"/\").some((segment) => DR_FOLDERS.has(segment))) return false;\n  if (VENDOR_EXCLUDE.test(posix)) return false;\n  return SOURCE_EXT.test(posix) || INDEXED_EXT.test(posix);\n}\n\n/** An uncommitted change to a source file: `gone` when it was deleted or renamed away. */\ninterface WorkingChange {\n  file: string;\n  gone: boolean;\n}\n\n/**\n * The source files with uncommitted changes (staged, unstaged or untracked), relative to the\n * codebase root. A delete, and the old path of a rename, come back `gone`. Null when git can't say.\n */\nasync function workingChanges(git: GitRunner, codebaseRoot: string): Promise<WorkingChange[] | null> {\n  const prefix = await git([\"rev-parse\", \"--show-prefix\"], codebaseRoot);\n  if (!prefix.ok) return null;\n  const status = await git([\"status\", \"--porcelain\", \"-z\", \"--untracked-files=all\", \"--\", \".\"], codebaseRoot);\n  if (!status.ok) return null;\n  const top = prefix.stdout.trim();\n  const local = (file: string): string | null => (!top ? file : file.startsWith(top) ? file.slice(top.length) : null);\n  const changes: WorkingChange[] = [];\n  const add = (file: string | undefined, gone: boolean) => {\n    const l = file ? local(file) : null;\n    if (l && isIndexedSource(l)) changes.push({ file: l, gone });\n  };\n  const parts = status.stdout.split(\"\\0\");\n  for (let i = 0; i < parts.length; i++) {\n    const entry = parts[i];\n    if (entry.length < 4) continue;\n    const code = entry.slice(0, 2);\n    const file = entry.slice(3);\n    if (code[0] === \"R\" || code[0] === \"C\") {\n      const from = parts[++i];\n      add(file, false);\n      if (code[0] === \"R\") add(from, true);\n      continue;\n    }\n    add(file, code.includes(\"D\"));\n  }\n  return changes;\n}\n\n/** A hash of each changed file's content; null for a file that is gone. */\nasync function hashWorkingChanges(codebaseRoot: string, changes: WorkingChange[]): Promise<Record<string, string | null>> {\n  const files: Record<string, string | null> = {};\n  for (const change of changes) {\n    if (change.gone) {\n      files[change.file] = null;\n      continue;\n    }\n    try {\n      files[change.file] = createHash(\"sha1\").update(await readFile(path.join(codebaseRoot, change.file))).digest(\"hex\");\n    } catch {\n      files[change.file] = null;\n    }\n  }\n  return files;\n}\n\n/**\n * The uncommitted source files as an index run starts, so a later check can tell any change to\n * them, including a revert (`git stash`, `git checkout -- file`) that no mtime shows. Written by\n * codebase_index next to the index; used only when it belongs to the run that wrote the index.\n */\nexport interface WorktreeSnapshot {\n  version: 1;\n  jobId: string;\n  takenAt: string;\n  files: Record<string, string | null>;\n}\n\nconst snapshotPath = (projectRoot: string, analyzer: string) =>\n  path.join(projectRoot, \".dr\", \"analyzers\", analyzer, \"index-worktree.json\");\n\n/** The working tree's uncommitted source files now, with their content hashes. */\nexport async function takeWorktreeSnapshot(codebaseRoot: string, git: GitRunner = runGit): Promise<Omit<WorktreeSnapshot, \"jobId\"> | null> {\n  const takenAt = new Date().toISOString();\n  const changes = await workingChanges(git, codebaseRoot);\n  if (!changes) return null;\n  return { version: 1, takenAt, files: await hashWorkingChanges(codebaseRoot, changes) };\n}\n\nexport async function writeWorktreeSnapshot(projectRoot: string, analyzer: string, snapshot: WorktreeSnapshot): Promise<void> {\n  await mkdir(path.dirname(snapshotPath(projectRoot, analyzer)), { recursive: true });\n  await writeFile(snapshotPath(projectRoot, analyzer), JSON.stringify(snapshot, null, 2));\n}\n\n/**\n * The snapshot of the run that wrote the current index, or null. It must belong to the last job,\n * that job must have finished, and the index must have been taken between the snapshot and the\n * job's end; an index from another run (a failed one, or `dr analyzer index` outside MCP) has none.\n */\nexport async function readWorktreeSnapshot(\n  projectRoot: string,\n  analyzer: string,\n  indexedAt: string,\n  isAlive?: (pid: number) => boolean\n): Promise<WorktreeSnapshot | null> {\n  let snapshot: WorktreeSnapshot;\n  try {\n    snapshot = JSON.parse(await readFile(snapshotPath(projectRoot, analyzer), \"utf-8\")) as WorktreeSnapshot;\n  } catch {\n    return null;\n  }\n  const job = await readIndexJob(projectRoot, { isAlive });\n  const at = Date.parse(indexedAt);\n  if (!job || job.jobId !== snapshot.jobId || job.state !== \"done\" || snapshot.version !== 1) return null;\n  if (!(Date.parse(snapshot.takenAt) <= at) || (job.finishedAt && Date.parse(job.finishedAt) < at)) return null;\n  return snapshot;\n}\n\n/** A clock a little ahead of this one still counts as now; beyond that an mtime is skew. */\nconst CLOCK_SKEW_MS = 1000;\n\n/**\n * - `fresh`: no source file changed since the index was taken. HEAD may have moved, by commits\n *   that touched only the model, DR's folders or non-source files.\n * - `fresh-with-uncommitted-edits`: no commit changed a source file, but uncommitted source edits\n *   were written after the index was taken. The tools still run, with a warning.\n * - `stale`: commits since the index changed source files, or git can't tell.\n */\nexport type IndexState = \"fresh\" | \"fresh-with-uncommitted-edits\" | \"stale\";\n\nexport interface IndexJudgement {\n  state: IndexState;\n  /** Why the index is not plainly fresh, or why it is fresh though HEAD moved. */\n  reason?: string;\n  /** Source files changed by commits since the indexed commit. */\n  committedSince: string[];\n  /** Source files with uncommitted edits written after the index was taken. */\n  editedSince: string[];\n}\n\n/** What the rule asks git: commits between two points, and uncommitted edits after a time. */\nexport interface IndexProbe {\n  /** Files changed between two commits, relative to the codebase root; null when git can't say. */\n  changedBetween(from: string, to: string): Promise<string[] | null>;\n  /** Source files with uncommitted edits written after `sinceMs`, relative to the codebase root. */\n  editedSince(sinceMs: number): Promise<string[]>;\n}\n\n/**\n * The probe the rule uses: git from the codebase root (async), or the injected deps.\n *\n * Uncommitted changes: with the snapshot of the run that wrote the index, any source file whose\n * uncommitted state differs from the snapshot (edited, deleted, renamed, reverted). Without one,\n * every delete and renamed-away path, and the files written after the index was taken; an mtime\n * in the future is clock skew and is ignored, so it can't ask for a re-index on every call.\n */\nexport function indexProbe(\n  codebaseRoot: string,\n  options: { git?: GitRunner; snapshot?: WorktreeSnapshot | null } & Pick<CodebaseToolDeps, \"committedChanges\" | \"sourceEdits\"> = {}\n): IndexProbe {\n  const git = options.git ?? runGit;\n  return {\n    async changedBetween(from, to) {\n      if (options.committedChanges) return options.committedChanges(codebaseRoot, from, to);\n      const result = await git([\"diff\", \"--name-only\", \"--no-renames\", \"-z\", \"--relative\", from, to, \"--\"], codebaseRoot);\n      return result.ok ? result.stdout.split(\"\\0\").filter((file) => file.length > 0) : null;\n    },\n    async editedSince(sinceMs) {\n      if (options.sourceEdits) return options.sourceEdits(codebaseRoot, sinceMs, isIndexedSource);\n      const changes = await workingChanges(git, codebaseRoot);\n      if (!changes) return [];\n      if (options.snapshot) {\n        const now = await hashWorkingChanges(codebaseRoot, changes);\n        const then = options.snapshot.files;\n        const files = new Set([...Object.keys(now), ...Object.keys(then)]);\n        return [...files].filter((file) => !(file in now) || !(file in then) || now[file] !== then[file]);\n      }\n      const limit = Date.now() + CLOCK_SKEW_MS;\n      const edited: string[] = [];\n      for (const change of changes) {\n        if (change.gone) {\n          edited.push(change.file);\n          continue;\n        }\n        try {\n          const mtime = (await stat(path.join(codebaseRoot, change.file))).mtimeMs;\n          if (mtime > sinceMs && mtime <= limit) edited.push(change.file);\n        } catch {\n          edited.push(change.file); // listed by git, gone now\n        }\n      }\n      return [...new Set(edited)];\n    },\n  };\n}\n\nconst short = (sha: string): string => sha.slice(0, 7);\n\nfunction listed(files: string[]): string {\n  return files.length > 5 ? `${files.slice(0, 5).join(\", \")} and ${files.length - 5} more` : files.join(\", \");\n}\n\n/**\n * Whether an index taken at `indexedCommit` and `indexedAt` still describes the code at `head`.\n * The one freshness rule for project_status, codebase_index, codebase_verify and codebase_extract.\n */\nexport async function judgeIndex(\n  index: { indexedCommit: string; indexedAt: string },\n  head: string | null,\n  probe: IndexProbe\n): Promise<IndexJudgement> {\n  if (head === null) {\n    return { state: \"stale\", reason: \"the code's git HEAD can't be read\", committedSince: [], editedSince: [] };\n  }\n  let committedSince: string[] = [];\n  let moved: string | undefined;\n  if (head !== index.indexedCommit) {\n    const changed = await probe.changedBetween(index.indexedCommit, head);\n    if (changed === null) {\n      return {\n        state: \"stale\",\n        reason: `it was taken at git HEAD ${index.indexedCommit}, and the code is now at ${head}`,\n        committedSince: [],\n        editedSince: [],\n      };\n    }\n    committedSince = changed.filter(isIndexedSource).sort();\n    if (committedSince.length > 0) {\n      const n = committedSince.length;\n      return {\n        state: \"stale\",\n        reason:\n          `${n} source file${n === 1 ? \"\" : \"s\"} changed in commits since it was taken at ` +\n          `${short(index.indexedCommit)} (the code is now at ${short(head)}): ${listed(committedSince)}`,\n        committedSince,\n        editedSince: [],\n      };\n    }\n    moved = `the code moved from ${short(index.indexedCommit)} to ${short(head)}, but no commit since changed a source file`;\n  }\n  const at = Date.parse(index.indexedAt);\n  const editedSince = Number.isNaN(at) ? [] : [...(await probe.editedSince(at))].sort();\n  if (editedSince.length > 0) {\n    const n = editedSince.length;\n    return {\n      state: \"fresh-with-uncommitted-edits\",\n      reason: `${n} source file${n === 1 ? \" has\" : \"s have\"} uncommitted changes (edits, deletes or renames) the index hasn't seen: ${listed(editedSince)}`,\n      committedSince,\n      editedSince,\n    };\n  }\n  return { state: \"fresh\", ...(moved ? { reason: moved } : {}), committedSince, editedSince };\n}\n\n/**\n * The index's freshness by the rule, read the way the codebase tools read it. With\n * `uncommittedEdits: false` it skips the uncommitted-edits check (which never makes an index\n * stale), so `fresh-with-uncommitted-edits` reads as `fresh`.\n */\nexport async function assessIndex(\n  projectRoot: string,\n  analyzer: string,\n  codebaseRoot: string,\n  deps: CodebaseToolDeps,\n  options: { uncommittedEdits?: boolean } = {}\n): Promise<{ freshness: IndexFreshness; judgement: IndexJudgement | null }> {\n  const freshness = await readIndexFreshness(projectRoot, analyzer, codebaseRoot, deps.gitHead);\n  if (!freshness.indexed) return { freshness, judgement: null };\n  const snapshot =\n    options.uncommittedEdits === false ? null : await readWorktreeSnapshot(projectRoot, analyzer, freshness.meta.timestamp, deps.isAlive);\n  const probe = indexProbe(codebaseRoot, { ...deps, snapshot });\n  const judgement = await judgeIndex(\n    { indexedCommit: freshness.meta.git_head, indexedAt: freshness.meta.timestamp },\n    freshness.currentGitHead,\n    options.uncommittedEdits === false ? { ...probe, editedSince: async () => [] } : probe\n  );\n  return { freshness, judgement };\n}\n\n/**\n * The index part of a codebase tool result. `fresh` is true only for the `fresh` state. Without a\n * judgement it never judges by HEAD equality: it reports the freshness it was given, which\n * requireFreshIndex sets by the rule, and otherwise says the state is unknown.\n *\n * Pass the judgement whenever there is one, so the state matches project_status: a caller of\n * requireFreshIndex passes its `index` (`describeIndex(result.freshness, result.index)`), and\n * then uncommitted edits read `fresh-with-uncommitted-edits` (with `fresh: false`, the reason and\n * `uncommittedEdits`) instead of a plain `fresh` beside a warning about those edits.\n */\nexport function describeIndex(freshness: IndexFreshness, judgement?: IndexJudgement | null): Record<string, unknown> {\n  if (!freshness.indexed) return { indexed: false, fresh: false };\n  const state: IndexState | \"unknown\" = judgement?.state ?? (freshness.fresh ? \"fresh\" : \"unknown\");\n  return {\n    indexed: true,\n    fresh: state === \"fresh\",\n    state,\n    ...(judgement?.reason ? { reason: judgement.reason } : {}),\n    ...(judgement?.editedSince.length ? { uncommittedEdits: judgement.editedSince } : {}),\n    lastIndexed: freshness.meta.timestamp,\n    gitHead: freshness.meta.git_head,\n    currentGitHead: freshness.currentGitHead,\n    nodeCount: freshness.meta.node_count,\n    edgeCount: freshness.meta.edge_count,\n  };\n}\n\n/** How an agent waits for an index run: a blocking call, not a tight polling loop. */\nexport const WAIT_FOR_INDEX = \"Call codebase_index with status: true and wait: 30 until job.state is done\";\n\n/**\n * The analyzer and its index, when the index is usable: not stale by the rule (judgeIndex), with\n * no index run in flight. Otherwise a CLIError that points at codebase_index, then `tool` again.\n *\n * Uncommitted edits never block. With `uncommittedEdits: true`, `index.state` is\n * `fresh-with-uncommitted-edits` when uncommitted source edits are newer than the index, and\n * `index.editedSince` lists them for the caller's warning; without it that check is skipped.\n */\nexport async function requireFreshIndex(\n  projectRoot: string,\n  codebaseRoot: string,\n  deps: CodebaseToolDeps,\n  tool: string,\n  options: { uncommittedEdits?: boolean } = {}\n): Promise<{\n  analyzer: string;\n  freshness: Extract<IndexFreshness, { indexed: true }> & { currentGitHead: string };\n  index: IndexJudgement;\n}> {\n  const reindex = `Call codebase_index with wait: 30 (then with status: true and wait: 30 until job.state is done), then call ${tool} again`;\n  const job = await readIndexJob(projectRoot, { isAlive: deps.isAlive });\n  if (job?.state === \"running\") {\n    throw new CLIError(`An index run is in progress (started ${job.startedAt})`, ErrorCategory.USER, [\n      `${WAIT_FOR_INDEX}, then call ${tool} again`,\n    ]);\n  }\n  const analyzer = (await readSession(projectRoot))?.active_analyzer;\n  const { freshness, judgement } = analyzer\n    ? await assessIndex(projectRoot, analyzer, codebaseRoot, deps, { uncommittedEdits: options.uncommittedEdits === true })\n    : { freshness: { indexed: false, fresh: false } as const, judgement: null };\n  if (!analyzer || !freshness.indexed || !judgement) {\n    throw new CLIError(\"The code is not indexed\", ErrorCategory.USER, [reindex]);\n  }\n  if (judgement.state === \"stale\" || freshness.currentGitHead === null) {\n    const why = freshness.currentGitHead === null ? `the code's git HEAD can't be read in ${codebaseRoot}` : judgement.reason;\n    throw new CLIError(`The index is stale: ${why}`, ErrorCategory.USER, [reindex]);\n  }\n  return {\n    analyzer,\n    // `fresh` by the rule, not by HEAD equality, for callers that describe it (describeIndex).\n    freshness: { ...freshness, fresh: true } as Extract<IndexFreshness, { indexed: true }> & { currentGitHead: string },\n    index: judgement,\n  };\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/mcp/tools/codebase-verify.js

@@ -0,0 +1,48 @@
+import { z } from "zod";
+import { splitVerifyLayers, VERIFIABLE_LAYERS } from "../../analyzers/active-analyzer.js";
+import { jsonResult, loadModel, rootPathSchema, runTool } from "./shared.js";
+import { analyzerNotFoundError, canonicalRoots, defaultCodebaseToolDeps, requireFreshIndex } from "./codebase-shared.js";
+const inputSchema = {
+  layers: z.array(z.string()).optional().describe(`Layers to verify (default ["api"]). Only ${VERIFIABLE_LAYERS.join(", ")} has a check; others are listed as not verified.`),
+  rootPath: rootPathSchema
+}, VERIFY_SCOPE = "codebase_verify checks only the API layer: the HTTP routes found in the code against the model's API operations. It says nothing about the other layers.", NO_ROUTES_NOTE = "The analyzer found no HTTP routes in the code (a library, a CLI, or routes it can't read), so every API operation in the model lands in in_model_only. That is expected here and is not drift; don't change the model because of it.";
+function createCodebaseVerifyHandler(deps = defaultCodebaseToolDeps) {
+  return async function(args) {
+    return runTool(async () => {
+      const model = await loadModel(args.rootPath), { projectRoot, codebaseRoot } = await canonicalRoots(model), { verifiable, unsupported } = splitVerifyLayers(args.layers), notVerified = unsupported.map((layer) => ({ layer, reason: "No verification available for this layer" }));
+      if (verifiable.length === 0)
+        return jsonResult({ layers_verified: [], layers_not_verified: notVerified, scope: VERIFY_SCOPE });
+      const { analyzer, index } = await requireFreshIndex(projectRoot, codebaseRoot, deps, "codebase_verify", {
+        uncommittedEdits: !0
+      }), backend = await deps.getAnalyzer(analyzer);
+      if (!backend)
+        throw analyzerNotFoundError(analyzer);
+      const report = await backend.verify(projectRoot, {
+        layers: verifiable,
+        changesetAware: !0,
+        codebaseRoot
+      }), routesInCode = report.buckets.matched.length + report.buckets.in_graph_only.length;
+      return jsonResult({
+        ...report,
+        ...notVerified.length > 0 ? { layers_not_verified: notVerified } : {},
+        scope: VERIFY_SCOPE,
+        ...routesInCode === 0 ? { note: NO_ROUTES_NOTE } : {},
+        ...index.state === "fresh-with-uncommitted-edits" ? { warning: `This report may miss uncommitted edits: ${index.reason}. Call codebase_index with wait: 30 to re-index them.` } : {}
+      });
+    });
+  };
+}
+const codebaseVerifyHandler = createCodebaseVerifyHandler(), codebaseVerifyTool = {
+  name: "codebase_verify",
+  description: "Checks the API layer only: compares the HTTP routes the code analyzer found in the indexed code with the model's API operations (the active changeset's view when one is active). Returns buckets: matched, in_graph_only (in the code, not the model), in_model_only (in the model, not found in the code) and ignored, with a summary and hints. On a library or a project with no HTTP routes, every operation lands in in_model_only: that is expected, not drift. It doesn't check other layers. Needs a fresh index: if there is none, a run is in flight, or source files changed since, it says so; run codebase_index first. Read-only.",
+  inputSchema,
+  handler: codebaseVerifyHandler
+};
+export {
+  NO_ROUTES_NOTE,
+  VERIFY_SCOPE,
+  codebaseVerifyHandler,
+  codebaseVerifyTool,
+  createCodebaseVerifyHandler
+};
+//# sourceMappingURL=codebase-verify.js.map

package/dist/mcp/tools/codebase-verify.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/mcp/tools/codebase-verify.ts"],
+  "sourcesContent": ["/**\n * codebase_verify \u2014 compare the HTTP routes the code analyzer found in the code with the model's\n * API operations, as structured data. It checks the API layer only. The same report as\n * `dr analyzer verify --json`, from the same engine (analyzers/verify-engine.ts through the\n * analyzer's verify()). Read-only.\n *\n * It needs a usable index (codebase-shared.ts judgeIndex): when there is none, a run is in\n * flight, or source files changed in commits since the last one, it says so and points at\n * codebase_index. Uncommitted edits newer than the index give a warning, not a refusal.\n */\n\nimport { z } from \"zod\";\nimport type { CallToolResult } from \"@modelcontextprotocol/sdk/types.js\";\nimport { splitVerifyLayers, VERIFIABLE_LAYERS } from \"../../analyzers/active-analyzer.js\";\nimport { jsonResult, loadModel, rootPathSchema, runTool, type McpToolDefinition } from \"./shared.js\";\nimport {\n  analyzerNotFoundError,\n  canonicalRoots,\n  defaultCodebaseToolDeps,\n  requireFreshIndex,\n  type CodebaseToolDeps,\n} from \"./codebase-shared.js\";\n\nconst inputSchema = {\n  layers: z\n    .array(z.string())\n    .optional()\n    .describe(`Layers to verify (default [\"api\"]). Only ${VERIFIABLE_LAYERS.join(\", \")} has a check; others are listed as not verified.`),\n  rootPath: rootPathSchema,\n};\n\nexport type CodebaseVerifyArgs = z.infer<z.ZodObject<typeof inputSchema>>;\n\n/** What every report says about its reach, so its findings aren't read as more than they are. */\nexport const VERIFY_SCOPE =\n  \"codebase_verify checks only the API layer: the HTTP routes found in the code against the model's API operations. \" +\n  \"It says nothing about the other layers.\";\n\n/** Said when the code has no routes: a library's operations are not drift. */\nexport const NO_ROUTES_NOTE =\n  \"The analyzer found no HTTP routes in the code (a library, a CLI, or routes it can't read), so every API operation \" +\n  \"in the model lands in in_model_only. That is expected here and is not drift; don't change the model because of it.\";\n\nexport function createCodebaseVerifyHandler(deps: CodebaseToolDeps = defaultCodebaseToolDeps) {\n  return async function codebaseVerifyHandler(args: CodebaseVerifyArgs): Promise<CallToolResult> {\n    return runTool(async () => {\n      const model = await loadModel(args.rootPath);\n      // The same spelling codebase_index's run indexed under (see canonicalRoots).\n      const { projectRoot, codebaseRoot } = await canonicalRoots(model);\n\n      const { verifiable, unsupported } = splitVerifyLayers(args.layers);\n      const notVerified = unsupported.map((layer) => ({ layer, reason: \"No verification available for this layer\" }));\n      if (verifiable.length === 0) {\n        return jsonResult({ layers_verified: [], layers_not_verified: notVerified, scope: VERIFY_SCOPE });\n      }\n\n      const { analyzer, index } = await requireFreshIndex(projectRoot, codebaseRoot, deps, \"codebase_verify\", {\n        uncommittedEdits: true,\n      });\n\n      const backend = await deps.getAnalyzer(analyzer);\n      if (!backend) throw analyzerNotFoundError(analyzer);\n\n      const report = await backend.verify(projectRoot, {\n        layers: verifiable,\n        changesetAware: true,\n        codebaseRoot,\n      });\n      const routesInCode = report.buckets.matched.length + report.buckets.in_graph_only.length;\n      return jsonResult({\n        ...report,\n        ...(notVerified.length > 0 ? { layers_not_verified: notVerified } : {}),\n        scope: VERIFY_SCOPE,\n        ...(routesInCode === 0 ? { note: NO_ROUTES_NOTE } : {}),\n        ...(index.state === \"fresh-with-uncommitted-edits\"\n          ? { warning: `This report may miss uncommitted edits: ${index.reason}. Call codebase_index with wait: 30 to re-index them.` }\n          : {}),\n      });\n    });\n  };\n}\n\nexport const codebaseVerifyHandler = createCodebaseVerifyHandler();\n\nexport const codebaseVerifyTool: McpToolDefinition<typeof inputSchema> = {\n  name: \"codebase_verify\",\n  description:\n    \"Checks the API layer only: compares the HTTP routes the code analyzer found in the indexed code with the \" +\n    \"model's API operations (the active changeset's view when one is active). Returns buckets: matched, \" +\n    \"in_graph_only (in the code, not the model), in_model_only (in the model, not found in the code) and ignored, \" +\n    \"with a summary and hints. On a library or a project with no HTTP routes, every operation lands in \" +\n    \"in_model_only: that is expected, not drift. It doesn't check other layers. Needs a fresh index: if there is \" +\n    \"none, a run is in flight, or source files changed since, it says so; run codebase_index first. Read-only.\",\n  inputSchema,\n  handler: codebaseVerifyHandler,\n};\n"],
+  "mappings": "AAWA,SAAS,SAAS;AAElB,SAAS,mBAAmB,yBAAyB;AACrD,SAAS,YAAY,WAAW,gBAAgB,eAAuC;AACvF,SACE,uBACA,gBACA,yBACA,yBAEK;AAEP,MAAM,cAAc;EAClB,QAAQ,EACL,MAAM,EAAE,OAAM,CAAE,EAChB,SAAQ,EACR,SAAS,4CAA4C,kBAAkB,KAAK,IAAI,CAAC,kDAAkD;EACtI,UAAU;GAMC,eACX,4JAIW,iBACX;AAGI,SAAU,4BAA4B,OAAyB,yBAAuB;AAC1F,SAAO,eAAqC,MAAwB;AAClE,WAAO,QAAQ,YAAW;AACxB,YAAM,QAAQ,MAAM,UAAU,KAAK,QAAQ,GAErC,EAAE,aAAa,aAAY,IAAK,MAAM,eAAe,KAAK,GAE1D,EAAE,YAAY,YAAW,IAAK,kBAAkB,KAAK,MAAM,GAC3D,cAAc,YAAY,IAAI,CAAC,WAAW,EAAE,OAAO,QAAQ,2CAA0C,EAAG;AAC9G,UAAI,WAAW,WAAW;AACxB,eAAO,WAAW,EAAE,iBAAiB,CAAA,GAAI,qBAAqB,aAAa,OAAO,aAAY,CAAE;AAGlG,YAAM,EAAE,UAAU,MAAK,IAAK,MAAM,kBAAkB,aAAa,cAAc,MAAM,mBAAmB;QACtG,kBAAkB;OACnB,GAEK,UAAU,MAAM,KAAK,YAAY,QAAQ;AAC/C,UAAI,CAAC;AAAS,cAAM,sBAAsB,QAAQ;AAElD,YAAM,SAAS,MAAM,QAAQ,OAAO,aAAa;QAC/C,QAAQ;QACR,gBAAgB;QAChB;OACD,GACK,eAAe,OAAO,QAAQ,QAAQ,SAAS,OAAO,QAAQ,cAAc;AAClF,aAAO,WAAW;QAChB,GAAG;QACH,GAAI,YAAY,SAAS,IAAI,EAAE,qBAAqB,YAAW,IAAK,CAAA;QACpE,OAAO;QACP,GAAI,iBAAiB,IAAI,EAAE,MAAM,eAAc,IAAK,CAAA;QACpD,GAAI,MAAM,UAAU,iCAChB,EAAE,SAAS,2CAA2C,MAAM,MAAM,wDAAuD,IACzH,CAAA;OACL;IACH,CAAC;EACH;AACF;AAEO,MAAM,wBAAwB,4BAA2B,GAEnD,qBAA4D;EACvE,MAAM;EACN,aACE;EAMF;EACA,SAAS;;",
+  "names": []
+}

package/dist/mcp/tools/index.js

@@ -26,6 +26,13 @@ import { chatStatusTool } from "./chat-status.js";
 import { chatLaunchTool } from "./chat-launch.js";
 import { changesetVerifyTool } from "./changeset-verify.js";
 import { changesetUpdateTool, changesetUnstageTool, changesetDiscardTool } from "./changeset-editing.js";
+import { projectInitTool, projectUpgradeTool } from "./project-tools.js";
+import { codebaseIndexTool } from "./codebase-index.js";
+import { codebaseVerifyTool } from "./codebase-verify.js";
+import { changesetCommitTool } from "./changeset-commit.js";
+import { reviewOpenTool } from "./review-open.js";
+import { projectStatusTool } from "./project-status.js";
+import { codebaseExtractTool } from "./codebase-extract.js";
 export {
   annotationCreateTool,
   annotationDeleteTool,
@@ -35,6 +42,7 @@ export {
   annotationUpdateTool,
   changesetActivateTool,
   changesetBriefTool,
+  changesetCommitTool,
   changesetCreateTool,
   changesetDeactivateTool,
   changesetDiscardTool,
@@ -46,6 +54,9 @@ export {
   changesetVerifyTool,
   chatLaunchTool,
   chatStatusTool,
+  codebaseExtractTool,
+  codebaseIndexTool,
+  codebaseVerifyTool,
   modelAddTool,
   modelDeleteTool,
   modelExportTool,
@@ -58,8 +69,12 @@ export {
   modelTraceTool,
   modelUpdateTool,
   modelValidateTool,
+  projectInitTool,
+  projectStatusTool,
+  projectUpgradeTool,
   relationshipAddTool,
   relationshipDeleteTool,
+  reviewOpenTool,
   specTypeTool
 };
 //# sourceMappingURL=index.js.map

package/dist/mcp/tools/index.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../src/mcp/tools/index.ts"],
-  "sourcesContent": ["export { annotationListTool } from \"./annotation-list.js\";\nexport { annotationGetTool } from \"./annotation-get.js\";\nexport { annotationCreateTool } from \"./annotation-create.js\";\nexport { annotationUpdateTool } from \"./annotation-update.js\";\nexport { annotationDeleteTool } from \"./annotation-delete.js\";\nexport { annotationReplyTool } from \"./annotation-reply.js\";\nexport { modelListTool } from \"./model-list.js\";\nexport { modelShowTool } from \"./model-show.js\";\nexport { modelSearchTool } from \"./model-search.js\";\nexport { modelStatsTool } from \"./model-stats.js\";\nexport { modelInfoTool } from \"./model-info.js\";\nexport { modelTraceTool } from \"./model-trace.js\";\nexport { modelAddTool } from \"./model-add.js\";\nexport { modelUpdateTool } from \"./model-update.js\";\nexport { modelDeleteTool } from \"./model-delete.js\";\nexport { modelValidateTool } from \"./model-validate.js\";\nexport { modelExportTool } from \"./model-export.js\";\nexport { modelReloadTool } from \"./model-reload.js\";\nexport { changesetListTool } from \"./changeset-list.js\";\nexport { changesetShowTool } from \"./changeset-show.js\";\nexport { changesetCreateTool, changesetActivateTool, changesetDeactivateTool } from \"./changeset-lifecycle.js\";\nexport { changesetImpactTool, changesetBriefTool } from \"./changeset-analysis-tools.js\";\nexport { relationshipAddTool, relationshipDeleteTool } from \"./relationship-tools.js\";\nexport { specTypeTool } from \"./spec-type.js\";\nexport { chatStatusTool } from \"./chat-status.js\";\nexport { chatLaunchTool } from \"./chat-launch.js\";\nexport { changesetVerifyTool } from \"./changeset-verify.js\";\nexport type { McpToolDefinition } from \"./shared.js\";\nexport { changesetUpdateTool, changesetUnstageTool, changesetDiscardTool } from \"./changeset-editing.js\";\n"],
-  "mappings": "AAAA,SAAS,0BAA0B;AACnC,SAAS,yBAAyB;AAClC,SAAS,4BAA4B;AACrC,SAAS,4BAA4B;AACrC,SAAS,4BAA4B;AACrC,SAAS,2BAA2B;AACpC,SAAS,qBAAqB;AAC9B,SAAS,qBAAqB;AAC9B,SAAS,uBAAuB;AAChC,SAAS,sBAAsB;AAC/B,SAAS,qBAAqB;AAC9B,SAAS,sBAAsB;AAC/B,SAAS,oBAAoB;AAC7B,SAAS,uBAAuB;AAChC,SAAS,uBAAuB;AAChC,SAAS,yBAAyB;AAClC,SAAS,uBAAuB;AAChC,SAAS,uBAAuB;AAChC,SAAS,yBAAyB;AAClC,SAAS,yBAAyB;AAClC,SAAS,qBAAqB,uBAAuB,+BAA+B;AACpF,SAAS,qBAAqB,0BAA0B;AACxD,SAAS,qBAAqB,8BAA8B;AAC5D,SAAS,oBAAoB;AAC7B,SAAS,sBAAsB;AAC/B,SAAS,sBAAsB;AAC/B,SAAS,2BAA2B;AAEpC,SAAS,qBAAqB,sBAAsB,4BAA4B;",
+  "sourcesContent": ["export { annotationListTool } from \"./annotation-list.js\";\nexport { annotationGetTool } from \"./annotation-get.js\";\nexport { annotationCreateTool } from \"./annotation-create.js\";\nexport { annotationUpdateTool } from \"./annotation-update.js\";\nexport { annotationDeleteTool } from \"./annotation-delete.js\";\nexport { annotationReplyTool } from \"./annotation-reply.js\";\nexport { modelListTool } from \"./model-list.js\";\nexport { modelShowTool } from \"./model-show.js\";\nexport { modelSearchTool } from \"./model-search.js\";\nexport { modelStatsTool } from \"./model-stats.js\";\nexport { modelInfoTool } from \"./model-info.js\";\nexport { modelTraceTool } from \"./model-trace.js\";\nexport { modelAddTool } from \"./model-add.js\";\nexport { modelUpdateTool } from \"./model-update.js\";\nexport { modelDeleteTool } from \"./model-delete.js\";\nexport { modelValidateTool } from \"./model-validate.js\";\nexport { modelExportTool } from \"./model-export.js\";\nexport { modelReloadTool } from \"./model-reload.js\";\nexport { changesetListTool } from \"./changeset-list.js\";\nexport { changesetShowTool } from \"./changeset-show.js\";\nexport { changesetCreateTool, changesetActivateTool, changesetDeactivateTool } from \"./changeset-lifecycle.js\";\nexport { changesetImpactTool, changesetBriefTool } from \"./changeset-analysis-tools.js\";\nexport { relationshipAddTool, relationshipDeleteTool } from \"./relationship-tools.js\";\nexport { specTypeTool } from \"./spec-type.js\";\nexport { chatStatusTool } from \"./chat-status.js\";\nexport { chatLaunchTool } from \"./chat-launch.js\";\nexport { changesetVerifyTool } from \"./changeset-verify.js\";\nexport type { McpToolDefinition } from \"./shared.js\";\nexport { changesetUpdateTool, changesetUnstageTool, changesetDiscardTool } from \"./changeset-editing.js\";\nexport { projectInitTool, projectUpgradeTool } from \"./project-tools.js\";\nexport { codebaseIndexTool } from \"./codebase-index.js\";\nexport { codebaseVerifyTool } from \"./codebase-verify.js\";\nexport { changesetCommitTool } from \"./changeset-commit.js\";\nexport { reviewOpenTool } from \"./review-open.js\";\nexport { projectStatusTool } from \"./project-status.js\";\nexport { codebaseExtractTool } from \"./codebase-extract.js\";\n"],
+  "mappings": "AAAA,SAAS,0BAA0B;AACnC,SAAS,yBAAyB;AAClC,SAAS,4BAA4B;AACrC,SAAS,4BAA4B;AACrC,SAAS,4BAA4B;AACrC,SAAS,2BAA2B;AACpC,SAAS,qBAAqB;AAC9B,SAAS,qBAAqB;AAC9B,SAAS,uBAAuB;AAChC,SAAS,sBAAsB;AAC/B,SAAS,qBAAqB;AAC9B,SAAS,sBAAsB;AAC/B,SAAS,oBAAoB;AAC7B,SAAS,uBAAuB;AAChC,SAAS,uBAAuB;AAChC,SAAS,yBAAyB;AAClC,SAAS,uBAAuB;AAChC,SAAS,uBAAuB;AAChC,SAAS,yBAAyB;AAClC,SAAS,yBAAyB;AAClC,SAAS,qBAAqB,uBAAuB,+BAA+B;AACpF,SAAS,qBAAqB,0BAA0B;AACxD,SAAS,qBAAqB,8BAA8B;AAC5D,SAAS,oBAAoB;AAC7B,SAAS,sBAAsB;AAC/B,SAAS,sBAAsB;AAC/B,SAAS,2BAA2B;AAEpC,SAAS,qBAAqB,sBAAsB,4BAA4B;AAChF,SAAS,iBAAiB,0BAA0B;AACpD,SAAS,yBAAyB;AAClC,SAAS,0BAA0B;AACnC,SAAS,2BAA2B;AACpC,SAAS,sBAAsB;AAC/B,SAAS,yBAAyB;AAClC,SAAS,2BAA2B;",
   "names": []
 }