@ajdev0/token-shrink 2.0.1 → 2.0.3

package/dist/cli.cjs

@@ -188,103 +188,180 @@ __export(cli_exports, {
 module.exports = __toCommonJS(cli_exports);
 var import_fastify = __toESM(require("fastify"), 1);
 var import_picocolors = __toESM(require("picocolors"), 1);
-var import_node_path6 = __toESM(require("path"), 1);
+var import_node_fs5 = __toESM(require("fs"), 1);
+var import_node_path7 = __toESM(require("path"), 1);
 
 // src/server/assembler.ts
 var import_node_fs = __toESM(require("fs"), 1);
 var import_node_path = __toESM(require("path"), 1);
-function assemble(activeFilePath, cache, opts = {}) {
-  const { includeStats = false, maxSkeletons = 50, pruneActiveFile = false } = opts;
-  const abs = import_node_path.default.resolve(activeFilePath);
-  const activeSource = import_node_fs.default.existsSync(abs) ? import_node_fs.default.readFileSync(abs, "utf8") : "";
-  const activeEntry = cache.get(abs);
+var MARKDOWN_OVERHEAD_TOKENS = 40;
+function assembleMany(activeFiles, cache, opts = {}) {
+  const {
+    includeStats = false,
+    maxSkeletons = 50,
+    maxTokens,
+    pruneActiveFile = false
+  } = opts;
+  const absList = activeFiles.map((p) => import_node_path.default.resolve(p));
+  const sources = absList.map((abs) => {
+    try {
+      return import_node_fs.default.readFileSync(abs, "utf8");
+    } catch {
+      return "";
+    }
+  });
+  const activeSet = new Set(absList);
+  const ring0Texts = absList.map((abs, i) => {
+    const entry = cache.get(abs);
+    return pruneActiveFile && entry ? entry.skeleton : sources[i];
+  });
   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;
+  const addUnresolved = (p) => {
+    if (!unresolved.includes(p)) unresolved.push(p);
+  };
+  const addIncluded = (p, allowUncached) => {
+    if (seen.has(p)) return;
+    const entry = cache.get(p);
+    if (!entry && !allowUncached) {
+      addUnresolved(p);
+      return;
+    }
+    seen.add(p);
+    included.push({ filePath: p, language: entry?.language ?? null });
+  };
+  for (let i = 0; i < absList.length; i++) {
+    const abs = absList[i];
+    const entry = cache.get(abs);
+    if (entry) {
+      for (const imp of entry.imports) {
+        if (activeSet.has(imp)) continue;
+        addIncluded(imp, false);
+      }
+    } else if (sources[i]) {
+      for (const spec of extractSpecifiers(sources[i])) {
+        const resolved = resolveLocal(abs, spec);
+        if (!resolved) {
+          addUnresolved(spec);
+          continue;
+        }
+        if (activeSet.has(resolved)) continue;
+        addIncluded(resolved, true);
       }
-      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 ordered = maxTokens === void 0 ? included : rankByRelevance(included, cache);
+  const budget = maxTokens === void 0 ? void 0 : Math.max(0, maxTokens - MARKDOWN_OVERHEAD_TOKENS);
+  const selected = [];
+  let trimmed = 0;
+  let dependencyTokens = 0;
+  for (const cand of ordered) {
+    if (selected.length >= maxSkeletons) break;
+    const entry = cache.get(cand.filePath);
+    const cost = entry ? approximateTokens(entry.skeleton) : 8;
+    if (budget !== void 0 && dependencyTokens + cost > budget) {
+      trimmed++;
+      continue;
     }
+    selected.push(cand);
+    dependencyTokens += cost;
   }
+  const activeTokens = ring0Texts.reduce(
+    (acc, t) => acc + approximateTokens(t),
+    0
+  );
   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("```", "");
+  if (absList.length === 1) {
+    lines.push(`Active file: \`${rel(absList[0])}\``, "");
+  } else {
+    lines.push("Active files:", "");
+    for (const p of absList) lines.push(`- \`${rel(p)}\``);
+    lines.push("");
+  }
+  lines.push(
+    absList.length === 1 ? "## Ring 0 \u2014 Active file (full text)" : "## Ring 0 \u2014 Active files (full text)",
+    ""
+  );
+  for (let i = 0; i < absList.length; i++) {
+    if (absList.length > 1) lines.push(`### \`${rel(absList[i])}\``, "");
+    const body = ring0Texts[i].trim() || "(empty or unreadable file)";
+    lines.push(`\`\`\`${ext(absList[i])}`, body, "```", "");
+  }
   lines.push(
-    `## Ring 1 \u2014 Pruned dependencies (${included.length})`,
+    `## Ring 1 \u2014 Pruned dependencies (${selected.length})`,
     "",
     "Implementation bodies removed; type signatures, interfaces and exports retained.",
     ""
   );
-  if (included.length === 0) {
+  if (selected.length === 0) {
     lines.push("_No local dependency skeletons available._", "");
   }
-  for (const inc of included) {
+  for (const inc of selected) {
     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("```", "");
+      lines.push(`\`\`\`${ext(inc.filePath)}`, entry.skeleton.trim(), "```", "");
     } else {
       lines.push("_Unindexed file._", "");
     }
   }
+  if (maxTokens !== void 0 && trimmed > 0) {
+    lines.push(
+      `_Note: token budget of ${maxTokens} excluded ${trimmed} lower-priority dependenc${trimmed === 1 ? "y" : "ies"}._`,
+      ""
+    );
+  }
   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("---", "");
+    const budgetNote = maxTokens !== void 0 ? ` \xB7 budget ${maxTokens} (${trimmed} deps trimmed)` : "";
     lines.push(
-      `_Token estimate \u2014 active: ${approximateTokens(activeSource)} \xB7 pruned deps: ${depTokens}._`,
+      "---",
+      "",
+      `_Token estimate \u2014 active: ${activeTokens} \xB7 pruned deps: ${dependencyTokens}${budgetNote}._`,
       ""
     );
   }
   return {
     markdown: lines.join("\n"),
-    activeFilePath: abs,
-    activeSource,
-    included,
-    unresolved
+    activeFilePath: absList[0] ?? "",
+    activeFilePaths: absList,
+    activeSource: sources.join("\n"),
+    included: selected,
+    unresolved,
+    tokenStats: {
+      activeTokens,
+      dependencyTokens,
+      totalTokens: activeTokens + dependencyTokens,
+      ...maxTokens !== void 0 ? { budget: maxTokens } : {},
+      trimmed
+    }
   };
 }
+function rankByRelevance(candidates, cache) {
+  const fanIn = /* @__PURE__ */ new Map();
+  for (const entry of cache.values()) {
+    for (const imp of entry.imports) fanIn.set(imp, (fanIn.get(imp) ?? 0) + 1);
+  }
+  return candidates.map((cand, idx) => ({ cand, idx })).sort((a, b) => {
+    const fa = fanIn.get(a.cand.filePath) ?? 0;
+    const fb = fanIn.get(b.cand.filePath) ?? 0;
+    if (fa !== fb) return fb - fa;
+    const da = pathDepth(a.cand.filePath);
+    const db = pathDepth(b.cand.filePath);
+    if (da !== db) return da - db;
+    return a.idx - b.idx;
+  }).map((x) => x.cand);
+}
+function pathDepth(p) {
+  return p.split(/[/\\]+/).filter(Boolean).length;
+}
 function extractSpecifiers(source) {
   const found = [];
   const re = /(?:from\s+['"`]|import\s+['"`]|require\s*\(\s*['"`])([^'"`]+)['"`]/g;
@@ -341,12 +418,12 @@ function approximateTokens(text) {
 }
 
 // src/watcher/sync.ts
-var import_node_fs3 = __toESM(require("fs"), 1);
-var import_node_path5 = __toESM(require("path"), 1);
+var import_node_fs4 = __toESM(require("fs"), 1);
+var import_node_path6 = __toESM(require("path"), 1);
 var import_node_crypto = require("crypto");
 var import_chokidar = __toESM(require("chokidar"), 1);
 
-// src/parser/pruner.ts
+// src/parser/analyze.ts
 var import_web_tree_sitter = __toESM(require("web-tree-sitter"), 1);
 var import_node_module = require("module");
 var import_node_path4 = __toESM(require("path"), 1);
@@ -431,7 +508,85 @@ async function warmGrammars(specs = []) {
   return results.filter((r) => r.status === "fulfilled").length;
 }
 
-// src/parser/pruner.ts
+// src/parser/symbols.ts
+var KIND_BY_TYPE = {
+  // TypeScript / JavaScript / TSX / JSX
+  function_declaration: "function",
+  generator_function_declaration: "function",
+  function_expression: "function",
+  function_signature_item: "function",
+  method_definition: "method",
+  method_signature: "method",
+  class_declaration: "class",
+  abstract_class_declaration: "class",
+  interface_declaration: "interface",
+  enum_declaration: "enum",
+  type_alias_declaration: "type",
+  // Python
+  function_definition: "function",
+  class_definition: "class",
+  // Go
+  method_declaration: "method",
+  type_spec: "type",
+  // Rust
+  function_item: "function",
+  struct_item: "class",
+  enum_item: "enum",
+  trait_item: "interface",
+  type_item: "type",
+  // Java / Kotlin / PHP / Dart / Swift (best-effort generic names)
+  constructor_declaration: "method",
+  module_declaration: "class",
+  protocol_declaration: "interface"
+};
+var SIGNATURE_MAX = 200;
+function collectSymbols(root, source) {
+  const out = [];
+  const walk2 = (node) => {
+    const kind = KIND_BY_TYPE[node.type];
+    if (kind) {
+      const nameNode = node.childForFieldName("name");
+      if (nameNode && nameNode.text.trim()) {
+        out.push(symbolFrom(nameNode.text.trim(), kind, node.startIndex, node.endIndex, source));
+      }
+    } else if (node.type === "variable_declarator") {
+      const value = node.childForFieldName("value");
+      const valueType = value?.type;
+      if (valueType === "arrow_function" || valueType === "function_expression") {
+        const nameNode = node.childForFieldName("name");
+        if (nameNode && nameNode.text.trim()) {
+          out.push(
+            symbolFrom(nameNode.text.trim(), "arrow", node.startIndex, node.endIndex, source)
+          );
+        }
+      }
+    }
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i);
+      if (child) walk2(child);
+    }
+  };
+  walk2(root);
+  return out;
+}
+function symbolFrom(name, kind, start, end, source) {
+  return {
+    name,
+    kind,
+    line: source.slice(0, start).split("\n").length,
+    start,
+    end,
+    signature: signaturePreview(source, start, end)
+  };
+}
+function signaturePreview(source, start, end) {
+  const nl = source.indexOf("\n", start);
+  const endOfLine = nl === -1 ? end : nl;
+  const first = source.slice(start, Math.min(endOfLine, end)).trim();
+  return first.length > SIGNATURE_MAX ? `${first.slice(0, SIGNATURE_MAX)}\u2026` : first;
+}
+
+// src/parser/analyze.ts
 var languageCache = /* @__PURE__ */ new Map();
 var initPromise = null;
 function ensureParserInit() {
@@ -464,35 +619,6 @@ function loadLanguage(spec, force = false) {
     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);
@@ -504,6 +630,128 @@ function spliceRanges(source, ranges) {
   }
   return { code: out, removed };
 }
+async function analyze(filePath, source, opts = {}) {
+  const spec = languageForFile(filePath);
+  if (!spec || spec.rules.length === 0) {
+    return { code: source, language: null, removed: 0, symbols: [] };
+  }
+  let language;
+  try {
+    language = await loadLanguage(spec, opts.forceDownload);
+  } catch {
+    return { code: source, language: null, removed: 0, symbols: [] };
+  }
+  const parser = new import_web_tree_sitter.default();
+  parser.setLanguage(language);
+  const tree = parser.parse(source);
+  try {
+    const symbols = collectSymbols(tree.rootNode, source);
+    if (opts.skipPrune) {
+      return { code: source, language: spec.name, removed: 0, symbols };
+    }
+    const keepRanges = [
+      ...opts.keepBlocksInside ?? [],
+      ...opts.preserveAnnotations?.length ? annotatedKeepRanges(symbols, source, opts.preserveAnnotations) : []
+    ];
+    const isProtected = (start, end) => keepRanges.some((k) => k.start <= start && end <= k.end);
+    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;
+        if (isProtected(cap.node.startIndex, cap.node.endIndex)) continue;
+        ranges.push({
+          start: cap.node.startIndex,
+          end: cap.node.endIndex,
+          token: rule.replacement.token
+        });
+      }
+      query.delete();
+    }
+    const { code, removed } = spliceRanges(source, ranges);
+    return { code, language: spec.name, removed, symbols };
+  } finally {
+    tree.delete();
+    parser.delete();
+  }
+}
+var ANNOTATION_WINDOW = 240;
+function annotatedKeepRanges(symbols, source, annotations) {
+  if (annotations.length === 0) return [];
+  const markers = annotations.filter(Boolean).map(escapeRegExp);
+  if (markers.length === 0) return [];
+  const re = new RegExp(`@(${markers.join("|")})\\b`, "i");
+  return symbols.filter((s) => {
+    const windowStart = Math.max(0, s.start - ANNOTATION_WINDOW);
+    const tail = source.slice(windowStart, s.start);
+    const cut = Math.max(tail.lastIndexOf("}\n"), tail.lastIndexOf(";\n"));
+    const relevant = cut === -1 ? tail : tail.slice(cut + 1);
+    return re.test(relevant);
+  }).map((s) => ({ start: s.start, end: s.end }));
+}
+function escapeRegExp(text) {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/config.ts
+var import_node_fs3 = __toESM(require("fs"), 1);
+var import_node_path5 = __toESM(require("path"), 1);
+function matchesAny(file, patterns) {
+  const rel2 = normalizeSlashes(file);
+  for (const raw of patterns) {
+    if (!raw) continue;
+    const pattern = normalizeSlashes(raw).replace(/^\.\//, "");
+    if (matchesGlob(rel2, pattern)) return true;
+  }
+  return false;
+}
+function matchesGlob(file, pattern) {
+  if (file === pattern) return true;
+  if (!/[?*[]/.test(pattern)) {
+    return file.endsWith(`/${pattern}`);
+  }
+  const re = globToRegExp(pattern);
+  return re.test(file);
+}
+function globToRegExp(glob) {
+  let re = "^";
+  for (let i = 0; i < glob.length; i++) {
+    const c = glob[i];
+    if (c === "*") {
+      if (glob[i + 1] === "*") {
+        i++;
+        if (glob[i + 1] === "/") {
+          i++;
+          re += "(?:.*/)?";
+        } else {
+          re += ".*";
+        }
+      } else {
+        re += "[^/]*";
+      }
+    } else if (c === "?") {
+      re += "[^/]";
+    } else if (c === "[") {
+      const close = glob.indexOf("]", i);
+      if (close === -1) {
+        re += "\\[";
+      } else {
+        const inner = glob.slice(i + 1, close).replace(/\\/g, "\\\\");
+        re += `[${inner}]`;
+        i = close;
+      }
+    } else {
+      re += c.replace(/[.+^${}()|\\]/g, "\\$&");
+    }
+  }
+  re += "$";
+  return new RegExp(re);
+}
+function normalizeSlashes(p) {
+  return p.split(import_node_path5.default.sep).join("/").replace(/^\.\//, "");
+}
 
 // src/watcher/sync.ts
 var DEFAULT_IGNORED = [
@@ -523,7 +771,7 @@ var ContextCache = class {
   }
   /** Returns the cached skeleton for a file, if present. */
   getSkeleton(filePath) {
-    return this.entries.get(import_node_path5.default.resolve(filePath)) ?? null;
+    return this.entries.get(import_node_path6.default.resolve(filePath)) ?? null;
   }
   get imports() {
     return this.entries;
@@ -545,18 +793,18 @@ function extractImports(_filePath, source) {
 function resolveImport(importer, specifier, root) {
   if (!/^[.~@]/.test(specifier)) {
     if (specifier.startsWith("@/")) {
-      return resolveCandidate(import_node_path5.default.join(root, specifier.slice(2)));
+      return resolveCandidate(import_node_path6.default.join(root, specifier.slice(2)));
     }
     if (specifier.startsWith("@")) {
       return null;
     }
     if (specifier.startsWith("~")) {
-      return resolveCandidate(import_node_path5.default.join(root, specifier.slice(1)));
+      return resolveCandidate(import_node_path6.default.join(root, specifier.slice(1)));
     }
     return null;
   }
-  const base = import_node_path5.default.dirname(import_node_path5.default.resolve(importer));
-  return resolveCandidate(import_node_path5.default.resolve(base, specifier));
+  const base = import_node_path6.default.dirname(import_node_path6.default.resolve(importer));
+  return resolveCandidate(import_node_path6.default.resolve(base, specifier));
 }
 function resolveCandidate(p) {
   const candidates = [
@@ -579,29 +827,34 @@ function resolveCandidate(p) {
     `${p}.h`,
     `${p}.hpp`,
     `${p}.php`,
-    import_node_path5.default.join(p, "index.ts"),
-    import_node_path5.default.join(p, "index.js"),
-    import_node_path5.default.join(p, "index.tsx"),
-    import_node_path5.default.join(p, "index.jsx"),
-    import_node_path5.default.join(p, "index.py")
+    import_node_path6.default.join(p, "index.ts"),
+    import_node_path6.default.join(p, "index.js"),
+    import_node_path6.default.join(p, "index.tsx"),
+    import_node_path6.default.join(p, "index.jsx"),
+    import_node_path6.default.join(p, "index.py")
   ];
   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);
+    if (import_node_fs4.default.existsSync(c) && import_node_fs4.default.statSync(c).isFile()) return import_node_path6.default.resolve(c);
   }
   return null;
 }
 function createWatcher(opts) {
   const cache = new ContextCache();
-  const { root, ignored = DEFAULT_IGNORED, onIndexed } = opts;
+  const { root, ignored = DEFAULT_IGNORED, config, onIndexed, onRemoved } = opts;
+  const rel2 = (abs) => import_node_path6.default.relative(root, abs);
+  const effectiveIgnored = [
+    ...ignored,
+    ...config?.ignorePatterns?.length ? [(_abs) => matchesAny(rel2(String(_abs)), config.ignorePatterns)] : []
+  ];
   const pending = /* @__PURE__ */ new Map();
   const DEBOUNCE_MS = 100;
   async function handle(filePath) {
-    const abs = import_node_path5.default.resolve(filePath);
+    const abs = import_node_path6.default.resolve(filePath);
     let source;
     try {
-      const st = import_node_fs3.default.statSync(abs);
+      const st = import_node_fs4.default.statSync(abs);
       if (!st.isFile()) return;
-      source = import_node_fs3.default.readFileSync(abs, "utf8");
+      source = import_node_fs4.default.readFileSync(abs, "utf8");
     } catch {
       return;
     }
@@ -609,13 +862,18 @@ function createWatcher(opts) {
     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 keepFull = config?.keepUnpruned?.length ? matchesAny(import_node_path6.default.relative(root, abs), config.keepUnpruned) : false;
+    const { code, language, symbols } = await analyze(abs, source, {
+      skipPrune: keepFull,
+      preserveAnnotations: config?.preserveAnnotations
+    });
+    const imports = extractImports(abs, source);
     const entry = {
       hash,
       skeleton: code,
       language,
-      imports: imports.map((spec) => resolveImport(abs, spec, root)).filter((p) => p !== null)
+      imports: imports.map((spec) => resolveImport(abs, spec, root)).filter((p) => p !== null),
+      ...symbols.length > 0 ? { symbols } : {}
     };
     cache.entries.set(abs, entry);
     onIndexed?.(abs, entry);
@@ -625,7 +883,7 @@ function createWatcher(opts) {
     // 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_path5.default.resolve(String(_p)), ignored);
+      return isIgnored(import_node_path6.default.resolve(String(_p)), effectiveIgnored);
     },
     alwaysStat: true,
     ignoreInitial: true,
@@ -633,7 +891,7 @@ function createWatcher(opts) {
     awaitWriteFinish: { stabilityThreshold: 50, pollInterval: 10 }
   });
   function debounce(filePath) {
-    const abs = import_node_path5.default.resolve(filePath);
+    const abs = import_node_path6.default.resolve(filePath);
     const existing = pending.get(abs);
     if (existing) clearTimeout(existing);
     if (!existing) void handle(abs);
@@ -645,8 +903,9 @@ function createWatcher(opts) {
   watcher.on("add", debounce);
   watcher.on("change", debounce);
   watcher.on("unlink", (filePath) => {
-    const abs = import_node_path5.default.resolve(filePath);
+    const abs = import_node_path6.default.resolve(filePath);
     cache.entries.delete(abs);
+    onRemoved?.(abs);
   });
   return {
     cache,
@@ -659,7 +918,7 @@ function createWatcher(opts) {
      */
     async indexAll() {
       const files = [];
-      await walk(root, (f) => files.push(f), ignored);
+      await walk(root, (f) => files.push(f), effectiveIgnored);
       let ok = 0;
       for (const f of files) {
         try {
@@ -674,9 +933,9 @@ function createWatcher(opts) {
   };
 }
 async function walk(root, push, ignored) {
-  const entries = await import_node_fs3.default.promises.readdir(root, { withFileTypes: true });
+  const entries = await import_node_fs4.default.promises.readdir(root, { withFileTypes: true });
   for (const e of entries) {
-    const abs = import_node_path5.default.join(root, e.name);
+    const abs = import_node_path6.default.join(root, e.name);
     if (isIgnored(abs, ignored)) continue;
     if (e.isDirectory()) {
       await walk(abs, push, ignored);
@@ -687,6 +946,10 @@ async function walk(root, push, ignored) {
 }
 function isIgnored(abs, ignored) {
   for (const m of ignored) {
+    if (typeof m === "function") {
+      if (m(abs)) return true;
+      continue;
+    }
     if (typeof m === "string" && abs.includes(m)) return true;
     if (m instanceof RegExp && m.test(abs)) return true;
   }
@@ -715,8 +978,9 @@ 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 root = import_node_path7.default.resolve(opts.root ?? args.root ?? process.cwd());
   const silent = opts.silent ?? args.silent === "true";
+  const maxTokensDefault = args["max-tokens"] ? Number(args["max-tokens"]) : void 0;
   const log = (msg) => {
     if (!silent) console.log(import_picocolors.default.dim(msg));
   };
@@ -735,18 +999,27 @@ async function startServer(opts = {}) {
   }));
   app.post("/v1/context", async (req, reply) => {
     const body = req.body ?? {};
-    if (!body.activeFilePath) {
-      return reply.status(400).send({ error: "`activeFilePath` is required" });
+    const hasMany = Array.isArray(body.activeFiles) && body.activeFiles.length > 0;
+    if (hasMany && body.activeFilePath) {
+      return reply.status(400).send({ error: "Pass either `activeFilePath` or `activeFiles`, not both." });
+    }
+    const paths = hasMany ? body.activeFiles : body.activeFilePath ? [body.activeFilePath] : [];
+    if (paths.length === 0) {
+      return reply.status(400).send({ error: "`activeFilePath` or `activeFiles` is required" });
     }
-    const result = assemble(body.activeFilePath, watcher.cache.entries, {
+    const maxTokens = body.maxTokens !== void 0 ? body.maxTokens : maxTokensDefault;
+    const result = assembleMany(paths, watcher.cache.entries, {
       maxSkeletons: body.maxSkeletons,
+      maxTokens: Number.isFinite(maxTokens) ? maxTokens : void 0,
       includeStats: body.includeStats
     });
     return {
       markdown: result.markdown,
       activeFilePath: result.activeFilePath,
+      activeFilePaths: result.activeFilePaths,
       dependencies: result.included.map((i) => i.filePath),
-      unresolved: result.unresolved
+      unresolved: result.unresolved,
+      tokenStats: result.tokenStats
     };
   });
   app.setNotFoundHandler(async (req, reply) => {
@@ -757,8 +1030,13 @@ async function startServer(opts = {}) {
   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") {
+var argv1 = process.argv[1] ? import_node_path7.default.basename(process.argv[1]) : "";
+var argv1Real = "";
+try {
+  argv1Real = process.argv[1] ? import_node_path7.default.basename(import_node_fs5.default.realpathSync(process.argv[1])) : "";
+} catch {
+}
+if (argv1 === "cli.js" || argv1 === "cli.mjs" || argv1 === "cli.cjs" || argv1 === "cli.ts" || argv1Real === "cli.js" || argv1Real === "cli.mjs" || argv1Real === "cli.cjs" || argv1Real === "cli.ts") {
   startServer().catch((err) => {
     console.error(import_picocolors.default.red(`[token-shrink] ${err.message}`));
     process.exitCode = 1;