@iowarp/clio-coder 0.3.0 → 0.3.2

package/dist/chunk-EKMEHE4H.js

@@ -0,0 +1,340 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/core/workspace-files.ts
+init_esm_shims();
+import { execFile, execFileSync } from "node:child_process";
+import fs from "node:fs";
+import { join, sep } from "node:path";
+import { performance } from "node:perf_hooks";
+var DEFAULT_YIELD_BUDGET_MS = 8;
+function createDefaultTick(budgetMs = DEFAULT_YIELD_BUDGET_MS) {
+  let sliceStart = performance.now();
+  return {
+    async tick() {
+      if (performance.now() - sliceStart < budgetMs) return;
+      await new Promise((resolve) => {
+        setImmediate(resolve);
+      });
+      sliceStart = performance.now();
+    }
+  };
+}
+var GIT_OUTPUT_LIMIT_BYTES = 128 * 1024 * 1024;
+var MAX_ENUMERATION_DIAGNOSTIC_PATH_CHARS = 200;
+var DEFAULT_WORKSPACE_FALLBACK_LIMITS = Object.freeze({
+  maxVisitedEntries: 1e5,
+  maxDepth: 64,
+  maxPathBytes: 64 * 1024 * 1024,
+  maxDurationMs: 5e3
+});
+var WorkspaceEnumerationLimitError = class extends Error {
+  constructor(kind, limit) {
+    super(`non-Git workspace enumeration exceeded ${kind} limit (${limit})`);
+    this.kind = kind;
+    this.limit = limit;
+    this.name = "WorkspaceEnumerationLimitError";
+  }
+  kind;
+  limit;
+  code = "WORKSPACE_ENUMERATION_LIMIT";
+};
+function boundedDiagnosticPath(path) {
+  const printable = Array.from(path.length > 0 ? path : ".", (character) => {
+    const codePoint = character.codePointAt(0) ?? 0;
+    return codePoint <= 31 || codePoint >= 127 && codePoint <= 159 ? "?" : character;
+  });
+  if (printable.length <= MAX_ENUMERATION_DIAGNOSTIC_PATH_CHARS) return printable.join("");
+  const side = Math.floor((MAX_ENUMERATION_DIAGNOSTIC_PATH_CHARS - 1) / 2);
+  return `${printable.slice(0, side).join("")}\u2026${printable.slice(-side).join("")}`;
+}
+function boundedSystemErrorCode(cause) {
+  if (typeof cause !== "object" || cause === null || !("code" in cause)) return "UNKNOWN";
+  const code = cause.code;
+  return typeof code === "string" && /^[A-Z][A-Z0-9_]{0,31}$/.test(code) ? code : "UNKNOWN";
+}
+var ENUMERATION_OPERATION_LABELS = Object.freeze({
+  "open-root": "open the workspace root",
+  "read-directory": "read a workspace directory",
+  "open-directory": "open a workspace directory",
+  "inspect-entry": "inspect a workspace entry"
+});
+var WorkspaceEnumerationIncompleteError = class extends Error {
+  code = "WORKSPACE_ENUMERATION_INCOMPLETE";
+  operation;
+  path;
+  causeCode;
+  constructor(operation, path, cause) {
+    const diagnosticPath = boundedDiagnosticPath(path);
+    const causeCode = boundedSystemErrorCode(cause);
+    super(
+      `non-Git workspace enumeration could not ${ENUMERATION_OPERATION_LABELS[operation]} at '${diagnosticPath}' (${causeCode})`
+    );
+    this.name = "WorkspaceEnumerationIncompleteError";
+    this.operation = operation;
+    this.path = diagnosticPath;
+    this.causeCode = causeCode;
+  }
+};
+var WORKSPACE_EXCLUDED_DIRS = /* @__PURE__ */ new Set([
+  ".git",
+  ".hg",
+  ".svn",
+  ".clio-coder",
+  "node_modules",
+  "dist",
+  "build",
+  "coverage",
+  ".venv",
+  "venv",
+  "__pycache__",
+  "target",
+  "vendor",
+  ".superpowers",
+  ".codex",
+  ".claude",
+  ".clio-coder-benchmark"
+]);
+function comparePaths(a, b) {
+  return a === b ? 0 : a < b ? -1 : 1;
+}
+function normalizeRelativePath(path) {
+  const posixPath = sep === "\\" ? path.replaceAll("\\", "/") : path;
+  const normalized = posixPath.replace(/^\.\//, "");
+  if (normalized.length === 0 || normalized.includes("\0") || normalized.startsWith("/")) return null;
+  if (/^[A-Za-z]:\//.test(normalized)) return null;
+  const segments = normalized.split("/");
+  if (segments.some((segment) => segment.length === 0 || segment === "." || segment === "..")) return null;
+  return segments.join("/");
+}
+function isWorkspacePathExcluded(relPath, excludedDirs = WORKSPACE_EXCLUDED_DIRS) {
+  return relPath.split("/").some((segment) => excludedDirs.has(segment));
+}
+function isDisappearedWorkspaceEntry(cause) {
+  if (typeof cause !== "object" || cause === null || !("code" in cause)) return false;
+  const code = cause.code;
+  return code === "ENOENT" || code === "ENOTDIR";
+}
+function isRegularWorkspaceFile(cwd, relPath, requireCompleteSnapshot) {
+  try {
+    const stat = fs.lstatSync(join(cwd, relPath));
+    if (stat.isFile()) return true;
+    if (requireCompleteSnapshot && stat.isDirectory()) {
+      throw new WorkspaceEnumerationIncompleteError("inspect-entry", relPath, { code: "ENTRY_TYPE_CHANGED" });
+    }
+    return false;
+  } catch (cause) {
+    if (cause instanceof WorkspaceEnumerationIncompleteError) throw cause;
+    if (requireCompleteSnapshot) {
+      if (isDisappearedWorkspaceEntry(cause)) return false;
+      throw new WorkspaceEnumerationIncompleteError("inspect-entry", relPath, cause);
+    }
+    return false;
+  }
+}
+function gitVisibleFilesArgs(candidates) {
+  const args = ["--literal-pathspecs", "ls-files", "-z", "--cached", "--others", "--exclude-standard"];
+  if (candidates) args.push("--", ...candidates);
+  return args;
+}
+function splitGitPathOutput(output) {
+  return output.split("\0").filter((path) => path.length > 0);
+}
+function gitVisibleFiles(cwd, candidates) {
+  let output;
+  try {
+    output = execFileSync("git", gitVisibleFilesArgs(candidates), {
+      cwd,
+      maxBuffer: GIT_OUTPUT_LIMIT_BYTES,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+  } catch {
+    return null;
+  }
+  return splitGitPathOutput(output.toString("utf8"));
+}
+function gitVisibleFilesAsync(cwd, candidates) {
+  return new Promise((resolve) => {
+    execFile("git", gitVisibleFilesArgs(candidates), { cwd, maxBuffer: GIT_OUTPUT_LIMIT_BYTES }, (error, stdout) => {
+      resolve(error ? null : splitGitPathOutput(stdout));
+    });
+  });
+}
+function resolveFallbackLimits(overrides) {
+  const limits = { ...DEFAULT_WORKSPACE_FALLBACK_LIMITS, ...overrides };
+  for (const [name, value] of Object.entries(limits)) {
+    if (!Number.isFinite(value) || value < 0 || !Number.isInteger(value)) {
+      throw new RangeError(`workspace fallback ${name} must be a non-negative integer`);
+    }
+  }
+  return limits;
+}
+function fallbackEntryKind(absPath, relPath, entry) {
+  if (!entry) return "disappeared";
+  if (entry.isDirectory()) return "directory";
+  if (entry.isFile()) return "file";
+  try {
+    const stat = fs.lstatSync(absPath);
+    if (stat.isDirectory()) return "directory";
+    if (stat.isFile()) return "file";
+    return "other";
+  } catch (cause) {
+    if (isDisappearedWorkspaceEntry(cause)) return "disappeared";
+    throw new WorkspaceEnumerationIncompleteError("inspect-entry", relPath, cause);
+  }
+}
+function closeFrame(frame) {
+  try {
+    frame.dir.closeSync();
+  } catch {
+  }
+}
+function* fallbackFilesWalk(cwd, excludedDirs, limits, elapsedMs) {
+  let visitedEntries = 0;
+  let pathBytes = 0;
+  let root;
+  try {
+    root = fs.opendirSync(cwd);
+  } catch (cause) {
+    throw new WorkspaceEnumerationIncompleteError("open-root", ".", cause);
+  }
+  const stack = [{ dir: root, absPath: cwd, prefix: "", depth: 0 }];
+  const files = [];
+  try {
+    while (stack.length > 0) {
+      yield;
+      if (elapsedMs() >= limits.maxDurationMs) {
+        throw new WorkspaceEnumerationLimitError("time", limits.maxDurationMs);
+      }
+      const frame = stack.at(-1);
+      if (!frame) break;
+      let entry;
+      try {
+        entry = frame.dir.readSync();
+      } catch (cause) {
+        throw new WorkspaceEnumerationIncompleteError("read-directory", frame.prefix || ".", cause);
+      }
+      if (!entry) {
+        closeFrame(frame);
+        stack.pop();
+        continue;
+      }
+      visitedEntries += 1;
+      if (visitedEntries > limits.maxVisitedEntries) {
+        throw new WorkspaceEnumerationLimitError("entries", limits.maxVisitedEntries);
+      }
+      const depth = frame.depth + 1;
+      if (depth > limits.maxDepth) {
+        throw new WorkspaceEnumerationLimitError("depth", limits.maxDepth);
+      }
+      const relPath = frame.prefix.length > 0 ? `${frame.prefix}/${entry.name}` : entry.name;
+      pathBytes += Buffer.byteLength(relPath, "utf8");
+      if (pathBytes > limits.maxPathBytes) {
+        throw new WorkspaceEnumerationLimitError("path-bytes", limits.maxPathBytes);
+      }
+      const absPath = join(frame.absPath, entry.name);
+      const kind = fallbackEntryKind(absPath, relPath, entry);
+      if (kind === "disappeared" || kind === "other") continue;
+      if (kind === "directory") {
+        if (excludedDirs.has(entry.name)) continue;
+        let child;
+        try {
+          child = fs.opendirSync(absPath);
+        } catch (cause) {
+          if (isDisappearedWorkspaceEntry(cause)) continue;
+          throw new WorkspaceEnumerationIncompleteError("open-directory", relPath, cause);
+        }
+        stack.push({ dir: child, absPath, prefix: relPath, depth });
+        continue;
+      }
+      files.push(relPath);
+    }
+    return files;
+  } finally {
+    for (const frame of stack) closeFrame(frame);
+  }
+}
+function fallbackFiles(cwd, excludedDirs, overrides) {
+  const limits = resolveFallbackLimits(overrides);
+  const startedAt = performance.now();
+  const walk = fallbackFilesWalk(cwd, excludedDirs, limits, () => performance.now() - startedAt);
+  let step = walk.next();
+  while (!step.done) step = walk.next();
+  return step.value;
+}
+async function fallbackFilesAsync(cwd, excludedDirs, overrides, cooperate) {
+  const limits = resolveFallbackLimits(overrides);
+  let activeMs = 0;
+  let resumedAt = performance.now();
+  const walk = fallbackFilesWalk(cwd, excludedDirs, limits, () => activeMs + (performance.now() - resumedAt));
+  let step = walk.next();
+  while (!step.done) {
+    activeMs += performance.now() - resumedAt;
+    await cooperate.tick();
+    resumedAt = performance.now();
+    step = walk.next();
+  }
+  return step.value;
+}
+function* normalizeVisibleFilesSteps(cwd, paths, excludedDirs, requireCompleteSnapshot) {
+  const visible = /* @__PURE__ */ new Set();
+  for (const path of paths) {
+    yield;
+    const normalized = normalizeRelativePath(path);
+    if (!normalized) {
+      if (requireCompleteSnapshot) {
+        throw new WorkspaceEnumerationIncompleteError("inspect-entry", path, { code: "INVALID_RELATIVE_PATH" });
+      }
+      continue;
+    }
+    if (isWorkspacePathExcluded(normalized, excludedDirs)) continue;
+    if (isRegularWorkspaceFile(cwd, normalized, requireCompleteSnapshot)) visible.add(normalized);
+  }
+  return [...visible].sort(comparePaths);
+}
+function normalizeVisibleFiles(cwd, paths, excludedDirs, requireCompleteSnapshot = false) {
+  const steps = normalizeVisibleFilesSteps(cwd, paths, excludedDirs, requireCompleteSnapshot);
+  let step = steps.next();
+  while (!step.done) step = steps.next();
+  return step.value;
+}
+async function normalizeVisibleFilesAsync(cwd, paths, excludedDirs, requireCompleteSnapshot, cooperate) {
+  const steps = normalizeVisibleFilesSteps(cwd, paths, excludedDirs, requireCompleteSnapshot);
+  let step = steps.next();
+  while (!step.done) {
+    await cooperate.tick();
+    step = steps.next();
+  }
+  return step.value;
+}
+function enumerateWorkspaceFiles(cwd, excludedDirs = WORKSPACE_EXCLUDED_DIRS, fallbackLimits) {
+  const gitFiles = gitVisibleFiles(cwd);
+  if (gitFiles) return normalizeVisibleFiles(cwd, gitFiles, excludedDirs);
+  return normalizeVisibleFiles(cwd, fallbackFiles(cwd, excludedDirs, fallbackLimits), excludedDirs, true);
+}
+async function enumerateWorkspaceFilesAsync(cwd, excludedDirs = WORKSPACE_EXCLUDED_DIRS, fallbackLimits, cooperate = createDefaultTick()) {
+  const gitFiles = await gitVisibleFilesAsync(cwd);
+  if (gitFiles) return normalizeVisibleFilesAsync(cwd, gitFiles, excludedDirs, false, cooperate);
+  const walked = await fallbackFilesAsync(cwd, excludedDirs, fallbackLimits, cooperate);
+  return normalizeVisibleFilesAsync(cwd, walked, excludedDirs, true, cooperate);
+}
+function filterWorkspaceFileCandidates(cwd, paths, excludedDirs = WORKSPACE_EXCLUDED_DIRS, fallbackLimits) {
+  const candidates = paths.map(normalizeRelativePath).filter((path) => path !== null && !isWorkspacePathExcluded(path, excludedDirs));
+  if (candidates.length === 0) return [];
+  const gitFiles = gitVisibleFiles(cwd, candidates);
+  if (gitFiles) return normalizeVisibleFiles(cwd, gitFiles, excludedDirs);
+  const fallbackVisible = new Set(
+    normalizeVisibleFiles(cwd, fallbackFiles(cwd, excludedDirs, fallbackLimits), excludedDirs, true)
+  );
+  return candidates.filter((path) => fallbackVisible.has(path)).sort(comparePaths);
+}
+
+export {
+  WORKSPACE_EXCLUDED_DIRS,
+  enumerateWorkspaceFiles,
+  enumerateWorkspaceFilesAsync,
+  filterWorkspaceFileCandidates
+};
+//# sourceMappingURL=chunk-EKMEHE4H.js.map

package/dist/{chunk-O4EJEDHO.js → chunk-EPVUXGXG.js}

@@ -1,40 +1,58 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   armInternalDispatchDeadline
-} from "./chunk-4UQA7NCT.js";
+} from "./chunk-J5Q24KAG.js";
 import {
   SchedulingDomainModule,
   createPromptsDomainModule
-} from "./chunk-3DANZDGR.js";
+} from "./chunk-LBNRH5WM.js";
 import {
   AgentsDomainModule,
   SafetyDomainModule
-} from "./chunk-JPOWPFCU.js";
+} from "./chunk-3ZXDFGR5.js";
 import {
   ConfigDomainModule,
   loadDomains
-} from "./chunk-527KG6XR.js";
+} from "./chunk-V4RXGQ5Q.js";
+import {
+  createObservabilityDomainModule
+} from "./chunk-WVO7V2QY.js";
 import {
   fallbackBootstrapOutput
-} from "./chunk-UWIJNAOB.js";
+} from "./chunk-7EYHLWU7.js";
 import {
   renderCodewikiDigest
-} from "./chunk-X3BR7HWV.js";
+} from "./chunk-5WIGXA4T.js";
 import {
   DispatchDomainModule,
-  MiddlewareDomainModule,
-  SessionDomainModule,
+  SessionDomainModule
+} from "./chunk-6EJV5X2W.js";
+import {
+  ResourcesDomainModule
+} from "./chunk-MFFY33HR.js";
+import {
+  MiddlewareDomainModule
+} from "./chunk-WMSVI4G2.js";
+import {
   UnsupportedResponseSchemaError,
-  createObservabilityDomainModule,
   isResponseSchemaRejection
-} from "./chunk-GNGDQYDU.js";
+} from "./chunk-MQSRRFWA.js";
 import {
-  ResourcesDomainModule
-} from "./chunk-2J63S4SF.js";
+  parseJsonObjectPayload
+} from "./chunk-STBPMHSX.js";
 import {
   ProvidersDomainModule
-} from "./chunk-TKHQ4DGZ.js";
+} from "./chunk-LZSJBIVT.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/cli/bootstrap-generate.ts
+init_esm_shims();
+import { performance } from "node:perf_hooks";
 
 // src/domains/context/bootstrap-prompt.ts
+init_esm_shims();
 var BOOTSTRAP_PROMPT = `You are the clio-coder bootstrap agent. Your job is to write the custom sections of CLIO-CODER.md for the project at <cwd>. CLIO-CODER.md is a lean, project-specific handbook that the clio-coder coding agent loads on every session, so write for an experienced engineer who has never seen this repository and is about to change it.
 
 Read the repository before you answer: start with code_nav (modes symbol, path, entries, outline, deps, dependents, wiki) against the index Clio just built, then read the specific files that decide behavior. Do not write files, run tests, or use external sources.
@@ -213,13 +231,9 @@ ${serialized}
 </bootstrap-input>`;
 }
 function extractJsonObject(text) {
-  const trimmed = text.trim();
-  if (trimmed.startsWith("{") && trimmed.endsWith("}")) return JSON.parse(trimmed);
-  const fenced = /```(?:json)?\s*([\s\S]*?)```/i.exec(trimmed)?.[1]?.trim();
-  if (fenced?.startsWith("{")) return JSON.parse(fenced);
-  const start = trimmed.indexOf("{");
-  const end = trimmed.lastIndexOf("}");
-  if (start >= 0 && end > start) return JSON.parse(trimmed.slice(start, end + 1));
+  const parsed = parseJsonObjectPayload(text);
+  if (parsed.ok) return parsed.value;
+  if (parsed.reason === "not-object") throw new Error("bootstrap model output must be a JSON object");
   throw new Error("bootstrap model output did not contain a JSON object");
 }
 function stringArray(value, key, maxItems, maxChars) {
@@ -258,11 +272,7 @@ function structuredSections(value) {
   }).filter((section) => section.title.length > 0 && section.body.length > 0).slice(0, 8);
 }
 function parseBootstrapModelOutput(text) {
-  const parsed = extractJsonObject(text);
-  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-    throw new Error("bootstrap model output must be a JSON object");
-  }
-  const record = parsed;
+  const record = extractJsonObject(text);
   return {
     projectName: stringField(record, "projectName", 80),
     identity: stringField(record, "identity", 600),
@@ -354,12 +364,12 @@ function durationFromReceipt(receipt) {
   if (!Number.isFinite(startedAt) || !Number.isFinite(endedAt)) return void 0;
   return Math.max(0, endedAt - startedAt);
 }
-function bootstrapTelemetry(prompt, output, startedAt, structuredOutputMode, runId, receipt, observedOutputBytes) {
+function bootstrapTelemetry(prompt, output, startedAtClock, structuredOutputMode, runId, receipt, observedOutputBytes) {
   const telemetry = {
     structuredOutputMode,
     promptBytes: Buffer.byteLength(prompt, "utf8"),
     outputBytes: observedOutputBytes ?? Buffer.byteLength(output, "utf8"),
-    durationMs: receipt ? durationFromReceipt(receipt) ?? Math.max(0, Date.now() - startedAt) : Math.max(0, Date.now() - startedAt),
+    durationMs: receipt ? durationFromReceipt(receipt) ?? Math.round(performance.now() - startedAtClock) : Math.round(performance.now() - startedAtClock),
     ...runId ? { runId } : {}
   };
   if (!receipt) return telemetry;
@@ -454,7 +464,7 @@ function responseSchemaRefusal(err) {
   if (err instanceof BootstrapAttemptError && isResponseSchemaRejection(err.message)) return err.message;
   return null;
 }
-async function attemptBootstrapDispatch(dispatch, input, prompt, startedAt, structuredOutputMode, dispatchBootstrap) {
+async function attemptBootstrapDispatch(dispatch, input, prompt, startedAtClock, structuredOutputMode, dispatchBootstrap) {
   const nativeSchema = structuredOutputMode === "native-schema";
   let handle;
   try {
@@ -462,7 +472,11 @@ async function attemptBootstrapDispatch(dispatch, input, prompt, startedAt, stru
   } catch (err) {
     if (nativeSchema && err instanceof UnsupportedResponseSchemaError) throw err;
     const error = err instanceof Error ? err : new Error(String(err));
-    throw new BootstrapAttemptError(error, "not-run", bootstrapTelemetry(prompt, "", startedAt, structuredOutputMode));
+    throw new BootstrapAttemptError(
+      error,
+      "not-run",
+      bootstrapTelemetry(prompt, "", startedAtClock, structuredOutputMode)
+    );
   }
   const deadline = armInternalDispatchDeadline(dispatch, handle.runId, "context bootstrap", process.env);
   let text = "";
@@ -485,7 +499,7 @@ async function attemptBootstrapDispatch(dispatch, input, prompt, startedAt, stru
     input.reportGeneration?.({
       mode: "model",
       parserOutcome: "parsed",
-      run: bootstrapTelemetry(prompt, text, startedAt, structuredOutputMode, handle.runId, receipt)
+      run: bootstrapTelemetry(prompt, text, startedAtClock, structuredOutputMode, handle.runId, receipt)
     });
     return output;
   } catch (err) {
@@ -498,7 +512,7 @@ async function attemptBootstrapDispatch(dispatch, input, prompt, startedAt, stru
       bootstrapTelemetry(
         prompt,
         text,
-        startedAt,
+        startedAtClock,
         structuredOutputMode,
         handle.runId,
         receipt,
@@ -511,7 +525,7 @@ async function attemptBootstrapDispatch(dispatch, input, prompt, startedAt, stru
 }
 async function generateBootstrapWithModel(dispatch, input, route) {
   const prompt = buildBootstrapPrompt(input);
-  const startedAt = Date.now();
+  const startedAtClock = performance.now();
   input.progress?.({
     phase: "generate",
     status: "running",
@@ -531,7 +545,7 @@ async function generateBootstrapWithModel(dispatch, input, route) {
     ...route?.model ? { model: route.model } : {}
   });
   try {
-    return await attemptBootstrapDispatch(dispatch, input, prompt, startedAt, "native-schema", dispatchBootstrap);
+    return await attemptBootstrapDispatch(dispatch, input, prompt, startedAtClock, "native-schema", dispatchBootstrap);
   } catch (err) {
     const refusal = responseSchemaRefusal(err);
     if (refusal === null) throw err;
@@ -541,7 +555,7 @@ async function generateBootstrapWithModel(dispatch, input, route) {
       message: "native schema unavailable; using bounded output parser",
       detail: refusal
     });
-    return await attemptBootstrapDispatch(dispatch, input, prompt, startedAt, "prompt-parser", dispatchBootstrap);
+    return await attemptBootstrapDispatch(dispatch, input, prompt, startedAtClock, "prompt-parser", dispatchBootstrap);
   }
 }
 async function loadBootstrapDispatch() {
@@ -610,6 +624,7 @@ function modelBootstrapGenerate(options = {}) {
 }
 
 // src/domains/context/init-options.ts
+init_esm_shims();
 var CONTEXT_INIT_FLAG_TABLE = [
   { flag: "--preview", field: "preview" },
   { flag: "--adopt", field: "adopt" },
@@ -656,4 +671,4 @@ export {
   validateInitOptions,
   bootstrapInputFromInitOptions
 };
-//# sourceMappingURL=chunk-O4EJEDHO.js.map
+//# sourceMappingURL=chunk-EPVUXGXG.js.map