@iowarp/clio-coder 0.4.4 → 0.4.6

package/dist/{chunk-25QBEXRS.js → chunk-VANN3GDP.js}

@@ -1,10 +1,10 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   combineBashOutput
-} from "./chunk-W54I7H25.js";
+} from "./chunk-5A6XR3RJ.js";
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/engine/tui.ts
 init_esm_shims();
@@ -946,7 +946,8 @@ function showClioOverlayFrame(tui, child, options) {
     // unchanged; the surface that gives the keyboard back to the composer
     // does it by hiding, which `setHidden` already reports.
     unfocus: (unfocusOptions) => unfocusOptions ? handle.unfocus(unfocusOptions) : handle.unfocus(),
-    isFocused: () => handle.isFocused()
+    isFocused: () => handle.isFocused(),
+    getBounds: () => handle.getBounds()
   };
 }
 function modalMarkerSink(tui) {
@@ -2025,29 +2026,9 @@ var CLIO_APP_KEYBINDINGS = {
     defaultKeys: "alt+k",
     description: "Cycle to previous scoped model"
   },
-  "clio-coder.tool.expand": {
+  "clio-coder.output.cycle": {
     defaultKeys: "alt+o",
-    description: "Fold or unfold the newest tool call or worker block between its one-line summary and full details, overriding the /output level for that block"
-  },
-  "clio-coder.tool.expandAll": {
-    // Alt+Shift+letter is commonly consumed by OS keyboard-layout switching.
-    // Keep it discoverable, but pair it with the legacy-safe Ctrl+Alt form.
-    defaultKeys: ["ctrl+alt+o", "alt+shift+o"],
-    description: "Fold or unfold every tool call and worker block at once, overriding the /output level; changing /output clears the overrides"
-  },
-  "clio-coder.tool.liveOutput": {
-    defaultKeys: "alt+p",
-    description: "Toggle streaming partial tool output in expanded tool bodies"
-  },
-  "clio-coder.thinking.expand": {
-    defaultKeys: "alt+r",
-    description: "Toggle the latest thinking block between hidden marker and full body (no effect while /output verbose pins it open)"
-  },
-  "clio-coder.thinking.expandAll": {
-    // Ctrl+Alt+R is the fallback for terminals/OSes that do not forward
-    // Alt+Shift+R as a distinct key event.
-    defaultKeys: ["ctrl+alt+r", "alt+shift+r"],
-    description: "Toggle all thinking blocks between hidden markers and full bodies, overriding the /output level; changing /output clears the overrides"
+    description: "Cycle output style: Compact, Standard, Detailed"
   },
   "clio-coder.editor.external": {
     defaultKeys: "alt+g",
@@ -2504,4 +2485,4 @@ export {
   formatPlatformKeybindingNotice,
   createKeybindingManager
 };
-//# sourceMappingURL=chunk-25QBEXRS.js.map
+//# sourceMappingURL=chunk-VANN3GDP.js.map

package/dist/{chunk-BWH6N36D.js → chunk-VHKTOLEW.js}

@@ -1,34 +1,225 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
-  createSlicer,
-  isIndexablePath,
-  languageForPath
-} from "./chunk-UUVG37B4.js";
+  createSlicer
+} from "./chunk-KPRLAMP4.js";
 import {
-  CODEWIKI_VERSION
-} from "./chunk-LBMZMYH2.js";
+  CODEWIKI_VERSION,
+  readCodewiki,
+  readCodewikiAsync
+} from "./chunk-W2RJEH6Q.js";
 import {
   WORKSPACE_EXCLUDED_DIRS,
+  enumerateWorkspaceFiles,
   enumerateWorkspaceFilesAsync,
   filterWorkspaceFileCandidates
-} from "./chunk-33YXPOE3.js";
+} from "./chunk-PPEZJWUG.js";
 import {
   classifyCHeaderLanguage,
   isAmbiguousHeaderPath
-} from "./chunk-7CR24IG7.js";
+} from "./chunk-WDV62RKY.js";
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
-// src/domains/context/codewiki/indexer.ts
+// src/domains/context/fingerprint.ts
 init_esm_shims();
+import { execFile, execFileSync } from "node:child_process";
 import { createHash } from "node:crypto";
-import { existsSync, readFileSync, statSync } from "node:fs";
-import { dirname, join, relative, resolve } from "node:path";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { promisify } from "node:util";
+
+// src/domains/context/codewiki/paths.ts
+init_esm_shims();
+
+// src/domains/context/excluded-dirs.ts
+init_esm_shims();
+
+// src/domains/context/codewiki/paths.ts
+var SOURCE_EXTENSIONS = /* @__PURE__ */ new Map([
+  [".ts", "typescript"],
+  [".tsx", "typescript"],
+  [".mts", "typescript"],
+  [".cts", "typescript"],
+  [".js", "javascript"],
+  [".jsx", "javascript"],
+  [".mjs", "javascript"],
+  [".cjs", "javascript"],
+  [".py", "python"],
+  [".pyw", "python"],
+  [".rs", "rust"],
+  [".go", "go"],
+  [".c", "c"],
+  [".h", "c"],
+  [".cc", "c++"],
+  [".cpp", "c++"],
+  [".cxx", "c++"],
+  [".hpp", "c++"],
+  [".hh", "c++"],
+  [".hxx", "c++"],
+  [".cu", "c++"],
+  [".cuh", "c++"],
+  [".java", "java"],
+  [".rb", "ruby"],
+  [".cs", "c#"]
+]);
+var CONFIG_FILE_NAMES = /* @__PURE__ */ new Set([
+  "package.json",
+  "pyproject.toml",
+  "setup.py",
+  "Cargo.toml",
+  "go.mod",
+  "pom.xml",
+  "CMakeLists.txt",
+  "compile_commands.json",
+  "Gemfile"
+]);
+function extensionOf(name) {
+  const index = name.lastIndexOf(".");
+  return index === -1 ? "" : name.slice(index);
+}
+function sourceLanguageForPath(relPath) {
+  if (relPath.endsWith(".d.ts")) return null;
+  return SOURCE_EXTENSIONS.get(extensionOf(relPath)) ?? null;
+}
+function languageForPath(relPath) {
+  const source = sourceLanguageForPath(relPath);
+  if (source) return source;
+  const name = relPath.split("/").pop() ?? relPath;
+  return CONFIG_FILE_NAMES.has(name) || name.endsWith(".csproj") || name.toLowerCase().endsWith(".cmake") ? "config" : null;
+}
+function isIndexablePath(relPath) {
+  if (relPath.split("/").some((segment) => WORKSPACE_EXCLUDED_DIRS.has(segment))) return false;
+  return languageForPath(relPath) !== null;
+}
+
+// src/domains/context/fingerprint.ts
+var execFileAsync = promisify(execFile);
+var DEFAULT_FINGERPRINT_CACHE_TTL_MS = 5e3;
+var cachedFingerprints = /* @__PURE__ */ new Map();
+var LOC_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".mjs",
+  ".cjs",
+  ".py",
+  ".rs",
+  ".go",
+  ".cc",
+  ".cpp",
+  ".cxx",
+  ".hpp",
+  ".hh",
+  ".hxx",
+  ".c",
+  ".h",
+  ".cu",
+  ".cuh",
+  ".java",
+  ".kt"
+]);
+function extensionOf2(name) {
+  const index = name.lastIndexOf(".");
+  return index === -1 ? "" : name.slice(index);
+}
+function currentGitHead(cwd) {
+  try {
+    return execFileSync("git", ["rev-parse", "--verify", "HEAD"], {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+async function currentGitHeadAsync(cwd) {
+  try {
+    const { stdout } = await execFileAsync("git", ["rev-parse", "--verify", "HEAD"], { cwd, encoding: "utf8" });
+    return stdout.trim();
+  } catch {
+    return null;
+  }
+}
+function countLines(text) {
+  if (text.length === 0) return 0;
+  let lines = 1;
+  for (const ch of text) {
+    if (ch === "\n") lines += 1;
+  }
+  return lines;
+}
+function locFromCodewiki(codewiki) {
+  if (!codewiki) return null;
+  return codewiki.files.reduce((sum, file) => file.lang === "config" ? sum : sum + file.loc, 0);
+}
+function createTreeHash() {
+  return createHash("sha256").update("clio-codewiki-tree:v3\n");
+}
+function accumulateFile(cwd, relPath, hash, artifactLoc) {
+  const contents = readFileSync(join(cwd, relPath));
+  const digest = createHash("sha256").update(contents).digest("hex");
+  hash.update(`${JSON.stringify(relPath)}:${digest}
+`);
+  if (artifactLoc === null && LOC_EXTENSIONS.has(extensionOf2(relPath))) return countLines(contents.toString("utf8"));
+  return 0;
+}
+function computeFingerprint(cwd, codewiki = readCodewiki(cwd), options = {}) {
+  const files = enumerateWorkspaceFiles(cwd, WORKSPACE_EXCLUDED_DIRS).filter(isIndexablePath);
+  const hash = createTreeHash();
+  const artifactLoc = options.artifactLoc ?? locFromCodewiki(codewiki);
+  let loc = 0;
+  for (const relPath of files) loc += accumulateFile(cwd, relPath, hash, artifactLoc);
+  return {
+    treeHash: hash.digest("hex"),
+    gitHead: currentGitHead(cwd),
+    loc: artifactLoc ?? loc
+  };
+}
+async function computeFingerprintAsync(cwd, codewiki = void 0, options = {}) {
+  const slicer = options.slicer ?? createSlicer();
+  const artifact = codewiki === void 0 ? await readCodewikiAsync(cwd) : codewiki;
+  await slicer.tick();
+  const files = (await enumerateWorkspaceFilesAsync(cwd, WORKSPACE_EXCLUDED_DIRS, void 0, slicer)).filter(isIndexablePath);
+  const hash = createTreeHash();
+  const artifactLoc = locFromCodewiki(artifact);
+  let loc = 0;
+  for (const relPath of files) {
+    await slicer.tick();
+    loc += accumulateFile(cwd, relPath, hash, artifactLoc);
+  }
+  return {
+    treeHash: hash.digest("hex"),
+    gitHead: await currentGitHeadAsync(cwd),
+    loc: artifactLoc ?? loc
+  };
+}
+function computeFingerprintCached(cwd, codewiki = readCodewiki(cwd), options = {}) {
+  const now = Date.now();
+  const cached = cachedFingerprints.get(cwd);
+  if (cached && cached.expiresAtMs > now) return cached.fingerprint;
+  const fingerprint = computeFingerprint(cwd, codewiki, options);
+  const ttlMs = options.ttlMs ?? DEFAULT_FINGERPRINT_CACHE_TTL_MS;
+  cachedFingerprints.set(cwd, {
+    fingerprint,
+    expiresAtMs: Date.now() + Math.max(0, ttlMs)
+  });
+  return fingerprint;
+}
+function isStale(prev, curr) {
+  return prev.treeHash !== curr.treeHash;
+}
+
+// src/domains/context/codewiki/indexer.ts
+init_esm_shims();
+import { createHash as createHash2 } from "node:crypto";
+import { existsSync, readFileSync as readFileSync2, statSync } from "node:fs";
+import { dirname, join as join2, relative, resolve } from "node:path";
 
 // src/domains/context/codewiki/cmake.ts
 init_esm_shims();
-var SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
+var SOURCE_EXTENSIONS2 = /* @__PURE__ */ new Set([
   ".c",
   ".cc",
   ".cpp",
@@ -280,7 +471,7 @@ function sourceSpecifier(value) {
   if (!path || path.includes(";") || path.startsWith("-") || TARGET_SOURCE_KEYWORDS.has(path.toUpperCase())) return null;
   const withoutQuery = path.split(/[?#]/, 1)[0] ?? path;
   const dot = withoutQuery.lastIndexOf(".");
-  if (dot === -1 || !SOURCE_EXTENSIONS.has(withoutQuery.slice(dot).toLowerCase())) return null;
+  if (dot === -1 || !SOURCE_EXTENSIONS2.has(withoutQuery.slice(dot).toLowerCase())) return null;
   return relativeSpecifier(path);
 }
 function childCMakeSpecifier(value) {
@@ -332,7 +523,7 @@ function extractCMake(text) {
 var CODEWIKI_SYMBOL_KINDS_WITH_SIG = /* @__PURE__ */ new Set(["func", "class", "method", "type"]);
 var treeSitterExtractorPromise = null;
 function loadTreeSitterExtractor() {
-  treeSitterExtractorPromise ??= import("./tree-sitter-HGKH6LG4.js").then(
+  treeSitterExtractorPromise ??= import("./tree-sitter-AQUUOSYM.js").then(
     ({ createTreeSitterExtractor }) => createTreeSitterExtractor()
   );
   return treeSitterExtractorPromise;
@@ -367,14 +558,14 @@ function compareStrings2(a, b) {
   return a.localeCompare(b);
 }
 function stableFileId(path) {
-  return `f_${createHash("sha256").update(path).digest("hex").slice(0, 16)}`;
+  return `f_${createHash2("sha256").update(path).digest("hex").slice(0, 16)}`;
 }
 function contentHash(text) {
-  return createHash("sha256").update(text).digest("hex").slice(0, 16);
+  return createHash2("sha256").update(text).digest("hex").slice(0, 16);
 }
 function defaultReadFile(path) {
   try {
-    return readFileSync(path, "utf8");
+    return readFileSync2(path, "utf8");
   } catch {
     return null;
   }
@@ -923,7 +1114,7 @@ function buildFile(cwd, relPath, treeSitterExtractor, readFile) {
   if (!pathLanguage) return null;
   let text;
   try {
-    text = readFile(join(cwd, relPath));
+    text = readFile(join2(cwd, relPath));
   } catch {
     return null;
   }
@@ -960,22 +1151,17 @@ function buildFile(cwd, relPath, treeSitterExtractor, readFile) {
   };
 }
 function candidatePathsForImport(cwd, fromRel, specifier) {
-  const fromDir = dirname(join(cwd, fromRel));
+  const fromDir = dirname(join2(cwd, fromRel));
   const cleaned = specifier.replace(/\\/g, "/");
   const base = cleaned.startsWith(".") || cleaned.startsWith("/") ? resolve(fromDir, cleaned) : "";
   if (!base) return [];
   const candidates = [base];
   for (const ext of RESOLUTION_EXTENSIONS) candidates.push(`${base}${ext}`);
-  for (const ext of RESOLUTION_EXTENSIONS) candidates.push(join(base, `index${ext}`));
+  for (const ext of RESOLUTION_EXTENSIONS) candidates.push(join2(base, `index${ext}`));
   if (cleaned.endsWith(".js")) {
     const stripped = base.replace(/\.js$/, "");
     for (const ext of [".ts", ".tsx", ".mts", ".cts"]) candidates.push(`${stripped}${ext}`);
   }
-  if (/^[.]+[A-Za-z_]/.test(cleaned)) {
-    const pythonModule = cleaned.replace(/^\.+/, "").replace(/\./g, "/");
-    const pythonBase = resolve(fromDir, pythonModule);
-    candidates.push(`${pythonBase}.py`, join(pythonBase, "__init__.py"));
-  }
   return uniqueSorted2(
     candidates.map((candidate) => normalizeRel(cwd, candidate)).filter((candidate) => !candidate.startsWith(".."))
   );
@@ -984,10 +1170,34 @@ function createImportResolver(cwd) {
   const candidatesByOrigin = /* @__PURE__ */ new Map();
   const onDisk = /* @__PURE__ */ new Map();
   const candidatesFor = (fromRel, specifier) => {
-    const key = `${dirname(fromRel)}\0${specifier}`;
+    const python = /\.pyw?$/.test(fromRel);
+    const key = `${python}\0${dirname(fromRel)}\0${specifier}`;
     let candidates = candidatesByOrigin.get(key);
     if (!candidates) {
-      candidates = candidatePathsForImport(cwd, fromRel, specifier);
+      if (python) {
+        const fromDir = dirname(fromRel);
+        let packageRoot = fromDir;
+        while (packageRoot !== "." && isFile(join2(packageRoot, "__init__.py"))) {
+          packageRoot = dirname(packageRoot);
+        }
+        const dots = /^\.+/.exec(specifier)?.[0].length ?? 0;
+        const modulePath = specifier.slice(dots).replace(/\./g, "/");
+        let bases;
+        if (dots > 0) {
+          const parent = resolve(cwd, fromDir, ...Array(dots - 1).fill(".."));
+          const root = resolve(cwd, packageRoot === fromDir ? "." : packageRoot);
+          const insidePackage = parent !== root || root === resolve(cwd) && isFile("__init__.py");
+          bases = insidePackage && !relative(root, parent).startsWith("..") ? [join2(parent, modulePath)] : [];
+        } else {
+          bases = [resolve(cwd, modulePath)];
+          if (packageRoot !== fromDir && packageRoot !== ".") bases.push(resolve(cwd, packageRoot, modulePath));
+        }
+        candidates = [...new Set(bases.flatMap((base) => [join2(base, "__init__.py"), `${base}.py`]))].map(
+          (candidate) => normalizeRel(cwd, candidate)
+        );
+      } else {
+        candidates = candidatePathsForImport(cwd, fromRel, specifier);
+      }
       candidatesByOrigin.set(key, candidates);
     }
     return candidates;
@@ -997,7 +1207,7 @@ function createImportResolver(cwd) {
     if (cached !== void 0) return cached;
     let exists;
     try {
-      exists = statSync(join(cwd, candidate)).isFile();
+      exists = statSync(join2(cwd, candidate)).isFile();
     } catch {
       exists = false;
     }
@@ -1102,30 +1312,42 @@ async function updateCodewikiPaths(cwd, codewiki, paths, options = {}) {
   if (normalizedPaths.some(
     (path) => path === ".gitignore" || path.endsWith("/.gitignore") || path === ".git/info/exclude" || path === ".git/index" || path === ".gitmodules"
   )) {
-    return buildCodewiki({ cwd, language: codewiki.language }, options);
+    return syncCodewiki(cwd, codewiki, options);
   }
   const slicer = options.slicer ?? createSlicer();
-  const existingPaths = new Set(codewiki.files.map((file) => file.path));
+  const existingFiles = new Map(codewiki.files.map((file) => [file.path, file]));
   const visiblePaths = new Set(filterWorkspaceFileCandidates(cwd, normalizedPaths, WORKSPACE_EXCLUDED_DIRS));
   const readFile = options.readFile ?? defaultReadFile;
-  const changedPathSet = new Set(normalizedPaths);
+  const currentTexts = /* @__PURE__ */ new Map();
+  const changedPathSet = /* @__PURE__ */ new Set();
   const rebuildPaths = [];
-  let hasIndexChange = false;
   for (const relPath of normalizedPaths) {
-    const wasIndexed = existingPaths.has(relPath);
+    const existing = existingFiles.get(relPath);
     const isCurrentIndexableFile = isIndexablePath(relPath) && visiblePaths.has(relPath);
-    if (!wasIndexed && !isCurrentIndexableFile) continue;
-    hasIndexChange = true;
-    if (isCurrentIndexableFile) rebuildPaths.push(relPath);
+    if (!existing && !isCurrentIndexableFile) continue;
+    if (isCurrentIndexableFile) {
+      const text = readFile(join2(cwd, relPath));
+      if (text !== null) {
+        if (existing?.hash === contentHash(text)) continue;
+        currentTexts.set(relPath, text);
+        rebuildPaths.push(relPath);
+      }
+    }
+    changedPathSet.add(relPath);
   }
-  if (!hasIndexChange) return codewiki;
+  if (changedPathSet.size === 0) return codewiki;
   const rebuiltFiles = [];
   if (rebuildPaths.length > 0) {
     const treeSitterExtractor = await loadTreeSitterExtractor();
     await treeSitterExtractor.ensureGrammarsForPaths(rebuildPaths);
     for (const relPath of rebuildPaths) {
       await slicer.tick();
-      const built = buildFile(cwd, relPath, treeSitterExtractor, readFile);
+      const built = buildFile(
+        cwd,
+        relPath,
+        treeSitterExtractor,
+        (path) => currentTexts.get(normalizeRel(cwd, path)) ?? null
+      );
       if (built) rebuiltFiles.push(built);
     }
   }
@@ -1150,7 +1372,7 @@ async function syncCodewiki(cwd, codewiki, options = {}) {
   const currentTexts = /* @__PURE__ */ new Map();
   for (const relPath of currentPaths) {
     await slicer.tick();
-    const text = readFile(join(cwd, relPath));
+    const text = readFile(join2(cwd, relPath));
     if (text !== null) {
       currentFiles.set(relPath, contentHash(text));
       currentTexts.set(relPath, text);
@@ -1164,7 +1386,11 @@ async function syncCodewiki(cwd, codewiki, options = {}) {
   for (const relPath of indexedFiles.keys()) {
     if (!currentFiles.has(relPath)) changedPaths.add(relPath);
   }
-  if (changedPaths.size === 0) return codewiki;
+  if (changedPaths.size === 0) {
+    if (!codewiki.files.some((file) => file.lang === "python")) return codewiki;
+    const edges = await buildEdges(cwd, codewiki.files, slicer);
+    return JSON.stringify(edges) === JSON.stringify(codewiki.edges) ? codewiki : { ...codewiki, edges };
+  }
   const syncOptions = {
     ...options,
     slicer,
@@ -1179,8 +1405,12 @@ function symbolSigFields(kind, sig) {
 }
 
 export {
+  computeFingerprint,
+  computeFingerprintAsync,
+  computeFingerprintCached,
+  isStale,
   buildCodewiki,
   updateCodewikiPaths,
   syncCodewiki
 };
-//# sourceMappingURL=chunk-BWH6N36D.js.map
+//# sourceMappingURL=chunk-VHKTOLEW.js.map