@ajdev0/token-shrink 2.0.0

package/dist/index.cjs

@@ -0,0 +1,988 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/parser/registry.ts
+var registry_exports = {};
+__export(registry_exports, {
+  allExtensions: () => allExtensions,
+  languageForFile: () => languageForFile,
+  registry: () => registry,
+  supportedLanguageIds: () => supportedLanguageIds
+});
+function languageForFile(filePath) {
+  const langId = extensionIndex.get(import_node_path.default.extname(filePath).toLowerCase());
+  if (!langId) return null;
+  return registry[langId];
+}
+var import_node_path, BLOCK, SWIFT_BLOCK, GO_BLOCK, RUST_BLOCK, PY_BLOCK, C_BLOCK, JAVA_BLOCK, PHP_BLOCK, KOTLIN_BLOCK, DART_BLOCK, DIRECTIVE_KEEP, registry, extensionIndex, supportedLanguageIds, allExtensions;
+var init_registry = __esm({
+  "src/parser/registry.ts"() {
+    "use strict";
+    import_node_path = __toESM(require("path"), 1);
+    BLOCK = { query: "(statement_block) @block", replacement: { token: "/* ... */" } };
+    SWIFT_BLOCK = { query: "(statements) @block", replacement: { token: "/* ... */" } };
+    GO_BLOCK = { query: "(block) @block", replacement: { token: "/* ... */" } };
+    RUST_BLOCK = { query: "(block) @block", replacement: { token: "/* ... */" } };
+    PY_BLOCK = { query: "(block) @block", replacement: { token: "pass" } };
+    C_BLOCK = { query: "(compound_statement) @block", replacement: { token: "/* ... */" } };
+    JAVA_BLOCK = {
+      query: "(block) @block",
+      replacement: { token: "/* ... */" }
+    };
+    PHP_BLOCK = {
+      query: "(compound_statement) @block",
+      replacement: { token: "/* ... */" }
+    };
+    KOTLIN_BLOCK = { query: "(block) @block", replacement: { token: "/* ... */" } };
+    DART_BLOCK = { query: "(block) @block", replacement: { token: "/* ... */" } };
+    DIRECTIVE_KEEP = {
+      token: "/* ... */",
+      keepIf: /^\s*'use (client|server)'/
+    };
+    registry = {
+      typescript: {
+        name: "TypeScript",
+        wasm: "tree-sitter-typescript.wasm",
+        url: "https://github.com/tree-sitter/tree-sitter-typescript/releases/latest/download/tree-sitter-typescript.wasm",
+        extensions: [".ts", ".cts", ".mts"],
+        rules: [BLOCK]
+      },
+      javascript: {
+        name: "JavaScript",
+        wasm: "tree-sitter-javascript.wasm",
+        url: "https://github.com/tree-sitter/tree-sitter-javascript/releases/latest/download/tree-sitter-javascript.wasm",
+        extensions: [".js", ".cjs", ".mjs"],
+        rules: [BLOCK]
+      },
+      tsx: {
+        name: "React / Next.js (TSX)",
+        wasm: "tree-sitter-tsx.wasm",
+        url: "https://github.com/tree-sitter/tree-sitter-typescript/releases/latest/download/tree-sitter-tsx.wasm",
+        extensions: [".tsx"],
+        rules: [{ query: "(statement_block) @block", replacement: DIRECTIVE_KEEP }]
+      },
+      jsx: {
+        name: "React (JSX)",
+        wasm: "tree-sitter-javascript.wasm",
+        url: "https://github.com/tree-sitter/tree-sitter-javascript/releases/latest/download/tree-sitter-javascript.wasm",
+        extensions: [".jsx"],
+        rules: [{ query: "(statement_block) @block", replacement: DIRECTIVE_KEEP }]
+      },
+      python: {
+        name: "Python",
+        wasm: "tree-sitter-python.wasm",
+        url: "https://github.com/tree-sitter/tree-sitter-python/releases/latest/download/tree-sitter-python.wasm",
+        extensions: [".py", ".pyi"],
+        rules: [PY_BLOCK]
+      },
+      dart: {
+        name: "Dart / Flutter",
+        wasm: "tree-sitter-dart.wasm",
+        url: "https://github.com/UserNobody14/tree-sitter-dart.wasm/releases/latest/download/tree-sitter-dart.wasm",
+        extensions: [".dart"],
+        rules: [DART_BLOCK]
+      },
+      swift: {
+        name: "Swift / SwiftUI",
+        wasm: "tree-sitter-swift.wasm",
+        url: "https://github.com/alex-pinkus/tree-sitter-swift/releases/latest/download/tree-sitter-swift.wasm",
+        extensions: [".swift"],
+        rules: [SWIFT_BLOCK]
+      },
+      go: {
+        name: "Go",
+        wasm: "tree-sitter-go.wasm",
+        url: "https://github.com/tree-sitter/tree-sitter-go/releases/latest/download/tree-sitter-go.wasm",
+        extensions: [".go"],
+        rules: [GO_BLOCK]
+      },
+      rust: {
+        name: "Rust",
+        wasm: "tree-sitter-rust.wasm",
+        url: "https://github.com/tree-sitter/tree-sitter-rust/releases/latest/download/tree-sitter-rust.wasm",
+        extensions: [".rs"],
+        rules: [RUST_BLOCK]
+      },
+      java: {
+        name: "Java",
+        wasm: "tree-sitter-java.wasm",
+        url: "https://github.com/tree-sitter/tree-sitter-java/releases/latest/download/tree-sitter-java.wasm",
+        extensions: [".java"],
+        rules: [JAVA_BLOCK]
+      },
+      kotlin: {
+        name: "Kotlin",
+        wasm: "tree-sitter-kotlin.wasm",
+        url: "https://github.com/fwcd/tree-sitter-kotlin/releases/latest/download/tree-sitter-kotlin.wasm",
+        extensions: [".kt", ".kts"],
+        rules: [KOTLIN_BLOCK]
+      },
+      c: {
+        name: "C",
+        wasm: "tree-sitter-c.wasm",
+        url: "https://github.com/tree-sitter/tree-sitter-c/releases/latest/download/tree-sitter-c.wasm",
+        extensions: [".c", ".h"],
+        rules: [C_BLOCK]
+      },
+      cpp: {
+        name: "C++",
+        wasm: "tree-sitter-cpp.wasm",
+        url: "https://github.com/tree-sitter/tree-sitter-cpp/releases/latest/download/tree-sitter-cpp.wasm",
+        extensions: [".cc", ".cpp", ".cxx", ".hpp", ".hh", ".hxx"],
+        rules: [C_BLOCK]
+      },
+      php: {
+        name: "PHP",
+        wasm: "tree-sitter-php.wasm",
+        url: "https://github.com/tree-sitter/tree-sitter-php/releases/latest/download/tree-sitter-php.wasm",
+        extensions: [".php"],
+        rules: [PHP_BLOCK]
+      }
+    };
+    extensionIndex = /* @__PURE__ */ new Map();
+    for (const [id, spec] of Object.entries(registry)) {
+      for (const ext2 of spec.extensions) {
+        extensionIndex.set(ext2, id);
+      }
+    }
+    supportedLanguageIds = Object.keys(registry);
+    allExtensions = [...extensionIndex.keys()];
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AUTO_RULE_PATH: () => AUTO_RULE_PATH,
+  AUTO_RULE_SENTINEL: () => AUTO_RULE_SENTINEL,
+  CLAUDE_RULE_PATH: () => CLAUDE_RULE_PATH,
+  CLAUDE_RULE_SENTINEL: () => CLAUDE_RULE_SENTINEL,
+  CURSOR_RULE_PATH: () => CURSOR_RULE_PATH,
+  DEFAULT_IGNORED: () => DEFAULT_IGNORED,
+  RULE_TARGET_PATH: () => RULE_TARGET_PATH,
+  allExtensions: () => allExtensions,
+  approximateTokens: () => approximateTokens,
+  assemble: () => assemble,
+  createAutoRule: () => createAutoRule,
+  createCursorRule: () => createCursorRule,
+  createWatcher: () => createWatcher,
+  extractImports: () => extractImports,
+  extractSpecifiers: () => extractSpecifiers,
+  getGrammar: () => getGrammar,
+  hashOf: () => hashOf,
+  languageForFile: () => languageForFile,
+  prune: () => prune,
+  registry: () => registry,
+  resolveImport: () => resolveImport,
+  spliceRanges: () => spliceRanges,
+  startMcpServer: () => startMcpServer,
+  startServer: () => startServer,
+  supportedLanguageIds: () => supportedLanguageIds,
+  version: () => version,
+  warmGrammars: () => warmGrammars
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/parser/pruner.ts
+var import_web_tree_sitter = __toESM(require("web-tree-sitter"), 1);
+var import_node_module = require("module");
+var import_node_path3 = __toESM(require("path"), 1);
+init_registry();
+
+// src/parser/wasm.ts
+var import_node_fs = __toESM(require("fs"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
+function resolveWasmDir() {
+  const candidates = [
+    import_node_path2.default.resolve(__dirname, "../../wasm"),
+    import_node_path2.default.resolve(__dirname, "../wasm"),
+    import_node_path2.default.resolve(process.cwd(), "wasm")
+  ];
+  for (const dir2 of candidates) {
+    try {
+      import_node_fs.default.mkdirSync(dir2, { recursive: true });
+      return dir2;
+    } catch {
+    }
+  }
+  const dir = import_node_path2.default.resolve(process.cwd(), "wasm");
+  import_node_fs.default.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+var wasmDir = null;
+function cacheDir() {
+  if (!wasmDir) wasmDir = resolveWasmDir();
+  return wasmDir;
+}
+function cachePath(spec) {
+  return import_node_path2.default.join(cacheDir(), spec.wasm);
+}
+function looksLikeWasm(bytes) {
+  return bytes.length >= 4 && bytes[0] === 0 && bytes[1] === 97 && bytes[2] === 115 && bytes[3] === 109;
+}
+var inflight = /* @__PURE__ */ new Map();
+function download(spec) {
+  const pending = inflight.get(spec.wasm);
+  if (pending) return pending;
+  const job = (async () => {
+    const res = await fetch(spec.url, { redirect: "follow" });
+    if (!res.ok) {
+      throw new Error(
+        `Failed to download grammar "${spec.wasm}" from ${spec.url} (HTTP ${res.status})`
+      );
+    }
+    const bytes = new Uint8Array(await res.arrayBuffer());
+    if (!looksLikeWasm(bytes)) {
+      throw new Error(
+        `Downloaded grammar "${spec.wasm}" is not valid WebAssembly (got HTML/redirect).`
+      );
+    }
+    const target = cachePath(spec);
+    const tmp = `${target}.${process.pid}.tmp`;
+    import_node_fs.default.writeFileSync(tmp, bytes);
+    import_node_fs.default.renameSync(tmp, target);
+    inflight.delete(spec.wasm);
+    return bytes;
+  })().catch((err) => {
+    inflight.delete(spec.wasm);
+    throw err;
+  });
+  inflight.set(spec.wasm, job);
+  return job;
+}
+async function getGrammar(spec, force = false) {
+  if (!force && import_node_fs.default.existsSync(cachePath(spec))) {
+    const cached = import_node_fs.default.readFileSync(cachePath(spec));
+    if (looksLikeWasm(cached)) return cached;
+  }
+  return download(spec);
+}
+async function warmGrammars(specs = []) {
+  const registryModule = await Promise.resolve().then(() => (init_registry(), registry_exports));
+  const list = specs.length > 0 ? specs : Object.values(registryModule.registry);
+  const unique = /* @__PURE__ */ new Map();
+  for (const spec of list) unique.set(spec.wasm, spec);
+  const results = await Promise.allSettled(
+    [...unique.values()].map((spec) => getGrammar(spec))
+  );
+  return results.filter((r) => r.status === "fulfilled").length;
+}
+
+// src/parser/pruner.ts
+var languageCache = /* @__PURE__ */ new Map();
+var initPromise = null;
+function ensureParserInit() {
+  if (!initPromise) {
+    initPromise = import_web_tree_sitter.default.init({
+      locateFile: (file) => {
+        const require2 = (0, import_node_module.createRequire)(__filename);
+        try {
+          const pkgRoot = import_node_path3.default.dirname(require2.resolve("web-tree-sitter/package.json"));
+          return import_node_path3.default.join(pkgRoot, file);
+        } catch {
+          return file;
+        }
+      }
+    });
+  }
+  return initPromise;
+}
+function loadLanguage(spec, force = false) {
+  if (!force) {
+    const cached = languageCache.get(spec.wasm);
+    if (cached) return Promise.resolve(cached);
+  }
+  if (force) languageCache.delete(spec.wasm);
+  return (async () => {
+    await ensureParserInit();
+    const grammar = await getGrammar(spec, force);
+    const language = await import_web_tree_sitter.default.Language.load(grammar);
+    languageCache.set(spec.wasm, language);
+    return language;
+  })();
+}
+async function prune(filePath, source, opts = {}) {
+  const spec = languageForFile(filePath);
+  if (!spec || spec.rules.length === 0) {
+    return { code: source, language: null, removed: 0 };
+  }
+  const language = await loadLanguage(spec, opts.forceDownload);
+  const parser = new import_web_tree_sitter.default();
+  parser.setLanguage(language);
+  const tree = parser.parse(source);
+  const ranges = [];
+  for (const rule of spec.rules) {
+    const query = language.query(rule.query);
+    const captures = query.captures(tree.rootNode);
+    for (const cap of captures) {
+      if (cap.node.startIndex === cap.node.endIndex) continue;
+      if (rule.replacement.keepIf?.test(cap.node.text)) continue;
+      ranges.push({
+        start: cap.node.startIndex,
+        end: cap.node.endIndex,
+        token: rule.replacement.token
+      });
+    }
+    query.delete();
+  }
+  tree.delete();
+  parser.delete();
+  const { code, removed } = spliceRanges(source, ranges);
+  return { code, language: spec.name, removed };
+}
+function spliceRanges(source, ranges) {
+  let removed = 0;
+  const sorted = [...ranges].sort((a, b) => b.start - a.start);
+  let out = source;
+  for (const r of sorted) {
+    if (r.start < 0 || r.end > out.length || r.end < r.start) continue;
+    removed += r.end - r.start;
+    out = out.slice(0, r.start) + r.token + out.slice(r.end);
+  }
+  return { code: out, removed };
+}
+
+// src/index.ts
+init_registry();
+
+// src/watcher/sync.ts
+var import_node_fs2 = __toESM(require("fs"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
+var import_node_crypto = require("crypto");
+var import_chokidar = __toESM(require("chokidar"), 1);
+var DEFAULT_IGNORED = [
+  /(^|[/\\])\.[^/\\]+/,
+  // dotfiles / dot-dirs (.git, .cursor, .env, ...)
+  /node_modules/,
+  /[/\\](build|dist|out|coverage|\.next|\.turbo|\.cache)[/\\]/
+];
+var ContextCache = class {
+  entries = /* @__PURE__ */ new Map();
+  initPromise = null;
+  ensureInit() {
+    if (!this.initPromise) {
+      this.initPromise = ensureParserInit();
+    }
+    return this.initPromise;
+  }
+  /** Returns the cached skeleton for a file, if present. */
+  getSkeleton(filePath) {
+    return this.entries.get(import_node_path4.default.resolve(filePath)) ?? null;
+  }
+  get imports() {
+    return this.entries;
+  }
+};
+function hashOf(text) {
+  return (0, import_node_crypto.createHash)("sha1").update(text).digest("hex");
+}
+function extractImports(_filePath, source) {
+  const out = [];
+  const re = /(?:from\s+['"`]([^'"`]+)['"`]|import\s+['"`]([^'"`]+)['"`]|require\s*\(\s*['"]([^'"]+)['"]\s*\))/g;
+  let m;
+  while ((m = re.exec(source)) !== null) {
+    const spec = m[1] ?? m[2] ?? m[3];
+    if (spec) out.push(spec);
+  }
+  return [...new Set(out)].filter(Boolean);
+}
+function resolveImport(importer, specifier, root) {
+  if (!/^[.~@]/.test(specifier)) {
+    if (specifier.startsWith("@/")) {
+      return resolveCandidate(import_node_path4.default.join(root, specifier.slice(2)));
+    }
+    if (specifier.startsWith("@")) {
+      return null;
+    }
+    if (specifier.startsWith("~")) {
+      return resolveCandidate(import_node_path4.default.join(root, specifier.slice(1)));
+    }
+    return null;
+  }
+  const base = import_node_path4.default.dirname(import_node_path4.default.resolve(importer));
+  return resolveCandidate(import_node_path4.default.resolve(base, specifier));
+}
+function resolveCandidate(p) {
+  const candidates = [
+    p,
+    `${p}.ts`,
+    `${p}.tsx`,
+    `${p}.js`,
+    `${p}.jsx`,
+    `${p}.mjs`,
+    `${p}.cjs`,
+    `${p}.py`,
+    `${p}.go`,
+    `${p}.rs`,
+    `${p}.dart`,
+    `${p}.swift`,
+    `${p}.java`,
+    `${p}.kt`,
+    `${p}.c`,
+    `${p}.cpp`,
+    `${p}.h`,
+    `${p}.hpp`,
+    `${p}.php`,
+    import_node_path4.default.join(p, "index.ts"),
+    import_node_path4.default.join(p, "index.js"),
+    import_node_path4.default.join(p, "index.tsx"),
+    import_node_path4.default.join(p, "index.jsx"),
+    import_node_path4.default.join(p, "index.py")
+  ];
+  for (const c of candidates) {
+    if (import_node_fs2.default.existsSync(c) && import_node_fs2.default.statSync(c).isFile()) return import_node_path4.default.resolve(c);
+  }
+  return null;
+}
+function createWatcher(opts) {
+  const cache = new ContextCache();
+  const { root, ignored = DEFAULT_IGNORED, onIndexed } = opts;
+  const pending = /* @__PURE__ */ new Map();
+  const DEBOUNCE_MS = 100;
+  async function handle(filePath) {
+    const abs = import_node_path4.default.resolve(filePath);
+    let source;
+    try {
+      const st = import_node_fs2.default.statSync(abs);
+      if (!st.isFile()) return;
+      source = import_node_fs2.default.readFileSync(abs, "utf8");
+    } catch {
+      return;
+    }
+    const hash = hashOf(source);
+    const cached = cache.entries.get(abs);
+    if (cached && cached.hash === hash) return;
+    await cache.ensureInit();
+    const { code, language } = await prune(abs, source);
+    const imports = await extractImports(abs, source);
+    const entry = {
+      hash,
+      skeleton: code,
+      language,
+      imports: imports.map((spec) => resolveImport(abs, spec, root)).filter((p) => p !== null)
+    };
+    cache.entries.set(abs, entry);
+    onIndexed?.(abs, entry);
+  }
+  const watcher = import_chokidar.default.watch(root, {
+    // Combine path matchers with a stat check so non-regular files (e.g. unix
+    // sockets) are never opened with fs.watch (which raises UVException).
+    ignored(_p, stats) {
+      if (stats && !stats.isFile() && !stats.isDirectory()) return true;
+      return isIgnored(import_node_path4.default.resolve(String(_p)), ignored);
+    },
+    alwaysStat: true,
+    ignoreInitial: true,
+    persistent: true,
+    awaitWriteFinish: { stabilityThreshold: 50, pollInterval: 10 }
+  });
+  function debounce(filePath) {
+    const abs = import_node_path4.default.resolve(filePath);
+    const existing = pending.get(abs);
+    if (existing) clearTimeout(existing);
+    if (!existing) void handle(abs);
+    pending.set(
+      abs,
+      setTimeout(() => pending.delete(abs), DEBOUNCE_MS)
+    );
+  }
+  watcher.on("add", debounce);
+  watcher.on("change", debounce);
+  watcher.on("unlink", (filePath) => {
+    const abs = import_node_path4.default.resolve(filePath);
+    cache.entries.delete(abs);
+  });
+  return {
+    cache,
+    watcher,
+    /** Index an existing file right now (bypasses the watcher). */
+    index: handle,
+    /**
+     * Index the whole tree once (cold start). Returns the number of files
+     * successfully indexed.
+     */
+    async indexAll() {
+      const files = [];
+      await walk(root, (f) => files.push(f), ignored);
+      let ok = 0;
+      for (const f of files) {
+        try {
+          await handle(f);
+          ok++;
+        } catch {
+        }
+      }
+      return ok;
+    },
+    close: () => watcher.close()
+  };
+}
+async function walk(root, push, ignored) {
+  const entries = await import_node_fs2.default.promises.readdir(root, { withFileTypes: true });
+  for (const e of entries) {
+    const abs = import_node_path4.default.join(root, e.name);
+    if (isIgnored(abs, ignored)) continue;
+    if (e.isDirectory()) {
+      await walk(abs, push, ignored);
+    } else if (e.isFile()) {
+      push(abs);
+    }
+  }
+}
+function isIgnored(abs, ignored) {
+  for (const m of ignored) {
+    if (typeof m === "string" && abs.includes(m)) return true;
+    if (m instanceof RegExp && m.test(abs)) return true;
+  }
+  return false;
+}
+
+// src/server/assembler.ts
+var import_node_fs3 = __toESM(require("fs"), 1);
+var import_node_path5 = __toESM(require("path"), 1);
+function assemble(activeFilePath, cache, opts = {}) {
+  const { includeStats = false, maxSkeletons = 50, pruneActiveFile = false } = opts;
+  const abs = import_node_path5.default.resolve(activeFilePath);
+  const activeSource = import_node_fs3.default.existsSync(abs) ? import_node_fs3.default.readFileSync(abs, "utf8") : "";
+  const activeEntry = cache.get(abs);
+  const included = [];
+  const unresolved = [];
+  const seen = /* @__PURE__ */ new Set();
+  if (activeEntry) {
+    for (const imp of activeEntry.imports) {
+      const entry = cache.get(imp);
+      if (!entry) {
+        unresolved.push(imp);
+        continue;
+      }
+      if (seen.has(imp)) continue;
+      seen.add(imp);
+      included.push({ filePath: imp, language: entry.language });
+      if (included.length >= maxSkeletons) break;
+    }
+  }
+  if (!activeEntry && activeSource) {
+    const specifiers = extractSpecifiers(activeSource);
+    for (const spec of specifiers) {
+      const resolved = resolveLocal(abs, spec);
+      if (!resolved) {
+        unresolved.push(spec);
+        continue;
+      }
+      if (seen.has(resolved)) continue;
+      seen.add(resolved);
+      const cached = cache.get(resolved);
+      included.push({ filePath: resolved, language: cached?.language ?? null });
+      if (included.length >= maxSkeletons) break;
+    }
+  }
+  const lines = [];
+  lines.push("# Compressed Code Context", "");
+  lines.push(`Active file: \`${rel(abs)}\``, "");
+  lines.push("## Ring 0 \u2014 Active file (full text)", "");
+  const ring0 = pruneActiveFile && activeEntry ? activeEntry.skeleton : activeSource;
+  lines.push(`\`\`\`${ext(activeFilePath)}`);
+  lines.push(ring0.trim() || "(empty or unreadable file)");
+  lines.push("```", "");
+  lines.push(
+    `## Ring 1 \u2014 Pruned dependencies (${included.length})`,
+    "",
+    "Implementation bodies removed; type signatures, interfaces and exports retained.",
+    ""
+  );
+  if (included.length === 0) {
+    lines.push("_No local dependency skeletons available._", "");
+  }
+  for (const inc of included) {
+    const entry = cache.get(inc.filePath);
+    const label = rel(inc.filePath);
+    lines.push(`### \`${label}\``, "");
+    if (entry) {
+      lines.push(`\`\`\`${ext(inc.filePath)}`);
+      lines.push(entry.skeleton.trim());
+      lines.push("```", "");
+    } else {
+      lines.push("_Unindexed file._", "");
+    }
+  }
+  if (unresolved.length > 0) {
+    lines.push("## Unresolved imports", "");
+    for (const u of unresolved) lines.push(`- \`${u}\``);
+    lines.push("");
+  }
+  if (includeStats) {
+    const depTokens = included.reduce(
+      (acc, inc) => {
+        const e = cache.get(inc.filePath);
+        return e ? acc + approximateTokens(e.skeleton) : acc;
+      },
+      0
+    );
+    lines.push("---", "");
+    lines.push(
+      `_Token estimate \u2014 active: ${approximateTokens(activeSource)} \xB7 pruned deps: ${depTokens}._`,
+      ""
+    );
+  }
+  return {
+    markdown: lines.join("\n"),
+    activeFilePath: abs,
+    activeSource,
+    included,
+    unresolved
+  };
+}
+function extractSpecifiers(source) {
+  const found = [];
+  const re = /(?:from\s+['"`]|import\s+['"`]|require\s*\(\s*['"`])([^'"`]+)['"`]/g;
+  let m;
+  while ((m = re.exec(source)) !== null) {
+    if (m[1]) found.push(m[1]);
+  }
+  return [...new Set(found)];
+}
+function resolveLocal(importer, specifier) {
+  if (!/^[.~@]/.test(specifier)) return null;
+  if (specifier.startsWith("@/")) specifier = specifier.slice(2);
+  else if (specifier.startsWith("~")) specifier = specifier.slice(1);
+  const base = import_node_path5.default.dirname(import_node_path5.default.resolve(importer));
+  const p = import_node_path5.default.resolve(base, specifier);
+  const candidates = [
+    p,
+    `${p}.ts`,
+    `${p}.tsx`,
+    `${p}.js`,
+    `${p}.jsx`,
+    `${p}.py`,
+    `${p}.go`,
+    `${p}.rs`,
+    `${p}.dart`,
+    `${p}.swift`,
+    `${p}.java`,
+    `${p}.kt`,
+    `${p}.c`,
+    `${p}.cpp`,
+    import_node_path5.default.join(p, "index.ts"),
+    import_node_path5.default.join(p, "index.js")
+  ];
+  for (const c of candidates) {
+    if (import_node_fs3.default.existsSync(c) && import_node_fs3.default.statSync(c).isFile()) return import_node_path5.default.resolve(c);
+  }
+  return null;
+}
+function rel(p) {
+  try {
+    const cwd = process.cwd();
+    if (p.startsWith(cwd)) return "." + p.slice(cwd.length);
+  } catch {
+  }
+  return p;
+}
+function ext(p) {
+  return import_node_path5.default.extname(p).replace(/^\./, "") || "text";
+}
+function approximateTokens(text) {
+  if (!text) return 0;
+  const tokens = text.match(/[A-Za-z0-9_$]+|[^A-Za-z0-9_\s$]/g);
+  return tokens ? tokens.length : 0;
+}
+
+// src/cli.ts
+var import_fastify = __toESM(require("fastify"), 1);
+var import_picocolors = __toESM(require("picocolors"), 1);
+var import_node_path6 = __toESM(require("path"), 1);
+function parseArgv(argv = process.argv) {
+  const out = {};
+  for (let i = 0; i < argv.length; i++) {
+    const cur = argv[i];
+    if (cur?.startsWith("--")) {
+      const key = cur.slice(2);
+      const next = argv[i + 1];
+      if (next && !next.startsWith("--")) {
+        out[key] = next;
+        i++;
+      } else {
+        out[key] = "true";
+      }
+    }
+  }
+  return out;
+}
+async function startServer(opts = {}) {
+  const args = parseArgv();
+  const port = opts.port ?? Number(args.port ?? process.env.PORT ?? 3e3);
+  const host = opts.host ?? args.host ?? "0.0.0.0";
+  const root = import_node_path6.default.resolve(opts.root ?? args.root ?? process.cwd());
+  const silent = opts.silent ?? args.silent === "true";
+  const log = (msg) => {
+    if (!silent) console.log(import_picocolors.default.dim(msg));
+  };
+  void warmGrammars().catch(() => {
+  });
+  const watcher = createWatcher({ root, ignored: opts.ignored });
+  log(`Indexing ${root} in the background\u2026`);
+  void watcher.indexAll().then((n) => log(`Indexed ${n} files.`));
+  const app = (0, import_fastify.default)({ logger: !silent });
+  app.get("/health", async () => ({
+    status: "ok",
+    service: "token-shrink",
+    version: "2.0.0",
+    root,
+    indexed: watcher.cache.entries.size
+  }));
+  app.post("/v1/context", async (req, reply) => {
+    const body = req.body ?? {};
+    if (!body.activeFilePath) {
+      return reply.status(400).send({ error: "`activeFilePath` is required" });
+    }
+    const result = assemble(body.activeFilePath, watcher.cache.entries, {
+      maxSkeletons: body.maxSkeletons,
+      includeStats: body.includeStats
+    });
+    return {
+      markdown: result.markdown,
+      activeFilePath: result.activeFilePath,
+      dependencies: result.included.map((i) => i.filePath),
+      unresolved: result.unresolved
+    };
+  });
+  app.setNotFoundHandler(async (req, reply) => {
+    void req;
+    return reply.status(404).send({ error: "Not found" });
+  });
+  await app.listen({ port, host });
+  log(`Listening on http://${host}:${port}`);
+  return { app, watcher };
+}
+var argv1 = process.argv[1] ? import_node_path6.default.basename(process.argv[1]) : "";
+if (argv1 === "cli.js" || argv1 === "cli.mjs" || argv1 === "cli.cjs" || argv1 === "cli.ts") {
+  startServer().catch((err) => {
+    console.error(import_picocolors.default.red(`[token-shrink] ${err.message}`));
+    process.exitCode = 1;
+  });
+}
+
+// src/mcp.ts
+var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
+var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
+var import_zod = require("zod");
+var import_node_fs4 = __toESM(require("fs"), 1);
+var import_node_path7 = __toESM(require("path"), 1);
+var RULE_TARGET_PATH = {
+  cursor: ".cursor/rules/token-shrink.mdc",
+  claude: ".claude/rules/token-shrink.md"
+};
+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 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.
+
+${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.
+
+${CLAUDE_RULE_SENTINEL}
+`
+  }
+};
+function createAutoRule(root, target) {
+  const spec = ruleTargets[target];
+  const rulePath = import_node_path7.default.join(root, spec.relPath);
+  try {
+    if (import_node_fs4.default.existsSync(rulePath)) {
+      const existing = import_node_fs4.default.readFileSync(rulePath, "utf8");
+      if (existing.includes(spec.sentinel)) {
+        return { created: false, skipped: "exists", filePath: rulePath };
+      }
+      return { created: false, skipped: "user", filePath: rulePath };
+    }
+    import_node_fs4.default.mkdirSync(import_node_path7.default.dirname(rulePath), { recursive: true });
+    import_node_fs4.default.writeFileSync(rulePath, spec.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"];
+  const list = Array.isArray(ruleTarget) ? ruleTarget : [ruleTarget];
+  if (list.includes("all")) return ["cursor", "claude"];
+  return list;
+}
+async function startMcpServer(opts = {}) {
+  const root = import_node_path7.default.resolve(opts.root ?? process.env.ROOT ?? process.cwd());
+  const log = (msg) => {
+    if (!opts.silent) process.stderr.write(`[token-shrink] ${msg}
+`);
+  };
+  const watcher = createWatcher({ root, ignored: opts.ignored });
+  if (!opts.silent) {
+    log(`Indexing ${root} in the background\u2026`);
+  }
+  if (opts.createRule !== false) {
+    for (const target of resolveTargets(opts.ruleTarget)) {
+      const res = createAutoRule(root, 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.`);
+      }
+    }
+  }
+  void watcher.indexAll().then((n) => log(`Indexed ${n} files.`));
+  const server = new import_mcp.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 a file: the active file\u2019s full source (Ring 0) plus pruned skeletons of its direct imports (Ring 1). Implementation bodies are removed but type signatures, interfaces, and module exports are preserved for ~80-90% token reduction.",
+      inputSchema: {
+        activeFilePath: import_zod.z.string().describe("Path to the file the agent is working on"),
+        maxSkeletons: import_zod.z.number().int().min(1).max(200).optional().describe("Cap on number of dependency skeletons to include"),
+        includeStats: import_zod.z.boolean().optional().describe("Append approximate token-count stats")
+      }
+    },
+    async ({ activeFilePath, maxSkeletons, includeStats }) => {
+      const result = assemble(activeFilePath, watcher.cache.entries, {
+        maxSkeletons,
+        includeStats
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: result.markdown
+          },
+          {
+            type: "text",
+            text: `[stats] active=${result.activeFilePath} dependencies=${result.included.length} unresolved=${result.unresolved.length}`
+          }
+        ]
+      };
+    }
+  );
+  const transport = new import_stdio.StdioServerTransport();
+  await server.connect(transport);
+  log("MCP server connected.");
+  return server;
+}
+var argv12 = process.argv[1] ? import_node_path7.default.basename(process.argv[1]) : "";
+if (argv12 === "mcp.js" || argv12 === "mcp.mjs" || argv12 === "mcp.cjs" || argv12 === "mcp.ts") {
+  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"
+  ) : void 0;
+  void startMcpServer({ root: rootArg, createRule, ruleTarget }).catch((err) => {
+    process.stderr.write(`[token-shrink] MCP server error: ${err.message}
+`);
+    process.exitCode = 1;
+  });
+}
+
+// src/index.ts
+var version = "2.0.0";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AUTO_RULE_PATH,
+  AUTO_RULE_SENTINEL,
+  CLAUDE_RULE_PATH,
+  CLAUDE_RULE_SENTINEL,
+  CURSOR_RULE_PATH,
+  DEFAULT_IGNORED,
+  RULE_TARGET_PATH,
+  allExtensions,
+  approximateTokens,
+  assemble,
+  createAutoRule,
+  createCursorRule,
+  createWatcher,
+  extractImports,
+  extractSpecifiers,
+  getGrammar,
+  hashOf,
+  languageForFile,
+  prune,
+  registry,
+  resolveImport,
+  spliceRanges,
+  startMcpServer,
+  startServer,
+  supportedLanguageIds,
+  version,
+  warmGrammars
+});
+//# sourceMappingURL=index.cjs.map