@ajdev0/token-shrink 2.0.2 → 2.0.3

package/dist/chunk-FYCLLG7F.js

@@ -0,0 +1,847 @@
+#!/usr/bin/env node
+import {
+  languageForFile
+} from "./chunk-7SQ6HMWM.js";
+
+// src/server/assembler.ts
+import fs from "fs";
+import path from "path";
+var MARKDOWN_OVERHEAD_TOKENS = 40;
+function assembleMany(activeFiles, cache, opts = {}) {
+  const {
+    includeStats = false,
+    maxSkeletons = 50,
+    maxTokens,
+    pruneActiveFile = false
+  } = opts;
+  const absList = activeFiles.map((p) => path.resolve(p));
+  const sources = absList.map((abs) => {
+    try {
+      return fs.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();
+  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);
+      }
+    }
+  }
+  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", "");
+  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 (${selected.length})`,
+    "",
+    "Implementation bodies removed; type signatures, interfaces and exports retained.",
+    ""
+  );
+  if (selected.length === 0) {
+    lines.push("_No local dependency skeletons available._", "");
+  }
+  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)}`, 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 budgetNote = maxTokens !== void 0 ? ` \xB7 budget ${maxTokens} (${trimmed} deps trimmed)` : "";
+    lines.push(
+      "---",
+      "",
+      `_Token estimate \u2014 active: ${activeTokens} \xB7 pruned deps: ${dependencyTokens}${budgetNote}._`,
+      ""
+    );
+  }
+  return {
+    markdown: lines.join("\n"),
+    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 assemble(activeFilePath, cache, opts = {}) {
+  return assembleMany([activeFilePath], cache, opts);
+}
+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;
+  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 = path.dirname(path.resolve(importer));
+  const p = path.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`,
+    path.join(p, "index.ts"),
+    path.join(p, "index.js")
+  ];
+  for (const c of candidates) {
+    if (fs.existsSync(c) && fs.statSync(c).isFile()) return path.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 path.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/parser/wasm.ts
+import fs2 from "fs";
+import path2 from "path";
+function resolveWasmDir() {
+  const candidates = [
+    path2.resolve(__dirname, "../../wasm"),
+    path2.resolve(__dirname, "../wasm"),
+    path2.resolve(process.cwd(), "wasm")
+  ];
+  for (const dir2 of candidates) {
+    try {
+      fs2.mkdirSync(dir2, { recursive: true });
+      return dir2;
+    } catch {
+    }
+  }
+  const dir = path2.resolve(process.cwd(), "wasm");
+  fs2.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+var wasmDir = null;
+function cacheDir() {
+  if (!wasmDir) wasmDir = resolveWasmDir();
+  return wasmDir;
+}
+function cachePath(spec) {
+  return path2.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`;
+    fs2.writeFileSync(tmp, bytes);
+    fs2.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 && fs2.existsSync(cachePath(spec))) {
+    const cached = fs2.readFileSync(cachePath(spec));
+    if (looksLikeWasm(cached)) return cached;
+  }
+  return download(spec);
+}
+async function warmGrammars(specs = []) {
+  const registryModule = await import("./registry-JLP6X4QB.js");
+  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/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 matchSymbols(symbols, query, kind) {
+  const q = query.trim();
+  if (!q) return [];
+  const pool = kind ? symbols.filter((s) => s.kind === kind) : symbols;
+  const byName = pool.filter((s) => s.name === q);
+  if (byName.length > 0) return byName;
+  const byNameCi = pool.filter((s) => s.name.toLowerCase() === q.toLowerCase());
+  if (byNameCi.length > 0) return byNameCi;
+  const lower = q.toLowerCase();
+  const bySubstring = pool.filter((s) => s.name.toLowerCase().includes(lower));
+  return bySubstring.length > 0 ? bySubstring : pool.filter((s) => (s.signature ?? "").toLowerCase().includes(lower));
+}
+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
+import Parser from "web-tree-sitter";
+import { createRequire } from "module";
+import path3 from "path";
+var languageCache = /* @__PURE__ */ new Map();
+var initPromise = null;
+function ensureParserInit() {
+  if (!initPromise) {
+    initPromise = Parser.init({
+      locateFile: (file) => {
+        const require2 = createRequire(__filename);
+        try {
+          const pkgRoot = path3.dirname(require2.resolve("web-tree-sitter/package.json"));
+          return path3.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 Parser.Language.load(grammar);
+    languageCache.set(spec.wasm, language);
+    return language;
+  })();
+}
+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 };
+}
+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 Parser();
+  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();
+  }
+}
+async function prune(filePath, source, opts = {}) {
+  const res = await analyze(filePath, source, opts);
+  return { code: res.code, language: res.language, removed: res.removed };
+}
+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
+import fs3 from "fs";
+import path4 from "path";
+var CONFIG_FILE_NAME = ".tokenshrinkrc.json";
+var EMPTY_CONFIG = {
+  ignorePatterns: [],
+  keepUnpruned: [],
+  preserveAnnotations: []
+};
+function configPathFor(root) {
+  return path4.join(root, CONFIG_FILE_NAME);
+}
+function loadConfig(root, warn) {
+  const file = configPathFor(root);
+  let raw;
+  try {
+    if (!fs3.existsSync(file)) return { ...EMPTY_CONFIG };
+    raw = JSON.parse(fs3.readFileSync(file, "utf8"));
+  } catch (err) {
+    warn?.(`Invalid ${CONFIG_FILE_NAME} at ${file}: ${err.message}`);
+    return { ...EMPTY_CONFIG };
+  }
+  return normalizeConfig(raw, warn, file);
+}
+function normalizeConfig(raw, warn, file) {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    warn?.(`Invalid ${CONFIG_FILE_NAME}${file ? ` at ${file}` : ""}: expected a JSON object.`);
+    return { ...EMPTY_CONFIG };
+  }
+  const obj = raw;
+  const asStrings = (v) => Array.isArray(v) ? v.filter((x) => typeof x === "string") : [];
+  return {
+    ignorePatterns: asStrings(obj.ignorePatterns),
+    keepUnpruned: asStrings(obj.keepUnpruned),
+    preserveAnnotations: asStrings(obj.preserveAnnotations),
+    ...typeof obj.autoWorkflow === "boolean" ? { autoWorkflow: obj.autoWorkflow } : {}
+  };
+}
+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(path4.sep).join("/").replace(/^\.\//, "");
+}
+
+// src/watcher/sync.ts
+import fs4 from "fs";
+import path5 from "path";
+import { createHash } from "crypto";
+import chokidar from "chokidar";
+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(path5.resolve(filePath)) ?? null;
+  }
+  get imports() {
+    return this.entries;
+  }
+};
+function hashOf(text) {
+  return 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(path5.join(root, specifier.slice(2)));
+    }
+    if (specifier.startsWith("@")) {
+      return null;
+    }
+    if (specifier.startsWith("~")) {
+      return resolveCandidate(path5.join(root, specifier.slice(1)));
+    }
+    return null;
+  }
+  const base = path5.dirname(path5.resolve(importer));
+  return resolveCandidate(path5.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`,
+    path5.join(p, "index.ts"),
+    path5.join(p, "index.js"),
+    path5.join(p, "index.tsx"),
+    path5.join(p, "index.jsx"),
+    path5.join(p, "index.py")
+  ];
+  for (const c of candidates) {
+    if (fs4.existsSync(c) && fs4.statSync(c).isFile()) return path5.resolve(c);
+  }
+  return null;
+}
+function createWatcher(opts) {
+  const cache = new ContextCache();
+  const { root, ignored = DEFAULT_IGNORED, config, onIndexed, onRemoved } = opts;
+  const rel2 = (abs) => path5.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 = path5.resolve(filePath);
+    let source;
+    try {
+      const st = fs4.statSync(abs);
+      if (!st.isFile()) return;
+      source = fs4.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 keepFull = config?.keepUnpruned?.length ? matchesAny(path5.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),
+      ...symbols.length > 0 ? { symbols } : {}
+    };
+    cache.entries.set(abs, entry);
+    onIndexed?.(abs, entry);
+  }
+  const watcher = chokidar.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(path5.resolve(String(_p)), effectiveIgnored);
+    },
+    alwaysStat: true,
+    ignoreInitial: true,
+    persistent: true,
+    awaitWriteFinish: { stabilityThreshold: 50, pollInterval: 10 }
+  });
+  function debounce(filePath) {
+    const abs = path5.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 = path5.resolve(filePath);
+    cache.entries.delete(abs);
+    onRemoved?.(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), effectiveIgnored);
+      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 fs4.promises.readdir(root, { withFileTypes: true });
+  for (const e of entries) {
+    const abs = path5.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 === "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;
+  }
+  return false;
+}
+
+export {
+  assembleMany,
+  assemble,
+  extractSpecifiers,
+  approximateTokens,
+  getGrammar,
+  warmGrammars,
+  collectSymbols,
+  matchSymbols,
+  ensureParserInit,
+  loadLanguage,
+  spliceRanges,
+  analyze,
+  prune,
+  CONFIG_FILE_NAME,
+  EMPTY_CONFIG,
+  configPathFor,
+  loadConfig,
+  matchesAny,
+  matchesGlob,
+  globToRegExp,
+  DEFAULT_IGNORED,
+  hashOf,
+  extractImports,
+  resolveImport,
+  createWatcher
+};
+//# sourceMappingURL=chunk-FYCLLG7F.js.map