token-goat 2.6.30 → 2.6.31

package/dist/token-goat-chunk-QL2743EW.mjs

@@ -0,0 +1,707 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  ABSENT_PIN,
+  CONTENT_MAX_INPUT_CHARS,
+  ConfinementIdentityError,
+  compressText,
+  createHandoff,
+  fileIdentity,
+  findSpecSeparator,
+  parseLineRange,
+  pinKey,
+  resolveHandoff,
+  retrieveText,
+  runBrief,
+  runChanged,
+  runExports,
+  runGrep,
+  runImports,
+  runOutline,
+  runRead,
+  runRefs,
+  runSection,
+  runSemantic,
+  runSkeleton,
+  runSymbol,
+  withPinnedReads
+} from "./token-goat-chunk-P7I6LS5H.mjs";
+import {
+  buildProjectMap,
+  embeddingsDepsAvailable,
+  formatProjectMap,
+  getDirtyPathsFor,
+  getProjectIndexCounts,
+  isWorkerRunning,
+  mapLookupBytesSaved
+} from "./token-goat-chunk-HPY7XE77.mjs";
+import {
+  VERSION,
+  dataDir,
+  extractErrorMessage,
+  getDb,
+  globalDbPath,
+  loadConfig,
+  normalizePath,
+  recordStat,
+  resolveProjectRoot
+} from "./token-goat-chunk-X7PIWZMB.mjs";
+import "./token-goat-chunk-VYC34TBW.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-4WGVGN6W.mjs";
+
+// src/mcp_server.ts
+init_define_import_meta_env();
+import * as fs from "fs";
+import * as path from "path";
+var TOKEN_GOAT_RETRY_RE = /token-goat (\w[\w-]*) "([^"]+)"/g;
+var MCP_MAX_LIMIT = 1e3;
+var MCP_MAX_CONTEXT_LINES = 50;
+var MCP_MAX_OUTPUT_LINES = 1e4;
+var RETRY_PARAM_BY_COMMAND = {
+  read: "spec",
+  section: "spec",
+  symbol: "name",
+  skeleton: "file",
+  outline: "file"
+};
+function mcpFriendlyText(text) {
+  let out = text.replace(TOKEN_GOAT_RETRY_RE, (_match, cmd, arg) => {
+    const param = RETRY_PARAM_BY_COMMAND[cmd] ?? "parameter";
+    return `the "${cmd}" tool again with a more specific ${param} (e.g. "${arg}")`;
+  });
+  out = out.replace(/--json\b/g, "the json parameter");
+  out = out.replace(/--limit\b/g, "the limit parameter");
+  out = out.replace(/--top\b/g, "the top parameter");
+  out = out.replace(/--grep PATTERN, --section HEADING, or --tail N/g, "a narrower query");
+  return out;
+}
+function toCallToolResult(result) {
+  return {
+    content: [{ type: "text", text: mcpFriendlyText(result.text) }],
+    isError: result.code !== 0
+  };
+}
+function compressionPayload(result) {
+  if (result.inlineWins) return { ...result };
+  const { compact: _compact, ...rest } = result;
+  return { ...rest, payloadWithheld: "inlining the compact payload would cost more tokens than the original text; use the recovery command to retrieve it" };
+}
+function toRawCallToolResult(result) {
+  return {
+    content: [{ type: "text", text: result.text }],
+    isError: result.code !== 0
+  };
+}
+function captureOutput(fn) {
+  const chunks = [];
+  const record = (chunk, encodingOrCb, maybeCb) => {
+    chunks.push(typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf-8"));
+    const callback = typeof encodingOrCb === "function" ? encodingOrCb : typeof maybeCb === "function" ? maybeCb : void 0;
+    if (typeof callback === "function") callback();
+    return true;
+  };
+  const origStdoutWrite = process.stdout.write.bind(process.stdout);
+  const origStderrWrite = process.stderr.write.bind(process.stderr);
+  process.stdout.write = record;
+  process.stderr.write = record;
+  try {
+    const code = fn();
+    return { code, text: chunks.join("") };
+  } finally {
+    process.stdout.write = origStdoutWrite;
+    process.stderr.write = origStderrWrite;
+  }
+}
+function toCallToolResultFromExitCode(fn) {
+  const { code, text } = captureOutput(fn);
+  return toCallToolResult({ text, code });
+}
+function realPathOrSelf(p) {
+  try {
+    return fs.realpathSync.native(p);
+  } catch {
+    return p;
+  }
+}
+function forCompare(p) {
+  return process.platform === "win32" ? p.toLowerCase() : p;
+}
+function resolveToolRoot(projectRoot) {
+  return resolveProjectRoot(projectRoot !== void 0 ? { project: projectRoot } : {});
+}
+function checkWithinProjectRoot(target, resolvedRoot) {
+  const root = forCompare(normalizePath(realPathOrSelf(resolvedRoot)));
+  const abs = path.resolve(resolvedRoot, normalizePath(target));
+  let identity;
+  try {
+    identity = fileIdentity(fs.statSync(abs, { bigint: true }));
+  } catch {
+    identity = null;
+  }
+  const realNative = realPathOrSelf(abs);
+  const real = forCompare(normalizePath(realNative));
+  return { inside: real === root || real.startsWith(root.endsWith("/") ? root : root + "/"), abs, real: realNative, identity };
+}
+function specFilePart(spec) {
+  const range = parseLineRange(spec);
+  if (range !== null) return range.file;
+  const colonIdx = findSpecSeparator(spec);
+  return colonIdx === -1 ? spec : spec.slice(0, colonIdx);
+}
+var NO_PINS = /* @__PURE__ */ new Map();
+function confineTargets(targets, resolvedRoot, splitCommas = true) {
+  if (!loadConfig(resolvedRoot).mcp.confine_reads_to_project_root) return { ok: true, targets, pins: NO_PINS };
+  const allowedRoots = loadConfig().mcp.allowed_roots;
+  if (allowedRoots.length > 0 && !allowedRoots.some((allowed) => checkWithinProjectRoot(resolvedRoot, allowed).inside)) {
+    return {
+      ok: false,
+      refusal: toCallToolResult({
+        text: `refused: "${resolvedRoot}" is not inside any root listed in mcp.allowed_roots. A caller-supplied projectRoot is untrusted input, so this deployment pins which roots may be named; add the root to mcp.allowed_roots (or TOKEN_GOAT_MCP_ALLOWED_ROOTS) to permit it.`,
+        code: 1
+      })
+    };
+  }
+  const checked = [];
+  const pins = /* @__PURE__ */ new Map();
+  for (const raw of targets) {
+    const parts = splitCommas ? raw.split(",") : [raw];
+    for (const part of parts) {
+      const file = specFilePart(part);
+      if (file === "") continue;
+      const check = checkWithinProjectRoot(file, resolvedRoot);
+      if (!check.inside) {
+        return {
+          ok: false,
+          refusal: toCallToolResult({
+            text: `refused: "${file}" is outside the project root. The MCP tools are confined to the workspace. Set mcp.confine_reads_to_project_root = false (or TOKEN_GOAT_MCP_CONFINE_READS=0) to allow cross-root reads.`,
+            code: 1
+          })
+        };
+      }
+      const pinIdentity = check.identity ?? ABSENT_PIN;
+      pins.set(pinKey(check.abs), pinIdentity);
+      pins.set(pinKey(check.real), pinIdentity);
+    }
+    checked.push(splitCommas ? parts.join(",") : parts[0]);
+  }
+  return { ok: true, targets: checked, pins };
+}
+function withConfinedRead(pins, fn) {
+  try {
+    return withPinnedReads(pins, fn);
+  } catch (err) {
+    if (err instanceof ConfinementIdentityError) {
+      return toCallToolResult({
+        text: `${err.message} The MCP tools are confined to the workspace. Set mcp.confine_reads_to_project_root = false (or TOKEN_GOAT_MCP_CONFINE_READS=0) to allow cross-root reads.`,
+        code: 1
+      });
+    }
+    throw err;
+  }
+}
+async function createMcpServer() {
+  const [{ McpServer }, { z }] = await Promise.all([import("@modelcontextprotocol/sdk/server/mcp.js"), import("./token-goat-chunk-Q4N6SQWR.mjs")]);
+  const server = new McpServer({ name: "token-goat", version: VERSION });
+  const makeProjectRootField = (verb) => z.string().optional().describe(
+    `absolute path to the workspace root to scope this ${verb} to; defaults to the MCP server process's cwd, which is not always the actual workspace root for MCP clients -- pass this explicitly when it might differ`
+  );
+  const projectRootField = makeProjectRootField("lookup");
+  server.registerTool(
+    "symbol",
+    {
+      description: "Search for a symbol by name across the indexed project.",
+      inputSchema: {
+        name: z.string().describe("symbol name to search for"),
+        limit: z.number().int().positive().max(MCP_MAX_LIMIT).optional().describe("max results (default: 20)"),
+        file: z.string().optional().describe("restrict to one file"),
+        kind: z.string().optional().describe("restrict to one kind (function, class, ...)"),
+        json: z.boolean().optional().describe("output as JSON"),
+        projectRoot: projectRootField
+      }
+    },
+    (args) => {
+      const { name, limit, file, kind, json, projectRoot } = args;
+      const root = resolveToolRoot(projectRoot);
+      let confinedFile = file;
+      let pins = NO_PINS;
+      if (file !== void 0) {
+        const gate = confineTargets([file], root);
+        if (!gate.ok) return gate.refusal;
+        confinedFile = gate.targets[0];
+        pins = gate.pins;
+      }
+      return withConfinedRead(
+        pins,
+        () => toCallToolResult(
+          runSymbol({
+            name,
+            limit: limit ?? 20,
+            ...confinedFile !== void 0 ? { file: confinedFile } : {},
+            ...kind !== void 0 ? { kind } : {},
+            ...json === true ? { json: true } : {},
+            projectRoot: root
+          })
+        )
+      );
+    }
+  );
+  server.registerTool(
+    "read",
+    {
+      description: "Read one symbol's full body, given a spec of the form file::symbol, or a line range file@N-M / file@N, or a bare file path. Pass a comma-separated spec (file::a,b) to fetch several symbols' bodies from one file in a single call.",
+      inputSchema: {
+        spec: z.string().describe("file::symbol, file@N-M, file@N, a bare file path, or comma-separated file::a,b for a merged multi-symbol view"),
+        json: z.boolean().optional().describe("output as JSON"),
+        forceRefresh: z.boolean().optional().describe("reparse file from disk before querying (ignore stale index)"),
+        stats: z.boolean().optional().describe("add per-symbol reference count and doc-coverage flag"),
+        projectRoot: projectRootField
+      }
+    },
+    (args) => {
+      const { spec, json, forceRefresh, stats, projectRoot } = args;
+      const root = resolveToolRoot(projectRoot);
+      const gate = confineTargets([spec], root);
+      if (!gate.ok) return gate.refusal;
+      return withConfinedRead(
+        gate.pins,
+        () => toCallToolResult(
+          runRead({
+            spec: gate.targets[0],
+            ...json === true ? { json: true } : {},
+            ...forceRefresh === true ? { forceRefresh: true } : {},
+            ...stats === true ? { stats: true } : {},
+            projectRoot: root
+          })
+        )
+      );
+    }
+  );
+  server.registerTool(
+    "section",
+    {
+      description: "Read one section from a file, given a spec of the form file::Heading.",
+      inputSchema: {
+        spec: z.string().describe("file::Heading"),
+        json: z.boolean().optional().describe("output as JSON"),
+        projectRoot: projectRootField
+      }
+    },
+    (args) => {
+      const { spec, json, projectRoot } = args;
+      const root = resolveToolRoot(projectRoot);
+      const gate = confineTargets([spec], root);
+      if (!gate.ok) return gate.refusal;
+      return withConfinedRead(
+        gate.pins,
+        () => toCallToolResult(
+          runSection({
+            spec: gate.targets[0],
+            ...json === true ? { json: true } : {},
+            projectRoot: root
+          })
+        )
+      );
+    }
+  );
+  server.registerTool(
+    "skeleton",
+    {
+      description: "List all symbols in a file without bodies (name, kind, line range).",
+      inputSchema: {
+        file: z.string().describe("file path"),
+        json: z.boolean().optional().describe("output as JSON"),
+        minLines: z.number().int().optional().describe("only show symbols at least N lines long"),
+        forceRefresh: z.boolean().optional().describe("reparse file from disk before querying (ignore stale index)"),
+        stats: z.boolean().optional().describe("add per-symbol reference count and doc-coverage flag"),
+        projectRoot: projectRootField
+      }
+    },
+    (args) => {
+      const { file, json, minLines, forceRefresh, stats, projectRoot } = args;
+      const root = resolveToolRoot(projectRoot);
+      const gate = confineTargets([file], root);
+      if (!gate.ok) return gate.refusal;
+      return withConfinedRead(
+        gate.pins,
+        () => toCallToolResult(
+          runSkeleton({
+            file: gate.targets[0],
+            ...json === true ? { json: true } : {},
+            ...minLines !== void 0 ? { minLines } : {},
+            ...forceRefresh === true ? { forceRefresh: true } : {},
+            ...stats === true ? { stats: true } : {},
+            projectRoot: root
+          })
+        )
+      );
+    }
+  );
+  server.registerTool(
+    "outline",
+    {
+      description: "List symbols in a file with line ranges and docstrings.",
+      inputSchema: {
+        file: z.string().describe("file path"),
+        json: z.boolean().optional().describe("output as JSON"),
+        minLines: z.number().int().optional().describe("only show symbols at least N lines long"),
+        forceRefresh: z.boolean().optional().describe("reparse file from disk before querying (ignore stale index)"),
+        stats: z.boolean().optional().describe("add per-symbol reference count and doc-coverage flag"),
+        projectRoot: projectRootField
+      }
+    },
+    (args) => {
+      const { file, json, minLines, forceRefresh, stats, projectRoot } = args;
+      const root = resolveToolRoot(projectRoot);
+      const gate = confineTargets([file], root);
+      if (!gate.ok) return gate.refusal;
+      return withConfinedRead(
+        gate.pins,
+        () => toCallToolResult(
+          runOutline({
+            file: gate.targets[0],
+            ...json === true ? { json: true } : {},
+            ...minLines !== void 0 ? { minLines } : {},
+            ...forceRefresh === true ? { forceRefresh: true } : {},
+            ...stats === true ? { stats: true } : {},
+            projectRoot: root
+          })
+        )
+      );
+    }
+  );
+  server.registerTool(
+    "semantic",
+    {
+      description: "Semantic search over the indexed project (falls back to full-text search when no embedding index is available). Scoped to projectRoot if given, else the MCP server process's own cwd -- which may not be the actual workspace root for a client that launched the server from elsewhere, so pass projectRoot explicitly when in doubt.",
+      inputSchema: {
+        query: z.string().describe("natural-language search query"),
+        limit: z.number().int().positive().max(MCP_MAX_LIMIT).optional().describe("max results (default: 20)"),
+        grep: z.string().optional().describe("filter to hits whose file path matches this regex (literal substring if it does not compile as regex); matched against the path as rendered, same convention as refs --grep"),
+        excludeTests: z.boolean().optional().describe("hide hits whose file is a test file (opt-in; default output is unchanged)"),
+        json: z.boolean().optional().describe("output as JSON"),
+        projectRoot: makeProjectRootField("search")
+      }
+    },
+    async (args) => {
+      const { query, limit, grep, excludeTests, json, projectRoot } = args;
+      const root = resolveToolRoot(projectRoot);
+      return toCallToolResult(
+        await runSemantic(query, {
+          ...limit !== void 0 ? { limit } : {},
+          ...grep !== void 0 ? { grep } : {},
+          ...excludeTests === true ? { excludeTests: true } : {},
+          ...json === true ? { json: true } : {},
+          projectRoot: root
+        })
+      );
+    }
+  );
+  server.registerTool(
+    "index_status",
+    {
+      description: 'Report whether the index for a project can be trusted right now: whether it has ever been indexed at all, current file/symbol counts, dirty-reindex-queue depth, whether the background worker is alive, and whether embeddings are available (semantic silently degrades to full-text search without them). Call this after an unexpectedly empty result from another token-goat tool (symbol/read/semantic/refs/brief/...) to tell apart "no match" from "the index is not ready yet" -- an MCP-only client has no hook layer to warn about this on its own, so an empty tool result and a stale/unindexed project look identical without this check.',
+      inputSchema: {
+        projectRoot: makeProjectRootField("check")
+      }
+    },
+    (args) => {
+      const { projectRoot } = args;
+      const rootDir = resolveToolRoot(projectRoot);
+      const dbPath = globalDbPath();
+      const databaseExists = fs.existsSync(dbPath);
+      let fileCount = 0;
+      let symbolCount = 0;
+      let queryError;
+      if (databaseExists) {
+        try {
+          const counts = getProjectIndexCounts(dbPath, rootDir);
+          fileCount = counts.fileCount;
+          symbolCount = counts.symbolCount;
+        } catch (err) {
+          queryError = extractErrorMessage(err);
+        }
+      }
+      const resolvedDataDir = dataDir();
+      const dirtyQueueDepth = getDirtyPathsFor(resolvedDataDir).length;
+      const workerAlive = isWorkerRunning(resolvedDataDir);
+      let embeddingsAvailable = false;
+      if (databaseExists && queryError === void 0) {
+        try {
+          embeddingsAvailable = embeddingsDepsAvailable(getDb(dbPath));
+        } catch {
+          embeddingsAvailable = false;
+        }
+      }
+      const embeddingsEnabled = loadConfig(rootDir).indexing?.embeddings_enabled ?? true;
+      const status = {
+        projectRoot: rootDir,
+        databaseExists,
+        indexedForProject: fileCount > 0,
+        fileCount,
+        symbolCount,
+        ...queryError !== void 0 ? { queryError } : {},
+        dirtyQueueDepth,
+        workerAlive,
+        embeddingsEnabled,
+        embeddingsAvailable
+      };
+      return toCallToolResult({ text: JSON.stringify(status, null, 2), code: 0 });
+    }
+  );
+  server.registerTool(
+    "refs",
+    {
+      description: "Find references to one or more symbols (spec: file::symbol, symbol, or comma-separated a,b,c / file::a,b for a merged multi-symbol view). For an unambiguous TypeScript symbol, automatically type-resolves candidates via the TypeScript compiler API to drop same-named-different-symbol false positives; falls back to name-based matching when that is not possible.",
+      inputSchema: {
+        spec: z.string().describe("file::symbol, symbol, or comma-separated a,b,c / file::a,b for a merged multi-symbol view"),
+        callers: z.boolean().optional().describe("group references by their enclosing caller symbol"),
+        limit: z.number().int().positive().max(MCP_MAX_LIMIT).optional().describe("max results"),
+        top: z.number().int().positive().max(MCP_MAX_LIMIT).optional().describe(
+          "for a high-fanout symbol, group references by file (count only) and show only the top N files by reference count instead of a per-line dump"
+        ),
+        json: z.boolean().optional().describe("output as JSON"),
+        projectRoot: projectRootField
+      }
+    },
+    (args) => {
+      const { spec, callers, limit, top, json, projectRoot } = args;
+      const root = resolveToolRoot(projectRoot);
+      const gate = confineTargets([spec], root);
+      if (!gate.ok) return gate.refusal;
+      return withConfinedRead(
+        gate.pins,
+        () => toCallToolResultFromExitCode(
+          () => runRefs({
+            spec: gate.targets[0],
+            ...callers === true ? { callers: true } : {},
+            ...json === true ? { json: true } : {},
+            ...limit !== void 0 ? { limit } : {},
+            ...top !== void 0 ? { top } : {},
+            projectRoot: root
+          })
+        )
+      );
+    }
+  );
+  server.registerTool(
+    "brief",
+    {
+      description: "One-shot symbol orientation: signature, location, token count, body, callers, and containing doc section, in a single call (spec: file::symbol; comma-separated file::a,b for a merged multi-symbol view; cross-file a.ts::x,b.ts::y is also supported -- unlike refs, a bare symbol name with no file is not accepted). Prefer this over separate read + refs calls when the goal is to understand a symbol, not just fetch its source: it folds the work of read (body) and refs --callers (call sites) into one result, at a fraction of the combined round-trip cost.",
+      inputSchema: {
+        spec: z.string().describe("file::symbol; comma-separated file::a,b for a merged multi-symbol view; cross-file a.ts::x,b.ts::y is also supported"),
+        limit: z.number().int().positive().max(MCP_MAX_LIMIT).optional().describe("max callers to show (default: 20)"),
+        json: z.boolean().optional().describe("output as JSON"),
+        context: z.number().int().nonnegative().max(MCP_MAX_CONTEXT_LINES).optional().describe("lines of call-site source to show before and after each caller (default 0)"),
+        excludeTests: z.boolean().optional().describe("hide callers whose call site lives in a test file (opt-in; default output is unchanged)"),
+        grep: z.string().optional().describe("only show callers whose enclosing symbol name matches this regex (literal substring if it is not valid regex)"),
+        projectRoot: makeProjectRootField("orient")
+      }
+    },
+    (args) => {
+      const { spec, limit, json, context, excludeTests, grep, projectRoot } = args;
+      const root = resolveToolRoot(projectRoot);
+      const gate = confineTargets([spec], root);
+      if (!gate.ok) return gate.refusal;
+      return withConfinedRead(
+        gate.pins,
+        () => toCallToolResultFromExitCode(
+          () => runBrief({
+            spec: gate.targets[0],
+            ...json === true ? { json: true } : {},
+            ...limit !== void 0 ? { limit } : {},
+            ...context !== void 0 ? { context } : {},
+            ...excludeTests === true ? { excludeTests: true } : {},
+            ...grep !== void 0 ? { grep } : {},
+            projectRoot: root
+          })
+        )
+      );
+    }
+  );
+  server.registerTool(
+    "map",
+    {
+      description: "Project overview: file count, languages, headline symbols, and recently modified files.",
+      inputSchema: {
+        compact: z.boolean().optional().describe("compact, low-token summary"),
+        projectRoot: makeProjectRootField("overview")
+      }
+    },
+    (args) => {
+      const { compact, projectRoot } = args;
+      const map = buildProjectMap(resolveToolRoot(projectRoot), { compact: compact === true });
+      const text = formatProjectMap(map, map.compact);
+      const bytesSaved = mapLookupBytesSaved(map, text);
+      recordStat("map_lookup", bytesSaved, Math.round(bytesSaved / 4));
+      return toCallToolResult({ text, code: 0 });
+    }
+  );
+  server.registerTool(
+    "changed",
+    {
+      description: "List files or symbols changed since a git ref.",
+      inputSchema: {
+        ref: z.string().optional().describe("git ref to compare against (default: HEAD~5)"),
+        symbolMode: z.boolean().optional().describe("list symbols instead of files"),
+        json: z.boolean().optional().describe("output as JSON"),
+        projectRoot: projectRootField
+      }
+    },
+    (args) => {
+      const { ref, symbolMode, json, projectRoot } = args;
+      return toCallToolResultFromExitCode(
+        () => runChanged({
+          ...ref !== void 0 ? { ref } : {},
+          ...symbolMode === true ? { symbolMode: true } : {},
+          ...json === true ? { json: true } : {},
+          projectRoot: resolveToolRoot(projectRoot)
+        })
+      );
+    }
+  );
+  server.registerTool(
+    "grep",
+    {
+      description: "Regex search over files, caching nothing (session-aware grep).",
+      inputSchema: {
+        pattern: z.string().describe("regex pattern to search for"),
+        path: z.array(z.string()).optional().describe("files or directories to search; defaults to this server process's cwd"),
+        maxLines: z.number().int().positive().max(MCP_MAX_OUTPUT_LINES).optional().describe("max matching lines to print"),
+        json: z.boolean().optional().describe("output as JSON"),
+        recursive: z.boolean().optional().describe("descend into subdirectories (default: true)"),
+        context: z.number().int().nonnegative().max(MCP_MAX_CONTEXT_LINES).optional().describe("lines of context to show before and after each match"),
+        // runGrep takes no projectRoot of its own (its `path` array is its scope), so this field only names the root the confinement check is made against -- without it, a search rooted anywhere but the server process's cwd is refused.
+        projectRoot: makeProjectRootField("search")
+      }
+    },
+    (args) => {
+      const { pattern, path: searchPath, maxLines, json, recursive, context, projectRoot } = args;
+      const root = resolveToolRoot(projectRoot);
+      const gate = confineTargets(searchPath === void 0 ? [root] : searchPath, root, false);
+      if (!gate.ok) return gate.refusal;
+      const confinedPath = searchPath === void 0 ? void 0 : [...gate.targets];
+      return withConfinedRead(
+        gate.pins,
+        () => toCallToolResultFromExitCode(
+          () => runGrep({
+            pattern,
+            ...confinedPath !== void 0 && confinedPath.length > 0 ? { path: confinedPath } : {},
+            ...json === true ? { json: true } : {},
+            ...maxLines !== void 0 ? { maxLines } : {},
+            ...recursive === false ? { recursive: false } : {},
+            ...context !== void 0 ? { context } : {},
+            projectRoot: root
+          })
+        )
+      );
+    }
+  );
+  server.registerTool(
+    "imports",
+    {
+      description: "List the modules a file imports.",
+      inputSchema: {
+        file: z.string().describe("file path"),
+        json: z.boolean().optional().describe("output as JSON"),
+        projectRoot: projectRootField
+      }
+    },
+    (args) => {
+      const { file, json, projectRoot } = args;
+      const root = resolveToolRoot(projectRoot);
+      const gate = confineTargets([file], root);
+      if (!gate.ok) return gate.refusal;
+      return withConfinedRead(
+        gate.pins,
+        () => toCallToolResultFromExitCode(
+          () => runImports({ file: gate.targets[0], ...json === true ? { json: true } : {}, projectRoot: root })
+        )
+      );
+    }
+  );
+  server.registerTool(
+    "exports",
+    {
+      description: "List exported (public) symbols in a file.",
+      inputSchema: {
+        file: z.string().describe("file path"),
+        json: z.boolean().optional().describe("output as JSON"),
+        projectRoot: projectRootField
+      }
+    },
+    (args) => {
+      const { file, json, projectRoot } = args;
+      const root = resolveToolRoot(projectRoot);
+      const gate = confineTargets([file], root);
+      if (!gate.ok) return gate.refusal;
+      return withConfinedRead(
+        gate.pins,
+        () => toCallToolResultFromExitCode(
+          () => runExports({ file: gate.targets[0], ...json === true ? { json: true } : {}, projectRoot: root })
+        )
+      );
+    }
+  );
+  server.registerTool(
+    "compress_text",
+    {
+      description: "Compress arbitrary local text, persist it in the bounded local cache, and return an opaque recovery ID plus metadata.",
+      inputSchema: {
+        text: z.string().max(CONTENT_MAX_INPUT_CHARS).describe("text to compress")
+      }
+    },
+    (args) => toCallToolResult({ text: JSON.stringify(compressionPayload(compressText(args.text)), null, 2), code: 0 })
+  );
+  server.registerTool(
+    "retrieve_text",
+    {
+      description: "Retrieve original text from a token-goat compression ID.",
+      inputSchema: {
+        id: z.string().regex(/^tg_[0-9a-f]{16}$/).describe("opaque token-goat content ID")
+      }
+    },
+    (args) => {
+      const text = retrieveText(args.id);
+      return text === null ? toCallToolResult({ text: `no token-goat content for id: ${args.id}`, code: 1 }) : toRawCallToolResult({ text, code: 0 });
+    }
+  );
+  server.registerTool(
+    "handoff_create",
+    {
+      description: "Create a bounded, project-local named compressed handoff for another agent.",
+      inputSchema: {
+        name: z.string().regex(/^[A-Za-z0-9._-]{1,128}$/).describe("handoff name"),
+        text: z.string().max(CONTENT_MAX_INPUT_CHARS).describe("handoff text"),
+        projectRoot: makeProjectRootField("scope")
+      }
+    },
+    (args) => toCallToolResult({
+      text: JSON.stringify(createHandoff(args.name, args.text, resolveToolRoot(args.projectRoot)), null, 2),
+      code: 0
+    })
+  );
+  server.registerTool(
+    "handoff_resolve",
+    {
+      description: "Resolve a project-local handoff compactly or in full. MCP does not intercept built-in file reads.",
+      inputSchema: {
+        name: z.string().regex(/^[A-Za-z0-9._-]{1,128}$/).describe("handoff name"),
+        full: z.boolean().optional().describe("return full text instead of a compact payload"),
+        projectRoot: makeProjectRootField("scope")
+      }
+    },
+    (args) => {
+      const result = resolveHandoff(args.name, {
+        projectRoot: resolveToolRoot(args.projectRoot),
+        ...args.full === true ? { full: true } : {}
+      });
+      return result === null ? toCallToolResult({ text: `no local handoff named "${args.name}" in this project`, code: 1 }) : typeof result === "string" ? toRawCallToolResult({ text: result, code: 0 }) : toCallToolResult({ text: JSON.stringify(compressionPayload(result), null, 2), code: 0 });
+    }
+  );
+  return server;
+}
+export {
+  createMcpServer
+};