@iowarp/clio-coder 0.4.9 → 0.5.0

package/dist/code-nav-4X3OI6DK.js

@@ -0,0 +1,715 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  readWikiMeta,
+  wikiCompletenessFromMeta,
+  wikiStaleness
+} from "./chunk-YQ3GFEUY.js";
+import {
+  readClioState,
+  writeClioState
+} from "./chunk-WTQGRBHV.js";
+import {
+  coordinateCodewikiWrite,
+  reconcileCodewikiCandidate
+} from "./chunk-GLIQT7SU.js";
+import {
+  listWikiPages,
+  readWikiPage
+} from "./chunk-BHJMMCXS.js";
+import {
+  CODE_NAV_DEFAULT_ENTRY_LIMIT,
+  CODE_NAV_DEFAULT_LIMIT,
+  CODE_NAV_MAX_LIMIT,
+  codeNavToolSurface
+} from "./chunk-UJD5MPP6.js";
+import {
+  compileGlobRegex
+} from "./chunk-DZLR4UEH.js";
+import {
+  OBSERVE_SELF_CAPS,
+  finalizeObservation,
+  observationBudgetExhausted,
+  reserveObservation
+} from "./chunk-OPD7GL6F.js";
+import "./chunk-733ZBT5P.js";
+import "./chunk-GHXGMFQ5.js";
+import "./chunk-KECNXMDE.js";
+import "./chunk-WXA2CFJO.js";
+import "./chunk-6CTHLZFB.js";
+import "./chunk-2KUBKL63.js";
+import "./chunk-MYI32N4R.js";
+import "./chunk-X6FLVUM5.js";
+import "./chunk-L7G7K4I2.js";
+import "./chunk-ALJWT6O6.js";
+import "./chunk-O3VV6IVK.js";
+import "./chunk-5EQO5NWP.js";
+import "./chunk-VYRQHORQ.js";
+import "./chunk-P4GNZPXO.js";
+import "./chunk-R2P2U3ZS.js";
+import "./chunk-NTTS3O53.js";
+import "./chunk-C2CPOIH2.js";
+import "./chunk-MGLRTOCK.js";
+import "./chunk-M4KFUXS7.js";
+import {
+  ToolNames
+} from "./chunk-V4XJWDHR.js";
+import "./chunk-C27U2TYG.js";
+import "./chunk-B5GGDIHT.js";
+import "./chunk-M2IPMWCN.js";
+import "./chunk-XS2QPZJE.js";
+import "./chunk-6EXUUOSN.js";
+import "./chunk-ZTNFYMIO.js";
+import "./chunk-DVJL77SO.js";
+import "./chunk-GH5ZR6JP.js";
+import "./chunk-TK2BMCBZ.js";
+import "./chunk-CTTI7G3T.js";
+import "./chunk-KPRLAMP4.js";
+import {
+  codewikiPath,
+  parseCodewikiRaw,
+  readCodewiki
+} from "./chunk-W2RJEH6Q.js";
+import "./chunk-PPEZJWUG.js";
+import "./chunk-ZZFWWYLX.js";
+import {
+  resolvePackageRoot
+} from "./chunk-ZPST2KQO.js";
+import "./chunk-FD2I4KBR.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/tools/codewiki/code-nav.ts
+init_esm_shims();
+import { existsSync, readFileSync } from "node:fs";
+import { isAbsolute, join, normalize, relative, resolve as resolve2 } from "node:path";
+
+// src/tools/codewiki/shared.ts
+init_esm_shims();
+import { statSync } from "node:fs";
+import { resolve } from "node:path";
+var CODEWIKI_ARTIFACT_CACHE_LIMIT = 4;
+var transientCodewikis = /* @__PURE__ */ new Map();
+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(), options = {}) {
+  try {
+    if (options.readOnly) {
+      const workspace = resolve(cwd);
+      const identity = codewikiArtifactIdentity(workspace);
+      const cached = transientCodewikis.get(workspace);
+      const sameDisk = cached && (identity === null ? cached.identity === null : cached.identity !== null && sameArtifactIdentity(identity, cached.identity));
+      const state = readClioState(workspace);
+      const current = sameDisk ? cached.codewiki : readCodewikiForTool(workspace);
+      const language = state?.projectType ?? current?.language;
+      const result = await reconcileCodewikiCandidate({
+        kind: "ensure",
+        cwd: workspace,
+        current,
+        previous: sameDisk ? cached.fingerprint : state?.fingerprint ?? null,
+        ...language ? { language } : {}
+      });
+      transientCodewikis.delete(workspace);
+      transientCodewikis.set(workspace, { codewiki: result.codewiki, fingerprint: result.fingerprint, identity });
+      while (transientCodewikis.size > CODEWIKI_ARTIFACT_CACHE_LIMIT) {
+        const oldest = transientCodewikis.keys().next().value;
+        if (oldest !== void 0) transientCodewikis.delete(oldest);
+      }
+      return { ok: true, codewiki: result.codewiki };
+    }
+    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 CLIO_CODEWIKI_RELATIVE_PATH = join("dist", "assets", "codewiki.json");
+var navIndexCache = /* @__PURE__ */ new WeakMap();
+var clioCodewikiCache = null;
+function packageRootResolvedPath(packageRoot, indexedPath) {
+  const resolved = resolve2(packageRoot, indexedPath);
+  const rel = relative(packageRoot, resolved);
+  if (rel.length === 0 || rel === ".." || rel.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`) || isAbsolute(rel)) {
+    throw new Error(`invalid package-root-relative path in bundled code map: ${indexedPath}`);
+  }
+  return resolved;
+}
+function packageRootResolvedCodewiki(packageRoot, codewiki) {
+  return {
+    ...codewiki,
+    files: codewiki.files.map((file) => ({
+      ...file,
+      path: packageRootResolvedPath(packageRoot, file.path)
+    }))
+  };
+}
+function loadClioCodewikiForTool() {
+  try {
+    const packageRoot = resolvePackageRoot();
+    if (clioCodewikiCache?.packageRoot === packageRoot) {
+      return { ok: true, loaded: { codewiki: clioCodewikiCache.codewiki, entryRoot: packageRoot } };
+    }
+    const artifactPath = join(packageRoot, CLIO_CODEWIKI_RELATIVE_PATH);
+    const parsed = parseCodewikiRaw(readFileSync(artifactPath, "utf8"));
+    if (!parsed) throw new Error("bundled artifact is not a valid codewiki");
+    const codewiki = packageRootResolvedCodewiki(packageRoot, parsed);
+    clioCodewikiCache = { packageRoot, codewiki };
+    return { ok: true, loaded: { codewiki, entryRoot: packageRoot } };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      ok: false,
+      message: `code_nav: bundled Clio code map unavailable at ${CLIO_CODEWIKI_RELATIVE_PATH}: ${message}`
+    };
+  }
+}
+async function loadNavSource(source) {
+  if (source === "clio") return loadClioCodewikiForTool();
+  const loaded = await loadCodewikiForTool(process.cwd(), { readOnly: true });
+  return loaded.ok ? { ok: true, loaded: { codewiki: loaded.codewiki, entryRoot: null } } : { ok: false, message: loaded.message };
+}
+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, resolveFromRoot) {
+  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;
+  const add = (value) => {
+    const normalized = normalizeEntryPath(value);
+    out.add(resolveFromRoot ? packageRootResolvedPath(cwd, normalized) : normalized);
+  };
+  if (typeof pkg.main === "string") add(pkg.main);
+  if (typeof pkg.bin === "string") add(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") add(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, entryRoot) {
+  const cwd = entryRoot ?? process.cwd();
+  const packageEntries = readPackageEntryPaths(cwd, entryRoot !== null);
+  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";
+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.";
+  }
+  return readWikiPage({ pagePath: path, content: text, sourceRoot: cwd }).metadata.summary || "Read the page for details.";
+}
+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 rawSource = args.source;
+    if (rawSource !== void 0 && rawSource !== "workspace" && rawSource !== "clio") {
+      return {
+        kind: "error",
+        message: `code_nav: source must be workspace or clio; got '${String(rawSource)}'`
+      };
+    }
+    const source = rawSource === "clio" ? "clio" : "workspace";
+    const mode = typeof args.mode === "string" ? args.mode : "";
+    if (source === "clio" && mode === "wiki") {
+      return {
+        kind: "error",
+        message: "code_nav: source=clio does not provide mode=wiki; use context scope=docs for Clio documentation"
+      };
+    }
+    const loaded = await loadNavSource(source);
+    if (!loaded.ok) return { kind: "error", message: loaded.message };
+    const index = navIndexFor(loaded.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;
+      const next = source === "clio" && nav.next !== void 0 ? `source=clio ${nav.next}` : nav.next;
+      const payload = next === nav.next ? nav.payload : { ...nav.payload, next };
+      return finalizeObservation({
+        tool: ToolNames.CodeNav,
+        unit: "results",
+        format: "json",
+        output: renderJson(payload),
+        shownCount: nav.shownCount,
+        totalCount: nav.totalCount,
+        truncated: nav.shownCount < nav.totalCount,
+        ...next !== void 0 ? { 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, loaded.loaded.entryRoot));
+    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-4X3OI6DK.js.map