@iowarp/clio-coder 0.3.1 → 0.3.2

package/dist/code-nav-7AX6FYE6.js

@@ -0,0 +1,600 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  listWikiPages,
+  readWikiMeta,
+  wikiCompletenessFromMeta,
+  wikiStaleness
+} from "./chunk-X4RCMKVQ.js";
+import {
+  coordinateCodewikiWrite,
+  readClioState,
+  writeClioState
+} from "./chunk-MVVUPGPW.js";
+import {
+  CODE_NAV_DEFAULT_ENTRY_LIMIT,
+  CODE_NAV_DEFAULT_LIMIT,
+  CODE_NAV_MAX_LIMIT,
+  codeNavToolSurface
+} from "./chunk-XN3L4EYL.js";
+import {
+  compileGlobRegex
+} from "./chunk-VG7TBQIY.js";
+import "./chunk-OQE5J4C6.js";
+import "./chunk-ECH6PKUQ.js";
+import {
+  OBSERVE_SELF_CAPS,
+  finalizeObservation,
+  observationBudgetExhausted,
+  reserveObservation
+} from "./chunk-VAKQQHWR.js";
+import "./chunk-6XLNIQDB.js";
+import "./chunk-5B2AEOW5.js";
+import {
+  ToolNames
+} from "./chunk-CGKSTWHD.js";
+import "./chunk-VJWL6YS5.js";
+import {
+  codewikiPath,
+  readCodewiki
+} from "./chunk-LBMZMYH2.js";
+import "./chunk-EKMEHE4H.js";
+import "./chunk-IKCO5N3L.js";
+import "./chunk-3I7MS7N2.js";
+import "./chunk-4ZG3XFUR.js";
+import "./chunk-APJ265NV.js";
+import "./chunk-FCSXB6T2.js";
+import "./chunk-YXLYO42X.js";
+import "./chunk-BNAZZHFG.js";
+import "./chunk-WEPFGWHJ.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/tools/codewiki/code-nav.ts
+init_esm_shims();
+import { existsSync, readFileSync } from "node:fs";
+import { join, normalize } from "node:path";
+
+// src/tools/codewiki/shared.ts
+init_esm_shims();
+import { statSync } from "node:fs";
+var CODEWIKI_ARTIFACT_CACHE_LIMIT = 4;
+var codewikiArtifactCache = /* @__PURE__ */ new Map();
+function codewikiArtifactIdentity(cwd) {
+  try {
+    const stats = statSync(codewikiPath(cwd), { bigint: true });
+    if (!stats.isFile()) return null;
+    return { dev: stats.dev, ino: stats.ino, mtimeNs: stats.mtimeNs, size: stats.size };
+  } catch {
+    return null;
+  }
+}
+function sameArtifactIdentity(a, b) {
+  return a.dev === b.dev && a.ino === b.ino && a.mtimeNs === b.mtimeNs && a.size === b.size;
+}
+function rememberCodewikiArtifact(cwd, identity, codewiki) {
+  const key = codewikiPath(cwd);
+  codewikiArtifactCache.delete(key);
+  codewikiArtifactCache.set(key, { identity, codewiki });
+  while (codewikiArtifactCache.size > CODEWIKI_ARTIFACT_CACHE_LIMIT) {
+    const oldest = codewikiArtifactCache.keys().next().value;
+    if (oldest === void 0) break;
+    codewikiArtifactCache.delete(oldest);
+  }
+}
+function readCodewikiForTool(cwd) {
+  const key = codewikiPath(cwd);
+  const identity = codewikiArtifactIdentity(cwd);
+  if (!identity) {
+    codewikiArtifactCache.delete(key);
+    return null;
+  }
+  const cached = codewikiArtifactCache.get(key);
+  if (cached && sameArtifactIdentity(cached.identity, identity)) {
+    rememberCodewikiArtifact(cwd, identity, cached.codewiki);
+    return cached.codewiki;
+  }
+  const codewiki = readCodewiki(cwd);
+  if (!codewiki) {
+    codewikiArtifactCache.delete(key);
+    return null;
+  }
+  rememberCodewikiArtifact(cwd, identity, codewiki);
+  return codewiki;
+}
+async function loadCodewikiForTool(cwd = process.cwd()) {
+  try {
+    const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const coordinated = await coordinateCodewikiWrite(
+      cwd,
+      (current, workspace) => {
+        const language = readClioState(workspace)?.projectType ?? current?.language;
+        return {
+          kind: "ensure",
+          cwd,
+          ...language ? { language } : {},
+          current,
+          previous: readClioState(workspace)?.fingerprint ?? null
+        };
+      },
+      {
+        readCurrent: (workspace) => readCodewikiForTool(workspace) ?? void 0,
+        afterCommit: ({ codewiki: committed, fingerprint, changed }, workspace) => {
+          const prev = readClioState(workspace);
+          if (!changed && prev) return;
+          writeClioState(workspace, {
+            version: 1,
+            projectType: prev?.projectType ?? committed.language,
+            fingerprint,
+            codewikiVersion: committed.version,
+            ...prev?.contextSources ? { contextSources: prev.contextSources } : {},
+            ...prev?.contextSourceHash ? { contextSourceHash: prev.contextSourceHash } : {},
+            ...prev?.lastBootstrap ? { lastBootstrap: prev.lastBootstrap } : {},
+            ...prev?.lastInitAt ? { lastInitAt: prev.lastInitAt } : {},
+            lastSessionAt: prev?.lastSessionAt ?? generatedAt,
+            lastIndexedAt: generatedAt
+          });
+        }
+      }
+    );
+    if (!coordinated) throw new Error("codewiki coordinator did not admit the demand build");
+    return { ok: true, codewiki: coordinated.codewiki };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { ok: false, message: `codewiki unavailable. run /context refresh to rebuild it. ${msg}` };
+  }
+}
+function renderJson(value) {
+  return JSON.stringify(value, null, 2);
+}
+
+// src/tools/codewiki/code-nav.ts
+var REGEX_SYNTAX_HINTS = /\.\*|\.\+|\^|\$|\\[dDwWsSbB]|\(\?:|\(\?=|\(\?!/;
+var navIndexCache = /* @__PURE__ */ new WeakMap();
+function regexFromPattern(pattern) {
+  if (pattern.startsWith("/") && pattern.lastIndexOf("/") > 0) {
+    const last = pattern.lastIndexOf("/");
+    const body = pattern.slice(1, last);
+    const flags = pattern.slice(last + 1).replace(/[gy]/g, "");
+    try {
+      return new RegExp(body, flags);
+    } catch {
+      return null;
+    }
+  }
+  if (REGEX_SYNTAX_HINTS.test(pattern)) {
+    try {
+      return new RegExp(pattern);
+    } catch {
+    }
+  }
+  if (/[*?[\]]/.test(pattern)) {
+    try {
+      return compileGlobRegex(pattern);
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+function readPackageEntryPaths(cwd) {
+  const out = /* @__PURE__ */ new Set();
+  const pkgPath = join(cwd, "package.json");
+  if (!existsSync(pkgPath)) return out;
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(pkgPath, "utf8"));
+  } catch {
+    return out;
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return out;
+  const pkg = parsed;
+  if (typeof pkg.main === "string") out.add(normalizeEntryPath(pkg.main));
+  if (typeof pkg.bin === "string") out.add(normalizeEntryPath(pkg.bin));
+  if (typeof pkg.bin === "object" && pkg.bin !== null && !Array.isArray(pkg.bin)) {
+    for (const value of Object.values(pkg.bin)) {
+      if (typeof value === "string") out.add(normalizeEntryPath(value));
+    }
+  }
+  return out;
+}
+function normalizeEntryPath(value) {
+  return normalize(value).split("\\").join("/").replace(/^\.\/+/, "");
+}
+function comparePath(a, b) {
+  return a.path.localeCompare(b.path);
+}
+function fileSummary(file) {
+  return {
+    id: file.id,
+    path: file.path,
+    lang: file.lang,
+    loc: file.loc,
+    role: file.role,
+    ...file.summary ? { summary: file.summary } : {}
+  };
+}
+function symbolSummary(symbol) {
+  return {
+    name: symbol.name,
+    kind: symbol.kind,
+    fileId: symbol.fileId,
+    line: symbol.line,
+    ...symbol.sig ? { sig: symbol.sig } : {}
+  };
+}
+function buildNavIndex(codewiki) {
+  const filesById = new Map(codewiki.files.map((file) => [file.id, file]));
+  const filesByPath = new Map(codewiki.files.map((file) => [file.path, file]));
+  const paths = codewiki.files.map((file) => file.path).sort((a, b) => a.localeCompare(b));
+  const symbolToFileIds = /* @__PURE__ */ new Map();
+  const symbolsByFileId = /* @__PURE__ */ new Map();
+  for (const symbol of codewiki.symbols) {
+    const fileIds = symbolToFileIds.get(symbol.name) ?? [];
+    if (!fileIds.includes(symbol.fileId)) fileIds.push(symbol.fileId);
+    symbolToFileIds.set(symbol.name, fileIds);
+    const symbols = symbolsByFileId.get(symbol.fileId) ?? [];
+    symbols.push(symbol);
+    symbolsByFileId.set(symbol.fileId, symbols);
+  }
+  for (const [name, fileIds] of symbolToFileIds) {
+    symbolToFileIds.set(
+      name,
+      fileIds.sort((a, b) => a.localeCompare(b))
+    );
+  }
+  for (const [fileId, symbols] of symbolsByFileId) {
+    symbolsByFileId.set(
+      fileId,
+      symbols.sort((a, b) => a.line - b.line || a.name.localeCompare(b.name) || a.kind.localeCompare(b.kind))
+    );
+  }
+  const depsByFileId = /* @__PURE__ */ new Map();
+  const dependentsByFileId = /* @__PURE__ */ new Map();
+  for (const edge of codewiki.edges) {
+    const deps = depsByFileId.get(edge.fileId) ?? { internal: [], external: [] };
+    if ("toFileId" in edge) {
+      const target = filesById.get(edge.toFileId);
+      if (target && !deps.internal.includes(target.path)) deps.internal.push(target.path);
+      const importers = dependentsByFileId.get(edge.toFileId) ?? [];
+      const source = filesById.get(edge.fileId);
+      if (source && !importers.includes(source.path)) importers.push(source.path);
+      dependentsByFileId.set(edge.toFileId, importers);
+    } else if (!deps.external.includes(edge.externalModule)) {
+      deps.external.push(edge.externalModule);
+    }
+    depsByFileId.set(edge.fileId, deps);
+  }
+  for (const [fileId, deps] of depsByFileId) {
+    depsByFileId.set(fileId, {
+      internal: deps.internal.sort((a, b) => a.localeCompare(b)),
+      external: deps.external.sort((a, b) => a.localeCompare(b))
+    });
+  }
+  for (const [fileId, importers] of dependentsByFileId) {
+    dependentsByFileId.set(
+      fileId,
+      importers.sort((a, b) => a.localeCompare(b))
+    );
+  }
+  return { filesById, filesByPath, paths, symbolToFileIds, symbolsByFileId, depsByFileId, dependentsByFileId };
+}
+function navIndexFor(codewiki) {
+  const cached = navIndexCache.get(codewiki);
+  if (cached) return cached;
+  const index = buildNavIndex(codewiki);
+  navIndexCache.set(codewiki, index);
+  return index;
+}
+function runSymbol(index, query, limit) {
+  const ids = index.symbolToFileIds.get(query) ?? [];
+  const files = ids.map((id) => index.filesById.get(id)).filter((file) => Boolean(file));
+  const matched = [];
+  for (const file of files) {
+    for (const symbol of index.symbolsByFileId.get(file.id) ?? []) {
+      if (symbol.name === query) matched.push({ file, symbol });
+    }
+  }
+  matched.sort(
+    (a, b) => a.file.path.localeCompare(b.file.path) || a.symbol.line - b.symbol.line || a.symbol.kind.localeCompare(b.symbol.kind)
+  );
+  const shown = matched.slice(0, limit);
+  const omitted = matched.length - shown.length;
+  const symbols = shown.map(({ file, symbol }) => ({ ...symbolSummary(symbol), path: file.path }));
+  const next = matched.length === 0 ? `mode=path query=${query}` : omitted > 0 ? `limit=${limit * 2}` : void 0;
+  return {
+    payload: {
+      symbols,
+      files: files.sort(comparePath).slice(0, limit).map(fileSummary),
+      omitted,
+      ...next !== void 0 ? { next } : {}
+    },
+    shownCount: shown.length,
+    totalCount: matched.length,
+    ...next !== void 0 ? { next } : {}
+  };
+}
+function runPath(index, query, limit) {
+  const regex = regexFromPattern(query);
+  const matches = index.paths.filter((path) => regex ? regex.test(path) : path.includes(query)).map((path) => index.filesByPath.get(path)).filter((file) => Boolean(file));
+  const shown = matches.slice(0, limit);
+  const omitted = matches.length - shown.length;
+  const next = matches.length === 0 ? "mode=entries" : omitted > 0 ? `limit=${limit * 2}` : void 0;
+  return {
+    payload: { files: shown.map(fileSummary), omitted, ...next !== void 0 ? { next } : {} },
+    shownCount: shown.length,
+    totalCount: matches.length,
+    ...next !== void 0 ? { next } : {}
+  };
+}
+function runEntries(index, limit) {
+  const cwd = process.cwd();
+  const packageEntries = readPackageEntryPaths(cwd);
+  const candidates = [...index.filesByPath.values()].filter(
+    (file) => file.lang !== "config" && (file.role === "entry" || packageEntries.has(file.path))
+  );
+  const ranked = candidates.sort((a, b) => {
+    const aPkg = packageEntries.has(a.path) ? 0 : 1;
+    const bPkg = packageEntries.has(b.path) ? 0 : 1;
+    return aPkg === bPkg ? a.path.localeCompare(b.path) : aPkg - bPkg;
+  });
+  const shown = ranked.slice(0, limit);
+  const omitted = ranked.length - shown.length;
+  const next = ranked.length === 0 ? "mode=path query=src/" : omitted > 0 ? `limit=${limit * 2}` : void 0;
+  return {
+    payload: { files: shown.map(fileSummary), omitted, ...next !== void 0 ? { next } : {} },
+    shownCount: shown.length,
+    totalCount: ranked.length,
+    ...next !== void 0 ? { next } : {}
+  };
+}
+function resolveFile(index, query) {
+  const exact = index.filesByPath.get(query);
+  if (exact) return exact;
+  const matches = index.paths.filter((path) => path.includes(query));
+  if (matches.length === 1) {
+    const file = index.filesByPath.get(matches[0] ?? "");
+    if (file) return file;
+  }
+  if (matches.length > 1) {
+    const directoryPrefix = `${query.replace(/\/+$/u, "")}/`;
+    if (matches.every((path) => path.startsWith(directoryPrefix))) {
+      return {
+        error: `path '${query}' is a directory-like prefix, but deps/dependents/outline require one indexed file. Use mode=path query=${query} to list files, then pass an exact file path to this mode.`
+      };
+    }
+    return { error: `ambiguous path '${query}' matched ${matches.length} files; use an exact indexed path` };
+  }
+  return {
+    error: `path '${query}' is not an indexed file path. deps/dependents/outline take file paths; for a symbol name use mode=symbol query=${query}, or use grep/read on the workspace directly.`
+  };
+}
+function runOutline(index, query, limit) {
+  const file = resolveFile(index, query);
+  if ("error" in file) return { kind: "error", message: `code_nav: ${file.error}` };
+  const symbols = index.symbolsByFileId.get(file.id) ?? [];
+  const shown = symbols.slice(0, limit);
+  const omitted = symbols.length - shown.length;
+  const next = omitted > 0 ? `limit=${limit * 2}` : void 0;
+  return {
+    payload: {
+      file: fileSummary(file),
+      symbols: shown.map(symbolSummary),
+      omitted,
+      ...next !== void 0 ? { next } : {}
+    },
+    shownCount: shown.length,
+    totalCount: symbols.length,
+    ...next !== void 0 ? { next } : {}
+  };
+}
+function runDeps(index, query, limit) {
+  const file = resolveFile(index, query);
+  if ("error" in file) return { kind: "error", message: `code_nav: ${file.error}` };
+  const deps = index.depsByFileId.get(file.id) ?? { internal: [], external: [] };
+  const internal = deps.internal.slice(0, limit);
+  const external = deps.external.slice(0, limit);
+  const total = deps.internal.length + deps.external.length;
+  const shown = internal.length + external.length;
+  const omitted = total - shown;
+  const next = omitted > 0 ? `limit=${limit * 2}` : void 0;
+  return {
+    payload: {
+      file: fileSummary(file),
+      deps: { internal, external },
+      omitted,
+      ...next !== void 0 ? { next } : {}
+    },
+    shownCount: shown,
+    totalCount: total,
+    ...next !== void 0 ? { next } : {}
+  };
+}
+function runDependents(index, query, limit) {
+  const file = resolveFile(index, query);
+  if ("error" in file) return { kind: "error", message: `code_nav: ${file.error}` };
+  const dependents = index.dependentsByFileId.get(file.id) ?? [];
+  const shown = dependents.slice(0, limit);
+  const omitted = dependents.length - shown.length;
+  const next = omitted > 0 ? `limit=${limit * 2}` : void 0;
+  return {
+    payload: {
+      file: fileSummary(file),
+      dependents: shown,
+      omitted,
+      ...next !== void 0 ? { next } : {}
+    },
+    shownCount: shown.length,
+    totalCount: dependents.length,
+    ...next !== void 0 ? { next } : {}
+  };
+}
+var WIKI_UPDATE_COMMAND = "clio-coder context wiki --update";
+var WIKI_SUMMARY_MAX_CHARS = 240;
+function wikiPageId(path) {
+  return path.replace(/\.md$/i, "");
+}
+function wikiPageSummary(cwd, path) {
+  let text = "";
+  try {
+    text = readFileSync(join(cwd, ".clio-coder", "wiki", path), "utf8");
+  } catch {
+    return "Summary unavailable; read the page for details.";
+  }
+  const paragraphs = text.replace(/^#\s+.*$/m, "").split(/\r?\n\s*\r?\n/).map((paragraph) => paragraph.replace(/\s+/g, " ").trim()).filter((paragraph) => paragraph.length > 0 && !paragraph.startsWith("#"));
+  const summary = paragraphs[0] ?? "Read the page for details.";
+  return summary.length <= WIKI_SUMMARY_MAX_CHARS ? summary : `${summary.slice(0, WIKI_SUMMARY_MAX_CHARS - 1).trimEnd()}\u2026`;
+}
+function wikiPageCatalog(pages) {
+  return pages.map((page) => `${wikiPageId(page.path)} (${page.title})`).join(", ");
+}
+function resolveWikiPage(pages, query) {
+  const needle = query.toLocaleLowerCase();
+  const exact = pages.filter(
+    (page) => wikiPageId(page.path).toLocaleLowerCase() === needle || page.title.toLocaleLowerCase() === needle
+  );
+  const matches = exact.length > 0 ? exact : pages.filter(
+    (page) => wikiPageId(page.path).toLocaleLowerCase().includes(needle) || page.title.toLocaleLowerCase().includes(needle)
+  );
+  if (matches.length === 1 && matches[0]) return matches[0];
+  const catalog = wikiPageCatalog(pages) || "none";
+  if (matches.length === 0) {
+    return { kind: "error", message: `code_nav: no wiki page matches '${query}'; pages are: ${catalog}` };
+  }
+  return {
+    kind: "error",
+    message: `code_nav: wiki query '${query}' is ambiguous; matching pages are: ${wikiPageCatalog(matches)}`
+  };
+}
+function runWiki(cwd, query) {
+  const meta = readWikiMeta(cwd);
+  if (!meta) {
+    if (query.length > 0) {
+      return {
+        kind: "error",
+        message: `code_nav: no wiki page matches '${query}'; pages are: none; wiki generation is operator-only: run \`${WIKI_UPDATE_COMMAND}\``
+      };
+    }
+    return {
+      payload: {
+        pages: [],
+        staleness: { state: "absent" },
+        message: `no wiki exists; wiki generation is operator-only: run \`${WIKI_UPDATE_COMMAND}\``
+      },
+      shownCount: 0,
+      totalCount: 0
+    };
+  }
+  const onDiskPages = listWikiPages(cwd);
+  const pages = onDiskPages;
+  const staleness = wikiStaleness(cwd);
+  const messages = [];
+  if (staleness.state !== "fresh") {
+    messages.push(`Wiki pages may be outdated; wiki regeneration is operator-only: run \`${WIKI_UPDATE_COMMAND}\`.`);
+  }
+  const owed = wikiCompletenessFromMeta(meta)?.owed ?? 0;
+  if (owed > 0) {
+    messages.push(
+      `${owed} planned page${owed === 1 ? " is" : "s are"} not written yet; run \`${WIKI_UPDATE_COMMAND}\` to finish them.`
+    );
+  }
+  if (query.length > 0) {
+    const resolved = resolveWikiPage(onDiskPages, query);
+    if ("kind" in resolved) {
+      return staleness.state === "fresh" ? resolved : { ...resolved, message: `${resolved.message}; ${messages[0]}` };
+    }
+    return {
+      payload: {
+        page: {
+          id: wikiPageId(resolved.path),
+          title: resolved.title,
+          summary: wikiPageSummary(cwd, resolved.path),
+          path: `.clio-coder/wiki/${resolved.path}`
+        },
+        staleness,
+        ...messages.length > 0 ? { message: messages.join(" ") } : {}
+      },
+      shownCount: 1,
+      totalCount: 1
+    };
+  }
+  return {
+    payload: {
+      pages,
+      staleness,
+      ...messages.length > 0 ? { message: messages.join(" ") } : {}
+    },
+    shownCount: pages.length,
+    totalCount: pages.length
+  };
+}
+function parseLimit(value, fallback) {
+  if (typeof value === "number" && Number.isFinite(value) && value > 0) return Math.min(Math.floor(value), CODE_NAV_MAX_LIMIT);
+  return fallback;
+}
+var codeNavTool = {
+  ...codeNavToolSurface,
+  async run(args, options) {
+    const mode = typeof args.mode === "string" ? args.mode : "";
+    const loaded = await loadCodewikiForTool();
+    if (!loaded.ok) return { kind: "error", message: loaded.message };
+    const index = navIndexFor(loaded.codewiki);
+    const query = typeof args.query === "string" ? args.query.trim() : "";
+    const limit = parseLimit(args.limit, mode === "entries" ? CODE_NAV_DEFAULT_ENTRY_LIMIT : CODE_NAV_DEFAULT_LIMIT);
+    const reservation = reserveObservation(OBSERVE_SELF_CAPS.codeNav, options);
+    if (reservation.exhausted) {
+      return observationBudgetExhausted({
+        tool: ToolNames.CodeNav,
+        unit: "results",
+        reservation,
+        subject: `mode=${mode}`,
+        hint: "Use a lower limit or continue in a follow-up turn."
+      });
+    }
+    const close = (nav) => {
+      if ("kind" in nav) return nav;
+      return finalizeObservation({
+        tool: ToolNames.CodeNav,
+        unit: "results",
+        format: "json",
+        output: renderJson(nav.payload),
+        shownCount: nav.shownCount,
+        totalCount: nav.totalCount,
+        truncated: nav.shownCount < nav.totalCount,
+        ...nav.next !== void 0 ? { next: nav.next } : {},
+        reservation,
+        ...options ? { options } : {}
+      });
+    };
+    if (mode === "symbol") {
+      if (query.length === 0) return { kind: "error", message: "code_nav: mode=symbol requires query" };
+      return close(runSymbol(index, query, limit));
+    }
+    if (mode === "path") {
+      if (query.length === 0) return { kind: "error", message: "code_nav: mode=path requires query" };
+      return close(runPath(index, query, limit));
+    }
+    if (mode === "entries") return close(runEntries(index, limit));
+    if (mode === "outline") {
+      if (query.length === 0) return { kind: "error", message: "code_nav: mode=outline requires query path" };
+      return close(runOutline(index, query, limit));
+    }
+    if (mode === "deps") {
+      if (query.length === 0) return { kind: "error", message: "code_nav: mode=deps requires query path" };
+      return close(runDeps(index, query, limit));
+    }
+    if (mode === "dependents") {
+      if (query.length === 0) return { kind: "error", message: "code_nav: mode=dependents requires query path" };
+      return close(runDependents(index, query, limit));
+    }
+    if (mode === "wiki") return close(runWiki(process.cwd(), query));
+    return {
+      kind: "error",
+      message: `code_nav: mode must be symbol, path, entries, outline, deps, dependents, or wiki; got '${mode}'`
+    };
+  }
+};
+export {
+  codeNavTool
+};
+//# sourceMappingURL=code-nav-7AX6FYE6.js.map

package/dist/codewiki/build-worker.js

@@ -0,0 +1,66 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  buildCodewiki,
+  syncCodewiki,
+  updateCodewikiPaths
+} from "../chunk-POHLU5DW.js";
+import {
+  detectProjectType
+} from "../chunk-YHZX5GEU.js";
+import {
+  computeFingerprint,
+  isStale
+} from "../chunk-VJWL6YS5.js";
+import {
+  codewikiNeedsBackfill
+} from "../chunk-LBMZMYH2.js";
+import "../chunk-EKMEHE4H.js";
+import "../chunk-WEPFGWHJ.js";
+import "../chunk-7CR24IG7.js";
+import {
+  init_esm_shims
+} from "../chunk-3R73A4XB.js";
+
+// src/domains/context/codewiki/build-worker.ts
+init_esm_shims();
+import { parentPort, workerData } from "node:worker_threads";
+async function execute(request) {
+  if (request.kind === "build") {
+    const codewiki2 = await buildCodewiki({ cwd: request.cwd, language: request.language });
+    return { codewiki: codewiki2, fingerprint: computeFingerprint(request.cwd, codewiki2), changed: true };
+  }
+  if (request.kind === "incremental") {
+    const codewiki2 = await updateCodewikiPaths(request.cwd, request.current, request.paths);
+    return {
+      codewiki: codewiki2,
+      fingerprint: computeFingerprint(request.cwd, codewiki2),
+      changed: codewiki2 !== request.current
+    };
+  }
+  if (request.current && !codewikiNeedsBackfill(request.current)) {
+    const currentFingerprint = computeFingerprint(request.cwd, request.current);
+    if (request.previous && !isStale(request.previous, currentFingerprint)) {
+      return { codewiki: request.current, fingerprint: currentFingerprint, changed: false };
+    }
+  }
+  const codewiki = request.current ? await syncCodewiki(request.cwd, request.current) : await buildCodewiki({ cwd: request.cwd, language: request.language ?? detectProjectType(request.cwd) });
+  return { codewiki, fingerprint: computeFingerprint(request.cwd, codewiki), changed: true };
+}
+var port = parentPort;
+if (!port) throw new Error("codewiki build worker requires a worker_threads parent");
+execute(workerData).then(
+  (result) => {
+    port.postMessage({ ok: true, result });
+    port.close();
+  },
+  (error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    port.postMessage({
+      ok: false,
+      error: message,
+      ...error instanceof Error && error.stack ? { stack: error.stack } : {}
+    });
+    port.close();
+  }
+);
+//# sourceMappingURL=build-worker.js.map

package/dist/compile-cache-CVJMMODC.js

@@ -0,0 +1,18 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  INJECTED_COMPILE_CACHE_ENV,
+  createCompileCache,
+  deleteInjectedCompileCacheFrom,
+  enableClioCompileCache,
+  workerCompileCacheEnvironment
+} from "./chunk-I4HZDVNP.js";
+import "./chunk-BNAZZHFG.js";
+import "./chunk-3R73A4XB.js";
+export {
+  INJECTED_COMPILE_CACHE_ENV,
+  createCompileCache,
+  deleteInjectedCompileCacheFrom,
+  enableClioCompileCache,
+  workerCompileCacheEnvironment
+};
+//# sourceMappingURL=compile-cache-CVJMMODC.js.map