@iowarp/clio-coder 0.3.1 → 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-RPTR2H26.js → chunk-EPVUXGXG.js}

@@ -1,42 +1,48 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   armInternalDispatchDeadline
-} from "./chunk-R5KLMSBV.js";
+} from "./chunk-J5Q24KAG.js";
 import {
   SchedulingDomainModule,
   createPromptsDomainModule
-} from "./chunk-G34LV2PF.js";
+} from "./chunk-LBNRH5WM.js";
 import {
   AgentsDomainModule,
   SafetyDomainModule
-} from "./chunk-MAR7Y6HW.js";
+} from "./chunk-3ZXDFGR5.js";
 import {
   ConfigDomainModule,
   loadDomains
-} from "./chunk-Q3RUPKEJ.js";
+} from "./chunk-V4RXGQ5Q.js";
+import {
+  createObservabilityDomainModule
+} from "./chunk-WVO7V2QY.js";
 import {
   fallbackBootstrapOutput
-} from "./chunk-M5T5VO65.js";
+} from "./chunk-7EYHLWU7.js";
 import {
   renderCodewikiDigest
 } from "./chunk-5WIGXA4T.js";
 import {
   DispatchDomainModule,
-  MiddlewareDomainModule,
-  SessionDomainModule,
-  UnsupportedResponseSchemaError,
-  createObservabilityDomainModule,
-  isResponseSchemaRejection
-} from "./chunk-7SS2CTV2.js";
+  SessionDomainModule
+} from "./chunk-6EJV5X2W.js";
 import {
   ResourcesDomainModule
-} from "./chunk-FST4FYJB.js";
+} from "./chunk-MFFY33HR.js";
+import {
+  MiddlewareDomainModule
+} from "./chunk-WMSVI4G2.js";
+import {
+  UnsupportedResponseSchemaError,
+  isResponseSchemaRejection
+} from "./chunk-MQSRRFWA.js";
 import {
   parseJsonObjectPayload
-} from "./chunk-GEP36Y4X.js";
+} from "./chunk-STBPMHSX.js";
 import {
   ProvidersDomainModule
-} from "./chunk-H6F6BYOH.js";
+} from "./chunk-LZSJBIVT.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -665,4 +671,4 @@ export {
   validateInitOptions,
   bootstrapInputFromInitOptions
 };
-//# sourceMappingURL=chunk-RPTR2H26.js.map
+//# sourceMappingURL=chunk-EPVUXGXG.js.map