@ajdev0/token-shrink 2.0.1 → 2.0.3

package/dist/chunk-RLHEIKPR.js

@@ -0,0 +1,894 @@
+#!/usr/bin/env node
+import {
+  EMPTY_CONFIG,
+  analyze,
+  assembleMany,
+  configPathFor,
+  createWatcher,
+  loadConfig,
+  matchSymbols
+} from "./chunk-FYCLLG7F.js";
+import {
+  languageForFile
+} from "./chunk-7SQ6HMWM.js";
+
+// src/mcp.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import fs3 from "fs";
+import path3 from "path";
+
+// src/detect.ts
+import fs from "fs";
+import path from "path";
+var VCS_MARKER_DIRS = [".git", ".hg", ".svn"];
+var PROJECT_MANIFEST_FILES = [
+  // JavaScript / TypeScript
+  "package.json",
+  "tsconfig.json",
+  // Python
+  "pyproject.toml",
+  "setup.py",
+  "setup.cfg",
+  "requirements.txt",
+  // Go / Rust / Dart / Swift
+  "go.mod",
+  "Cargo.toml",
+  "pubspec.yaml",
+  "Package.swift",
+  // Java / Kotlin
+  "pom.xml",
+  "build.gradle",
+  "build.gradle.kts",
+  "settings.gradle",
+  "settings.gradle.kts",
+  // PHP / Ruby / Elixir
+  "composer.json",
+  "Gemfile",
+  "mix.exs"
+];
+var MANIFEST_FILE_SET = new Set(PROJECT_MANIFEST_FILES);
+var MAX_WALK_DEPTH = 64;
+function detectProjectRoot(fromPath) {
+  const resolved = path.resolve(fromPath);
+  let dir = isDirectory(resolved) ? resolved : path.dirname(resolved);
+  let nearestManifest = null;
+  for (let depth = 0; depth < MAX_WALK_DEPTH; depth++) {
+    const names = readDirNames(dir);
+    if (names) {
+      if (VCS_MARKER_DIRS.some((vcs) => names.has(vcs))) return dir;
+      if (nearestManifest === null && hasManifest(names)) nearestManifest = dir;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return nearestManifest;
+}
+function isDirectory(p) {
+  try {
+    return fs.statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function readDirNames(dir) {
+  try {
+    return new Set(fs.readdirSync(dir));
+  } catch {
+    return null;
+  }
+}
+function hasManifest(names) {
+  for (const name of names) {
+    if (MANIFEST_FILE_SET.has(name)) return true;
+  }
+  return false;
+}
+
+// src/search/index.ts
+function words(text) {
+  const out = /* @__PURE__ */ new Set();
+  for (const part of text.split(/[^A-Za-z0-9_$]+/)) {
+    if (!part) continue;
+    for (const seg of part.split(/(?<=[a-z0-9])(?=[A-Z])/)) {
+      const w = seg.toLowerCase();
+      if (w) out.add(w);
+    }
+    for (const seg of part.split("_")) {
+      const w = seg.toLowerCase();
+      if (w) out.add(w);
+    }
+  }
+  return [...out];
+}
+var SymbolSearch = class {
+  docs = [];
+  byFile = /* @__PURE__ */ new Map();
+  inverted = /* @__PURE__ */ new Map();
+  get size() {
+    return this.docs.length;
+  }
+  /** Replace the docs for one file (or remove when `symbols` is empty). */
+  setFile(filePath, symbols) {
+    this.removeFile(filePath);
+    if (symbols.length === 0) return;
+    const docs = symbols.map((s) => ({ ...s, filePath }));
+    const ids = docs.map((d) => {
+      const id = this.docs.length;
+      this.docs.push(d);
+      for (const w of words(`${d.name}`)) {
+        const list = this.inverted.get(w) ?? [];
+        list.push(id);
+        this.inverted.set(w, list);
+      }
+      return id;
+    });
+    this.byFile.set(filePath, docs);
+    void ids;
+  }
+  removeFile(filePath) {
+    const docs = this.byFile.get(filePath);
+    if (!docs) return;
+    const removed = new Set(docs);
+    this.docs = this.docs.filter((d) => !removed.has(d));
+    this.byFile.delete(filePath);
+    this.rebuildInverted();
+  }
+  /** Bulk-load a whole cache (used at attach time and cold lazy builds). */
+  loadCache(entries) {
+    this.docs = [];
+    this.byFile.clear();
+    for (const [abs, entry] of entries) {
+      if (!entry.symbols || entry.symbols.length === 0) continue;
+      const docs = entry.symbols.map((s) => ({ ...s, filePath: abs }));
+      this.byFile.set(abs, docs);
+      this.docs.push(...docs);
+    }
+    this.rebuildInverted();
+  }
+  /** Ranked symbol hits for `query`. */
+  search(query, opts = {}) {
+    const maxResults = opts.maxResults ?? 10;
+    const q = query.trim().toLowerCase();
+    if (!q) return [];
+    const queryWords = words(q);
+    let candidates;
+    if (queryWords.length > 0) {
+      const ids = /* @__PURE__ */ new Set();
+      for (const w of queryWords) {
+        const post = this.inverted.get(w);
+        if (post) for (const id of post) ids.add(id);
+      }
+      candidates = [...ids].map((id) => this.docs[id]);
+    } else {
+      candidates = this.docs;
+    }
+    if (opts.kind) candidates = candidates.filter((d) => d.kind === opts.kind);
+    const scored = candidates.map((d) => this.score(d, q, queryWords)).filter((s) => s !== null).sort((a, b) => b.score - a.score || a.line - b.line).slice(0, maxResults);
+    return scored.map((s) => ({ ...s, label: this.label(s) }));
+  }
+  score(d, q, queryWords) {
+    const name = d.name.toLowerCase();
+    let score = 0;
+    if (name === q) score += 100;
+    if (name.startsWith(q)) score += 60;
+    if (name.includes(q)) score += 30;
+    if ((d.signature ?? "").toLowerCase().includes(q)) score += 8;
+    for (const w of queryWords) {
+      if (name.includes(w)) score += 4;
+      if ((d.signature ?? "").toLowerCase().includes(w)) score += 1;
+    }
+    if (score <= 0) return null;
+    return { ...d, score };
+  }
+  label(d) {
+    const sig = d.signature && d.signature.length > 0 ? ` \u2014 ${d.signature}` : "";
+    return `${d.filePath}:${d.line}${sig}`;
+  }
+  rebuildInverted() {
+    this.inverted.clear();
+    this.docs.forEach((d, id) => {
+      for (const w of words(d.name)) {
+        const list = this.inverted.get(w) ?? [];
+        list.push(id);
+        this.inverted.set(w, list);
+      }
+    });
+  }
+};
+
+// src/git.ts
+import { spawn } from "child_process";
+import path2 from "path";
+import fs2 from "fs";
+function runGit(root, args) {
+  return new Promise((resolve) => {
+    const child = spawn("git", ["--no-pager", ...args], {
+      cwd: root,
+      env: { ...process.env, LC_ALL: "C" },
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let out = "";
+    let err = "";
+    child.stdout.on("data", (d) => {
+      out += d;
+    });
+    child.stderr.on("data", (d) => {
+      err += d;
+    });
+    child.on("error", (e) => resolve({ ok: false, out: "", err: e.message }));
+    child.on("close", (code) => resolve({ ok: code === 0, out, err }));
+  });
+}
+function parseNames(out) {
+  return out.split("\n").map((l) => l.trim()).filter(Boolean);
+}
+function isFatal(err) {
+  if (!err) return void 0;
+  const e = err.trim();
+  if (/not a git repository|fatal:/i.test(e)) return e;
+  return void 0;
+}
+async function gitChangedFiles(root, opts) {
+  const scope = opts.scope ?? "worktree";
+  const filter = "--diff-filter=ACMRT";
+  let relative = [];
+  if (scope === "staged") {
+    const r = await runGit(root, ["diff", "--cached", "--name-only", filter]);
+    const fatal = isFatal(r.err);
+    if (!r.ok) return { files: [], ...fatal ? { error: fatal } : {} };
+    relative = parseNames(r.out);
+  } else if (scope === "branch") {
+    const base = opts.base ?? "HEAD~1";
+    const head = opts.head ?? "HEAD";
+    const r = await runGit(root, ["diff", "--name-only", `${base}...${head}`, filter]);
+    const fatal = isFatal(r.err);
+    if (!r.ok) return { files: [], ...fatal ? { error: fatal } : {} };
+    relative = parseNames(r.out);
+  } else {
+    const [unstaged, staged] = await Promise.all([
+      runGit(root, ["diff", "--name-only", filter]),
+      runGit(root, ["diff", "--cached", "--name-only", filter])
+    ]);
+    const fatal = isFatal(unstaged.err) ?? isFatal(staged.err);
+    if (!unstaged.ok && !staged.ok) {
+      return { files: [], ...fatal ? { error: fatal } : {} };
+    }
+    const merged = /* @__PURE__ */ new Set([...parseNames(unstaged.out), ...parseNames(staged.out)]);
+    if (opts.includeUntracked) {
+      const ut = await runGit(root, ["ls-files", "--others", "--exclude-standard"]);
+      for (const f of parseNames(ut.out)) merged.add(f);
+    }
+    relative = [...merged];
+  }
+  const files = relative.map((rel) => path2.resolve(root, rel)).filter((abs) => {
+    try {
+      return fs2.statSync(abs).isFile();
+    } catch {
+      return false;
+    }
+  });
+  return { files };
+}
+
+// src/mcp.ts
+var RULE_TARGET_PATH = {
+  cursor: ".cursor/rules/token-shrink.mdc",
+  claude: ".claude/rules/token-shrink.md",
+  cline: ".clinerules/token-shrink.md"
+};
+var RULE_VERSION = 3;
+var RULE_VERSION_MARKER = `# token-shrink rule v${RULE_VERSION}`;
+var WORKFLOW_GUIDANCE = [
+  "When a pruned skeleton is not enough to write or change code correctly, expand the exact",
+  "definition with expand_symbol.",
+  "",
+  "Call search_symbol_signatures automatically for any identifier you reference that the",
+  "context does not already define, so you always work from exact signatures.",
+  "",
+  "Before multi-file edits, reviews, or work on code with uncommitted or staged changes, call",
+  "git_diff_context and use its impact payload (changed files and their callers) as context.",
+  "",
+  "Pass activeFiles to get_compressed_code_context when a task spans several files, and",
+  "maxTokens whenever the payload must fit a token budget."
+].join("\n");
+var LIGHT_GUIDANCE = [
+  "Use expand_symbol when a pruned body is not enough, git_diff_context for changed or",
+  "multi-file work, and search_symbol_signatures to locate definitions repo-wide."
+].join("\n");
+var AUTO_RULE_SENTINEL = "# auto-generated by token-shrink";
+var CURSOR_RULE_PATH = RULE_TARGET_PATH.cursor;
+var AUTO_RULE_PATH = CURSOR_RULE_PATH;
+var CLAUDE_RULE_PATH = RULE_TARGET_PATH.claude;
+var CLAUDE_RULE_SENTINEL = "# auto-generated by token-shrink (claude)";
+var CLINE_RULE_PATH = RULE_TARGET_PATH.cline;
+var CLINE_RULE_SENTINEL = "# auto-generated by token-shrink (cline)";
+var ruleTargets = {
+  cursor: {
+    relPath: CURSOR_RULE_PATH,
+    sentinel: AUTO_RULE_SENTINEL,
+    body: `---
+description: Compress dependency context with token-shrink on every task
+globs: **/*.{ts,tsx,js,jsx,py,go,rs,dart,swift,java,kt,c,cpp,h,hpp,php}
+alwaysApply: true
+---
+Before working on a file in this repo, call the \`get_compressed_code_context\` MCP tool with
+that file's path, and use the returned Ring 0 + Ring 1 payload as the context for that file
+and its direct imports.
+
+${WORKFLOW_GUIDANCE}
+
+${RULE_VERSION_MARKER}
+${AUTO_RULE_SENTINEL}
+`
+  },
+  claude: {
+    relPath: CLAUDE_RULE_PATH,
+    sentinel: CLAUDE_RULE_SENTINEL,
+    body: `---
+description: Compress dependency context with token-shrink on every task
+paths: ["**/*.{ts,tsx,js,jsx,py,go,rs,dart,swift,java,kt,c,cpp,h,hpp,php}"]
+---
+Before working on a file in this repo, call the \`get_compressed_code_context\` MCP tool with
+that file's path, and use the returned Ring 0 + Ring 1 payload as the context for that file
+and its direct imports.
+
+${WORKFLOW_GUIDANCE}
+
+${RULE_VERSION_MARKER}
+${CLAUDE_RULE_SENTINEL}
+`
+  },
+  cline: {
+    relPath: CLINE_RULE_PATH,
+    sentinel: CLINE_RULE_SENTINEL,
+    // No frontmatter -> always-on rule (Cline treats unconditional .clinerules/*.md
+    // files as universal rules, applied to every task regardless of active file).
+    body: `# token-shrink
+
+Before working on a file in this repo, call the \`get_compressed_code_context\` MCP tool with
+that file's path, and use the returned Ring 0 + Ring 1 payload as the context for that file
+and its direct imports.
+
+${WORKFLOW_GUIDANCE}
+
+${RULE_VERSION_MARKER}
+${CLINE_RULE_SENTINEL}
+`
+  }
+};
+function createAutoRule(root, target) {
+  const spec = ruleTargets[target];
+  const rulePath = path3.join(root, spec.relPath);
+  const autoWorkflow = loadConfig(root).autoWorkflow !== false;
+  const body = autoWorkflow ? spec.body : spec.body.replace(WORKFLOW_GUIDANCE, LIGHT_GUIDANCE);
+  try {
+    if (fs3.existsSync(rulePath)) {
+      const existing = fs3.readFileSync(rulePath, "utf8");
+      if (existing.includes(spec.sentinel)) {
+        if (existing.includes(RULE_VERSION_MARKER)) {
+          return { created: false, skipped: "exists", filePath: rulePath };
+        }
+        fs3.writeFileSync(rulePath, body, "utf8");
+        return { created: true, skipped: "none", filePath: rulePath };
+      }
+      return { created: false, skipped: "user", filePath: rulePath };
+    }
+    fs3.mkdirSync(path3.dirname(rulePath), { recursive: true });
+    fs3.writeFileSync(rulePath, body, "utf8");
+    return { created: true, skipped: "none", filePath: rulePath };
+  } catch (err) {
+    process.stderr.write(
+      `[token-shrink] Failed to write rule for "${target}": ${err.message}
+`
+    );
+    return { created: false, skipped: "none", filePath: rulePath };
+  }
+}
+function createCursorRule(root) {
+  return createAutoRule(root, "cursor");
+}
+function resolveTargets(ruleTarget) {
+  if (!ruleTarget) return ["cursor", "claude", "cline"];
+  const list = Array.isArray(ruleTarget) ? ruleTarget : [ruleTarget];
+  if (list.includes("all")) return ["cursor", "claude", "cline"];
+  return list;
+}
+function isWithin(parent, child) {
+  const rel = path3.relative(path3.resolve(parent), path3.resolve(child));
+  return rel === "" || !rel.startsWith("..") && !path3.isAbsolute(rel);
+}
+function resolveActiveFiles(single, many) {
+  if (many && many.length > 0) {
+    if (single) {
+      throw new Error("Pass either `activeFilePath` or `activeFiles`, not both.");
+    }
+    return many;
+  }
+  if (single) return [single];
+  throw new Error("`activeFilePath` or `activeFiles` is required");
+}
+async function startMcpServer(opts = {}) {
+  const log = (msg) => {
+    if (!opts.silent) process.stderr.write(`[token-shrink] ${msg}
+`);
+  };
+  const textReply = (text) => ({
+    content: [{ type: "text", text }]
+  });
+  const explicitRoot = opts.root?.trim() || process.env.ROOT?.trim() || "";
+  const autoMode = explicitRoot === "";
+  let root = "";
+  let watcher = null;
+  let searchIndex = null;
+  let lifecycle = Promise.resolve();
+  let config = { ...EMPTY_CONFIG };
+  let configFsw = null;
+  let configReloadTimer = null;
+  const stopConfigWatch = () => {
+    if (configReloadTimer) {
+      clearTimeout(configReloadTimer);
+      configReloadTimer = null;
+    }
+    if (configFsw) {
+      configFsw.close();
+      configFsw = null;
+    }
+  };
+  const reloadForRoot = async (r) => {
+    const next = loadConfig(r, (m) => log(m));
+    const changed = JSON.stringify(next) !== JSON.stringify(config);
+    config = next;
+    if (!changed || !watcher || root !== r) return;
+    log(".tokenshrinkrc.json changed \u2014 re-indexing with the new rules.");
+    stopConfigWatch();
+    const old = watcher;
+    watcher = null;
+    root = "";
+    await old.close().catch(() => {
+    });
+    await attachWatcher(r, false);
+  };
+  const startConfigWatch = (r) => {
+    stopConfigWatch();
+    const cfgPath = configPathFor(r);
+    if (!fs3.existsSync(cfgPath)) return;
+    try {
+      configFsw = fs3.watch(cfgPath, () => {
+        if (configReloadTimer) clearTimeout(configReloadTimer);
+        configReloadTimer = setTimeout(() => {
+          void enqueue(() => reloadForRoot(r));
+        }, 200);
+      });
+    } catch {
+    }
+  };
+  const writeRules = (r) => {
+    if (opts.createRule === false) return;
+    for (const target of resolveTargets(opts.ruleTarget)) {
+      const res = createAutoRule(r, target);
+      if (res.created) {
+        log(`Wrote ${target} rule to ${res.filePath}`);
+      } else if (res.skipped === "user") {
+        log(`${target} rule exists (user-authored); leaving it untouched.`);
+      }
+    }
+  };
+  const attachWatcher = (r, waitForIndex) => {
+    stopConfigWatch();
+    config = loadConfig(r, (m) => log(m));
+    const search = new SymbolSearch();
+    const w = createWatcher({
+      root: r,
+      ignored: opts.ignored,
+      config,
+      onIndexed: (abs, entry) => {
+        if (entry.symbols && entry.symbols.length > 0) search.setFile(abs, entry.symbols);
+        else search.removeFile(abs);
+      },
+      onRemoved: (abs) => search.removeFile(abs)
+    });
+    searchIndex = search;
+    root = r;
+    watcher = w;
+    writeRules(r);
+    log(`Indexing ${r} in the background\u2026`);
+    const indexed = w.indexAll().then((n) => log(`Indexed ${n} files.`)).catch((err) => log(`Indexing ${r} failed: ${err?.message ?? err}`));
+    startConfigWatch(r);
+    return waitForIndex ? indexed : Promise.resolve();
+  };
+  const enqueue = (fn) => {
+    const run = lifecycle.then(fn);
+    lifecycle = run.then(
+      () => {
+      },
+      () => {
+      }
+    );
+    return run;
+  };
+  if (explicitRoot) {
+    void enqueue(() => attachWatcher(path3.resolve(explicitRoot), false));
+  } else {
+    const fromCwd = detectProjectRoot(process.cwd());
+    if (fromCwd) {
+      log(`Auto-detected project root ${fromCwd} (from cwd). Pass --root to pin it.`);
+      void enqueue(() => attachWatcher(fromCwd, false));
+    } else {
+      log(
+        "No --root and no project markers around the current directory \u2014 will auto-detect the project from the first tool call."
+      );
+    }
+  }
+  const ensureReadyFor = (activeFilePath) => enqueue(async () => {
+    const abs = path3.resolve(activeFilePath);
+    if (watcher && root) {
+      if (!autoMode || isWithin(root, abs)) return;
+      const next = detectProjectRoot(abs);
+      if (!next || next === root) return;
+      log(`Active file is in a different project (${next}); re-indexing (was ${root}).`);
+      await watcher.close().catch(() => {
+      });
+      watcher = null;
+      root = "";
+    }
+    if (root) return;
+    const detected = detectProjectRoot(abs);
+    const target = detected ?? process.cwd();
+    if (detected) {
+      log(`Auto-detected project root ${target} from ${abs}.`);
+    } else {
+      log(`No project markers around ${abs}; falling back to ${target}.`);
+    }
+    await attachWatcher(target, true);
+  });
+  const server = new McpServer(
+    { name: "token-shrink", version: "2.0.0" },
+    { capabilities: { tools: {} } }
+  );
+  server.registerTool(
+    "get_compressed_code_context",
+    {
+      title: "Get Compressed Code Context",
+      description: "Returns a compressed, framework-aware AST context payload for one or more files: each active file\u2019s full source (Ring 0) plus pruned skeletons of their direct imports (Ring 1). Implementation bodies are removed but type signatures, interfaces, and module exports are preserved for ~80-90% token reduction. Use `activeFiles` to pin multiple files as Ring 0 and `maxTokens` to cap the payload with a relevance-ranked Ring 1.",
+      inputSchema: {
+        activeFilePath: z.string().optional().describe("Path to the file the agent is working on (or use `activeFiles`)"),
+        activeFiles: z.array(z.string()).optional().describe("Multiple files to keep as Ring 0 (full text); mutually exclusive with `activeFilePath`"),
+        maxSkeletons: z.number().int().min(1).max(200).optional().describe("Cap on number of dependency skeletons to include"),
+        maxTokens: z.number().int().positive().optional().describe("Hard token budget for the whole payload; Ring 1 is relevance-ranked and packed to fit"),
+        includeStats: z.boolean().optional().describe("Append approximate token-count stats")
+      }
+    },
+    async ({ activeFilePath, activeFiles, maxSkeletons, maxTokens, includeStats }) => {
+      const paths = resolveActiveFiles(activeFilePath, activeFiles);
+      for (const p of paths) await ensureReadyFor(p);
+      if (!watcher) {
+        throw new Error("token-shrink watcher failed to start");
+      }
+      const result = assembleMany(paths, watcher.cache.entries, {
+        maxSkeletons,
+        maxTokens,
+        includeStats
+      });
+      const ts = result.tokenStats;
+      const budgetNote = ts.budget !== void 0 ? ` budget=${ts.budget} trimmed=${ts.trimmed}` : "";
+      return {
+        content: [
+          {
+            type: "text",
+            text: result.markdown
+          },
+          {
+            type: "text",
+            text: `[stats] files=${result.activeFilePaths.length} dependencies=${result.included.length} unresolved=${result.unresolved.length} tokens=${ts.totalTokens}${budgetNote}`
+          }
+        ]
+      };
+    }
+  );
+  server.registerTool(
+    "expand_symbol",
+    {
+      title: "Expand Symbol",
+      description: "Returns the full, un-pruned source of a named definition (function, method, class, interface, enum, arrow/const function, \u2026) from one file. Use it when a Ring-1 skeleton is not enough \u2014 e.g. you need the exact algorithm inside a pruned body before writing or changing code.",
+      inputSchema: {
+        filePath: z.string().describe("Path to the file containing the symbol"),
+        symbolName: z.string().describe("Name of the definition to expand (exact name preferred; falls back to case-insensitive/substring)"),
+        maxMatches: z.number().int().min(1).max(20).optional().describe("Maximum matching definitions to return (default 5)")
+      }
+    },
+    async ({ filePath, symbolName, maxMatches }) => {
+      await ensureReadyFor(filePath);
+      const abs = path3.resolve(filePath);
+      let source;
+      try {
+        source = fs3.readFileSync(abs, "utf8");
+      } catch {
+        return textReply(`File not found or unreadable: ${filePath}`);
+      }
+      const spec = languageForFile(abs);
+      if (!spec) {
+        return textReply(`No token-shrink grammar for file type: ${filePath}`);
+      }
+      const { symbols } = await analyze(abs, source, { skipPrune: true });
+      if (symbols.length === 0) {
+        return textReply(
+          `No parseable definitions found in ${filePath} \u2014 the grammar may be unavailable (first run offline) or the language exposes no name-carrying definitions yet.`
+        );
+      }
+      const matches = matchSymbols(symbols, symbolName).slice(0, maxMatches ?? 5);
+      if (matches.length === 0) {
+        const names = [...new Set(symbols.map((s) => s.name))].slice(0, 12).join(", ");
+        return textReply(
+          `No symbol named "${symbolName}" in ${filePath}.` + (names ? ` Other definitions there: ${names}.` : "")
+        );
+      }
+      const fence = path3.extname(abs).replace(/^\./, "") || "text";
+      const parts = matches.map((m) => {
+        const body = source.slice(m.start, m.end).trim();
+        return `### ${m.name} (${m.kind}) \u2014 ${abs}:${m.line}
+
+\`\`\`` + fence + "\n" + body + "\n```\n";
+      });
+      const disambig = matches.length > 1 ? `
+_Multiple definitions matched (${matches.length}); each is shown above._` : "";
+      return textReply(parts.join("\n") + disambig);
+    }
+  );
+  server.registerTool(
+    "git_diff_context",
+    {
+      title: "Git Diff Context",
+      description: 'Builds an impact-analysis payload from git changes: every changed file is kept as Ring 0 (full code), their imports AND the files that import them (file-level callers) are attached as pruned Ring-1 skeletons. Use for PR reviews, regression fixes and multi-file tasks where no single "active file" exists.',
+      inputSchema: {
+        scope: z.enum(["worktree", "staged", "branch"]).optional().describe("Diff scope: 'worktree' (default, staged+unstaged), 'staged', or 'branch' (base...head)"),
+        base: z.string().optional().describe("Base ref for scope=branch (default HEAD~1)"),
+        head: z.string().optional().describe("Head ref for scope=branch (default HEAD)"),
+        includeUntracked: z.boolean().optional().describe("Include untracked files (worktree scope only)"),
+        maxFiles: z.number().int().min(1).max(200).optional().describe("Maximum changed files to include (default 30)"),
+        maxImporters: z.number().int().min(0).max(100).optional().describe("Maximum importer skeletons to append (default 20)"),
+        maxSkeletons: z.number().int().min(1).max(200).optional().describe("Cap on dependency skeletons per payload"),
+        maxTokens: z.number().int().positive().optional().describe("Hard token budget for the whole payload"),
+        includeStats: z.boolean().optional().describe("Append approximate token-count stats")
+      }
+    },
+    async ({
+      scope,
+      base,
+      head,
+      includeUntracked,
+      maxFiles,
+      maxImporters,
+      maxSkeletons,
+      maxTokens,
+      includeStats
+    }) => {
+      await ensureReadyFor(process.cwd());
+      if (!watcher || !root) {
+        throw new Error("token-shrink watcher failed to start");
+      }
+      const repoRoot = root;
+      const changedResult = await gitChangedFiles(repoRoot, {
+        scope: scope ?? "worktree",
+        base,
+        head,
+        includeUntracked
+      });
+      if (changedResult.error) {
+        return textReply(`git error: ${changedResult.error}`);
+      }
+      if (changedResult.files.length === 0) {
+        return textReply("No changed files (clean worktree, or empty diff for the requested scope).");
+      }
+      const fileCap = maxFiles ?? 30;
+      const changed = changedResult.files.slice(0, fileCap);
+      const filesTruncated = changedResult.files.length > changed.length;
+      for (const abs of changed) {
+        if (!watcher.cache.entries.has(abs)) {
+          try {
+            await watcher.index(abs);
+          } catch {
+          }
+        }
+      }
+      const assembled = assembleMany(changed, watcher.cache.entries, {
+        maxSkeletons,
+        maxTokens,
+        includeStats
+      });
+      const changedSet = new Set(changed);
+      const importerOf = /* @__PURE__ */ new Map();
+      for (const [fileAbs, entry] of watcher.cache.entries) {
+        for (const imp of entry.imports) {
+          if (!changedSet.has(imp)) continue;
+          const list = importerOf.get(imp) ?? [];
+          list.push(fileAbs);
+          importerOf.set(imp, list);
+        }
+      }
+      const importerList = [...new Set([...importerOf.values()].flat())].filter(
+        (f) => !changedSet.has(f)
+      );
+      const importerCap = maxImporters ?? 20;
+      const importers = importerList.slice(0, importerCap);
+      const importersTruncated = importerList.length > importers.length;
+      const relLabel = (abs) => {
+        const rel = path3.relative(repoRoot, abs);
+        return rel && !rel.startsWith("..") ? rel : abs;
+      };
+      const fence = (abs) => path3.extname(abs).replace(/^\./, "") || "text";
+      const parts = [];
+      parts.push(
+        `# Git Impact Context (${changed.length} changed file${changed.length === 1 ? "" : "s"})`,
+        ""
+      );
+      parts.push(`- changed files: ${changed.map(relLabel).join(", ")}`);
+      if (importers.length > 0) {
+        parts.push(`- importing files (callers): ${importers.map(relLabel).join(", ")}`);
+      }
+      parts.push("", "---", "");
+      parts.push("## Changed files \u2014 full code", "");
+      for (const abs of changed) {
+        parts.push(`### \`${relLabel(abs)}\``, "");
+        let source = "";
+        try {
+          source = fs3.readFileSync(abs, "utf8");
+        } catch {
+        }
+        parts.push(`\`\`\`${fence(abs)}`, source.trim() || "(unreadable file)", "```", "");
+      }
+      parts.push(`## Ring 1 \u2014 Pruned dependencies (${assembled.included.length})`, "");
+      parts.push("", "Implementation bodies removed; type signatures, interfaces and exports retained.", "");
+      if (assembled.included.length === 0) {
+        parts.push("_No local dependency skeletons available._", "");
+      }
+      for (const inc of assembled.included) {
+        const entry = watcher.cache.entries.get(inc.filePath);
+        const label = relLabel(inc.filePath);
+        parts.push(`### \`${label}\``, "");
+        if (entry) {
+          parts.push(`\`\`\`${fence(inc.filePath)}`, entry.skeleton.trim(), "```", "");
+        } else {
+          parts.push("_Unindexed file._", "");
+        }
+        parts.push("");
+      }
+      if (assembled.tokenStats.budget !== void 0 && assembled.tokenStats.trimmed > 0) {
+        parts.push(
+          `_Note: token budget of ${assembled.tokenStats.budget} excluded ${assembled.tokenStats.trimmed} lower-priority dependencies._`,
+          ""
+        );
+      }
+      if (importers.length > 0) {
+        parts.push(`## Ring 2 \u2014 Files importing the diff (${importers.length})`, "");
+        parts.push("", "Pruned skeletons of modules that call into the changed files.", "");
+        for (const abs of importers) {
+          const entry = watcher.cache.entries.get(abs);
+          parts.push(`### \`${relLabel(abs)}\``, "");
+          if (entry) {
+            parts.push(`\`\`\`${fence(abs)}`, entry.skeleton.trim(), "```", "");
+          } else {
+            parts.push("_Unindexed file._", "");
+          }
+          parts.push("");
+        }
+        if (importersTruncated) {
+          parts.push(
+            `_\u2026and ${importerList.length - importers.length} more importing files (raise maxImporters)._`,
+            ""
+          );
+        }
+      }
+      if (filesTruncated) {
+        parts.push(
+          `_Note: capped to ${fileCap} changed files (${changedResult.files.length} total); raise maxFiles to include more._`,
+          ""
+        );
+      }
+      if (assembled.unresolved.length > 0) {
+        parts.push("## Unresolved imports", "");
+        for (const u of assembled.unresolved) parts.push(`- \`${u}\``);
+        parts.push("");
+      }
+      const ts = assembled.tokenStats;
+      const budgetNote = ts.budget !== void 0 ? ` budget=${ts.budget} trimmed=${ts.trimmed}` : "";
+      const stats = `[git-stats] files=${changed.length} ring1=${assembled.included.length} importers=${importers.length} unresolved=${assembled.unresolved.length} tokens=${ts.totalTokens}${budgetNote}`;
+      return {
+        content: [
+          { type: "text", text: parts.join("\n") },
+          { type: "text", text: stats }
+        ]
+      };
+    }
+  );
+  server.registerTool(
+    "search_symbol_signatures",
+    {
+      title: "Search Symbol Signatures",
+      description: "Fast, repo-wide lookup of named definitions (functions, methods, classes, interfaces, enums, \u2026). Returns compact `file:line \u2014 signature` lines instead of raw search hits. Use it to discover where a symbol lives and what its exact signature is before reading or editing code.",
+      inputSchema: {
+        query: z.string().describe("Search text (matched against symbol names; falls back to signatures)"),
+        maxResults: z.number().int().min(1).max(100).optional().describe("Maximum results to return (default 10)"),
+        kind: z.enum(["function", "method", "arrow", "class", "interface", "enum", "type", "other"]).optional().describe("Only return definitions of this kind")
+      }
+    },
+    async ({ query, maxResults, kind }) => {
+      await ensureReadyFor(process.cwd());
+      if (!searchIndex) {
+        throw new Error("token-shrink symbol index failed to start");
+      }
+      if (searchIndex.size === 0 && watcher && watcher.cache.entries.size > 0) {
+        searchIndex.loadCache(watcher.cache.entries);
+      }
+      const hits = searchIndex.search(query, {
+        maxResults: maxResults ?? 10,
+        kind
+      });
+      if (hits.length === 0) {
+        return textReply(`No symbols match "${query}". Try a different name or kind.`);
+      }
+      const lines = hits.map((h) => `- \`${h.label}\``);
+      return textReply(
+        `${lines.join("\n")}
+
+_Found ${hits.length} symbol${hits.length === 1 ? "" : "s"} matching "${query}"._`
+      );
+    }
+  );
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  log("MCP server connected.");
+  return server;
+}
+var argv1 = process.argv[1] ? path3.basename(process.argv[1]) : "";
+var argv1Real = "";
+try {
+  argv1Real = process.argv[1] ? path3.basename(fs3.realpathSync(process.argv[1])) : "";
+} catch {
+}
+var invokedAsMcp = argv1 === "mcp.js" || argv1 === "mcp.mjs" || argv1 === "mcp.cjs" || argv1 === "mcp.ts" || argv1Real === "mcp.js" || argv1Real === "mcp.mjs" || argv1Real === "mcp.cjs" || argv1Real === "mcp.ts";
+if (invokedAsMcp) {
+  const rootArg = (() => {
+    const i = process.argv.indexOf("--root");
+    if (i !== -1 && process.argv[i + 1]) return process.argv[i + 1];
+    const eq = process.argv.find((a) => a.startsWith("--root="));
+    if (eq) return eq.slice("--root=".length);
+    return void 0;
+  })();
+  const createRule = !(process.env.TOKEN_SHRINK_CREATE_RULE === "0" || process.env.TOKEN_SHRINK_CREATE_RULE === "false" || process.env.CONTEXT_SHRINK_CREATE_RULE === "0" || process.env.CONTEXT_SHRINK_CREATE_RULE === "false" || process.argv.includes("--no-create-rule") || (() => {
+    const f = process.argv.find((a) => a.startsWith("--create-rule="));
+    return f ? f.slice("--create-rule=".length) === "false" : false;
+  })());
+  const rawTargets = process.argv.filter((a) => a.startsWith("--rule-target=")).flatMap((a) => a.slice("--rule-target=".length).split(","));
+  const ruleTarget = rawTargets.length > 0 && !rawTargets.includes("all") ? [...new Set(rawTargets)].filter(
+    (v) => v === "cursor" || v === "claude" || v === "cline"
+  ) : void 0;
+  void startMcpServer({ root: rootArg, createRule, ruleTarget }).catch((err) => {
+    process.stderr.write(`[token-shrink] MCP server error: ${err.message}
+`);
+    process.exitCode = 1;
+  });
+}
+
+export {
+  VCS_MARKER_DIRS,
+  PROJECT_MANIFEST_FILES,
+  detectProjectRoot,
+  SymbolSearch,
+  RULE_TARGET_PATH,
+  RULE_VERSION,
+  RULE_VERSION_MARKER,
+  AUTO_RULE_SENTINEL,
+  CURSOR_RULE_PATH,
+  AUTO_RULE_PATH,
+  CLAUDE_RULE_PATH,
+  CLAUDE_RULE_SENTINEL,
+  CLINE_RULE_PATH,
+  CLINE_RULE_SENTINEL,
+  createAutoRule,
+  createCursorRule,
+  startMcpServer
+};
+//# sourceMappingURL=chunk-RLHEIKPR.js.map