@iowarp/clio-coder 0.3.1 → 0.3.3

package/dist/chunk-VJWL6YS5.js

@@ -0,0 +1,244 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  readCodewiki,
+  readCodewikiAsync
+} from "./chunk-LBMZMYH2.js";
+import {
+  WORKSPACE_EXCLUDED_DIRS,
+  enumerateWorkspaceFiles,
+  enumerateWorkspaceFilesAsync
+} from "./chunk-EKMEHE4H.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/context/codewiki/cooperative.ts
+init_esm_shims();
+import { setImmediate as yieldToEventLoop } from "node:timers/promises";
+var INDEX_SLICE_MS = 8;
+var settled = Promise.resolve();
+function createSlicer(sliceMs = INDEX_SLICE_MS) {
+  let deadline = performance.now() + sliceMs;
+  let yields = 0;
+  return {
+    tick() {
+      if (performance.now() < deadline) return settled;
+      yields += 1;
+      return yieldToEventLoop().then(() => {
+        deadline = performance.now() + sliceMs;
+      });
+    },
+    get yields() {
+      return yields;
+    }
+  };
+}
+
+// src/domains/context/fingerprint.ts
+init_esm_shims();
+import { execFile, execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { readFileSync, statSync } 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(filePath) {
+  try {
+    const text = readFileSync(filePath, "utf8");
+    if (text.length === 0) return 0;
+    let lines = 1;
+    for (const ch of text) {
+      if (ch === "\n") lines += 1;
+    }
+    return lines;
+  } catch {
+    return 0;
+  }
+}
+function locFromCodewiki(codewiki) {
+  if (!codewiki) return null;
+  return codewiki.files.reduce((sum, file) => file.lang === "config" ? sum : sum + file.loc, 0);
+}
+function accumulateFile(cwd, relPath, hash, artifactLoc) {
+  const absPath = join(cwd, relPath);
+  let stat;
+  try {
+    stat = statSync(absPath);
+  } catch {
+    return 0;
+  }
+  hash.update(`${relPath}:${stat.size}:${Math.floor(stat.mtimeMs)}
+`);
+  if (artifactLoc === null && LOC_EXTENSIONS.has(extensionOf2(relPath))) return countLines(absPath);
+  return 0;
+}
+function computeFingerprint(cwd, codewiki = readCodewiki(cwd)) {
+  const files = enumerateWorkspaceFiles(cwd, WORKSPACE_EXCLUDED_DIRS).filter(isIndexablePath);
+  const hash = createHash("sha256");
+  const 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 = createHash("sha256");
+  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);
+  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;
+}
+
+export {
+  INDEX_SLICE_MS,
+  createSlicer,
+  languageForPath,
+  isIndexablePath,
+  computeFingerprint,
+  computeFingerprintAsync,
+  computeFingerprintCached,
+  isStale
+};
+//# sourceMappingURL=chunk-VJWL6YS5.js.map

package/dist/{chunk-EYOKLTMF.js → chunk-VPAYEGVX.js}

@@ -1,7 +1,15 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  gitCommitAttributionEnabled,
+  reportCommitAttributionDiagnostic,
+  withManagedGitCommitAttributionEnvironment
+} from "./chunk-COU2UHX6.js";
 import {
   clampTimerDelayMs
-} from "./chunk-KY56HMHH.js";
+} from "./chunk-FQ4SKYE4.js";
+import {
+  AI_AGENT_NAME
+} from "./chunk-6EJMN2Y3.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -36,6 +44,7 @@ function buildSafeToolEnv(extra = {}) {
     if (!/^[A-Z_][A-Z0-9_]*$/i.test(key)) continue;
     env[key] = value;
   }
+  env.AI_AGENT = AI_AGENT_NAME;
   return env;
 }
 function resolveSafeCwd(cwd, workspaceRoot = process.cwd()) {
@@ -51,6 +60,11 @@ function runCommandVector(file, args, options = {}) {
     const cwd = resolveSafeCwd(options.cwd, options.workspaceRoot);
     const timeoutMs = clampTimerDelayMs(options.timeoutMs ?? SAFE_EXEC_DEFAULT_TIMEOUT_MS);
     const maxOutputBytes = options.maxOutputBytes ?? SAFE_EXEC_DEFAULT_MAX_OUTPUT_BYTES;
+    const attribution = withManagedGitCommitAttributionEnvironment(buildSafeToolEnv(options.env), {
+      cwd,
+      enabled: gitCommitAttributionEnabled(process.env)
+    });
+    reportCommitAttributionDiagnostic(attribution.diagnostic);
     let aborted = false;
     let timedOut = false;
     let outputCapped = false;
@@ -63,7 +77,7 @@ function runCommandVector(file, args, options = {}) {
     let killGraceTimer = null;
     const child = spawn(file, [...args], {
       cwd,
-      env: buildSafeToolEnv(options.env),
+      env: attribution.env,
       detached: process.platform !== "win32",
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -167,4 +181,4 @@ export {
   runCommandVector,
   combineSafeOutput
 };
-//# sourceMappingURL=chunk-EYOKLTMF.js.map
+//# sourceMappingURL=chunk-VPAYEGVX.js.map

package/dist/chunk-WEH5XRJQ.js

@@ -0,0 +1,32 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  typebox_exports
+} from "./chunk-5B2AEOW5.js";
+import {
+  ToolNames
+} from "./chunk-CGKSTWHD.js";
+import {
+  StringEnum
+} from "./chunk-FCSXB6T2.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/tools/steer-surface.ts
+init_esm_shims();
+var steerToolSurface = {
+  name: ToolNames.Steer,
+  description: "Control a running native worker whose run id is already available. Parent-model mid-run control requires detach:true because ordinary dispatch auto-waits and dispatch/steer are sequential; the interactive operator/TUI may steer an active synchronous native run through the dispatch contract. ACP runs have no input channel.",
+  parameters: typebox_exports.Object({
+    run_id: typebox_exports.String({ description: "Run id from dispatch output or monitor list." }),
+    action: StringEnum(["guide", "cancel"], { description: "What to do." }),
+    message: typebox_exports.Optional(typebox_exports.String({ description: "action=guide: the steering message." }))
+  }),
+  baseActionClass: "dispatch",
+  executionMode: "sequential"
+};
+
+export {
+  steerToolSurface
+};
+//# sourceMappingURL=chunk-WEH5XRJQ.js.map