@iowarp/clio-coder 0.4.2 → 0.4.4

package/dist/chunk-RVG5JXAL.js

@@ -1,41 +0,0 @@
-import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
-import {
-  init_esm_shims
-} from "./chunk-3R73A4XB.js";
-
-// src/domains/safety/rigor.ts
-init_esm_shims();
-import { existsSync } from "node:fs";
-import path from "node:path";
-var VALIDATION_CONTRACT_FILES = [
-  path.join(".clio-coder", "validation.yaml"),
-  path.join(".clio-coder", "validation.yml"),
-  "validation.yaml",
-  "validation.yml",
-  "VALIDATION.md"
-];
-function resolveRigor(options) {
-  if (options.override === "high" || options.override === "normal") return options.override;
-  const cwd = options.cwd ?? process.cwd();
-  return hasValidationContract(cwd) ? "high" : "normal";
-}
-function parseRigorOverride(value) {
-  if (typeof value !== "string") return null;
-  const normalized = value.trim().toLowerCase();
-  if (normalized === "high") return "high";
-  if (normalized === "normal") return "normal";
-  return null;
-}
-function hasValidationContract(cwd) {
-  try {
-    return VALIDATION_CONTRACT_FILES.some((relative) => existsSync(path.join(cwd, relative)));
-  } catch {
-    return false;
-  }
-}
-
-export {
-  resolveRigor,
-  parseRigorOverride
-};
-//# sourceMappingURL=chunk-RVG5JXAL.js.map

package/dist/chunk-T56WDKA5.js

@@ -1,183 +0,0 @@
-import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
-import {
-  truncateUtf8
-} from "./chunk-6XLNIQDB.js";
-import {
-  init_esm_shims
-} from "./chunk-3R73A4XB.js";
-
-// src/domains/dispatch/event-pump.ts
-init_esm_shims();
-var EVENT_TEE_LIMIT = 1024;
-function startDispatchEventPump(source, fold, options = {}) {
-  const limit = options.limit ?? EVENT_TEE_LIMIT;
-  const pending = [...options.prelude ?? []];
-  const waiters = [];
-  let finished = false;
-  let abandoned = false;
-  let dropped = 0;
-  const push = (value) => {
-    if (abandoned) return;
-    const waiter = waiters.shift();
-    if (waiter) {
-      waiter({ value, done: false });
-      return;
-    }
-    pending.push(value);
-    while (pending.length > limit) {
-      pending.shift();
-      dropped += 1;
-    }
-  };
-  const end = () => {
-    finished = true;
-    while (waiters.length > 0) {
-      waiters.shift()?.({ value: void 0, done: true });
-    }
-  };
-  const notify = (event) => {
-    try {
-      options.onEvent?.(event);
-    } catch (error) {
-      options.onError?.(error);
-    }
-  };
-  const done = (async () => {
-    try {
-      for (const event of options.prelude ?? []) notify(event);
-      for await (const event of source) {
-        try {
-          fold(event);
-        } catch (error) {
-          options.onError?.(error);
-        }
-        notify(event);
-        push(event);
-      }
-    } catch (error) {
-      options.onError?.(error);
-    } finally {
-      end();
-    }
-  })();
-  const events = {
-    next() {
-      if (pending.length > 0) {
-        return Promise.resolve({ value: pending.shift(), done: false });
-      }
-      if (finished || abandoned) return Promise.resolve({ value: void 0, done: true });
-      return new Promise((resolve) => {
-        waiters.push(resolve);
-      });
-    },
-    return() {
-      abandoned = true;
-      pending.length = 0;
-      while (waiters.length > 0) {
-        waiters.shift()?.({ value: void 0, done: true });
-      }
-      return Promise.resolve({ value: void 0, done: true });
-    },
-    [Symbol.asyncIterator]() {
-      return this;
-    }
-  };
-  return { events, done, droppedEvents: () => dropped };
-}
-var WORKER_OUTPUT_MAX_BYTES = 8192;
-var WORKER_OUTPUT_TRUNCATION_MARKER = "\n[worker output truncated]";
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function assistantTextFromContent(content) {
-  if (typeof content === "string") return content;
-  if (!Array.isArray(content)) return "";
-  return content.map((block) => {
-    if (typeof block === "string") return block;
-    if (!isRecord(block)) return "";
-    return typeof block.text === "string" ? block.text : "";
-  }).join("");
-}
-function isDurableAssistantMessage(message) {
-  const stopReason = message.stopReason;
-  if (stopReason === "toolUse" || stopReason === "error" || stopReason === "aborted" || stopReason === "cancelled") {
-    return false;
-  }
-  if (!Array.isArray(message.content)) return true;
-  return !message.content.some((block) => isRecord(block) && block.type === "toolCall");
-}
-function durableAssistantTextFromEvent(event) {
-  if (!isRecord(event) || event.type !== "message_end" || !isRecord(event.message)) return "";
-  if (event.message.role !== "assistant" || !isDurableAssistantMessage(event.message)) return "";
-  return assistantTextFromContent(event.message.content);
-}
-function boundedOutput(state, text) {
-  const bytes = Buffer.byteLength(text, "utf8");
-  const bounded = truncateUtf8(text, WORKER_OUTPUT_MAX_BYTES, WORKER_OUTPUT_TRUNCATION_MARKER);
-  return { state, text: bounded, bytes, truncated: bounded !== text };
-}
-function createWorkerOutputCapture() {
-  let finalText = null;
-  let partialText = "";
-  let partialBytes = 0;
-  let partialStored = 0;
-  return {
-    observe(event) {
-      if (!isRecord(event)) return;
-      if (event.type === "message_end") {
-        const message = isRecord(event.message) ? event.message : null;
-        partialText = "";
-        partialBytes = 0;
-        partialStored = 0;
-        if (message === null || message.role !== "assistant") return;
-        if (!isDurableAssistantMessage(message)) return;
-        const text = assistantTextFromContent(message.content).trim();
-        if (text.length > 0) finalText = text;
-        return;
-      }
-      if (event.type !== "message_update") return;
-      const assistantEvent = isRecord(event.assistantMessageEvent) ? event.assistantMessageEvent : null;
-      if (assistantEvent === null || assistantEvent.type !== "text_delta") return;
-      const delta = assistantEvent.delta;
-      if (typeof delta !== "string" || delta.length === 0) return;
-      partialBytes += Buffer.byteLength(delta, "utf8");
-      if (partialStored < WORKER_OUTPUT_MAX_BYTES) {
-        partialText += delta;
-        partialStored += Buffer.byteLength(delta, "utf8");
-      }
-    },
-    snapshot() {
-      if (partialBytes > 0 && partialText.trim().length > 0) {
-        const bounded = truncateUtf8(partialText.trim(), WORKER_OUTPUT_MAX_BYTES, WORKER_OUTPUT_TRUNCATION_MARKER);
-        return {
-          state: "partial",
-          text: bounded,
-          bytes: partialBytes,
-          truncated: bounded !== partialText.trim() || partialBytes > partialStored
-        };
-      }
-      if (finalText !== null) return boundedOutput("final", finalText);
-      return void 0;
-    }
-  };
-}
-
-// src/domains/dispatch/admission-error.ts
-init_esm_shims();
-var AdmissionCanceledError = class extends Error {
-  code = "admission_canceled";
-  constructor(message = "dispatch: admission canceled before a capacity slot opened") {
-    super(message);
-    this.name = "AdmissionCanceledError";
-  }
-};
-
-export {
-  EVENT_TEE_LIMIT,
-  startDispatchEventPump,
-  WORKER_OUTPUT_MAX_BYTES,
-  durableAssistantTextFromEvent,
-  createWorkerOutputCapture,
-  AdmissionCanceledError
-};
-//# sourceMappingURL=chunk-T56WDKA5.js.map

package/dist/chunk-VN3SHNBN.js

@@ -1,313 +0,0 @@
-import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
-import {
-  isProjectVerifierCheckId
-} from "./chunk-UL3WSD3F.js";
-import {
-  SAFE_EXEC_DEFAULT_TIMEOUT_MS,
-  resolveSafeCwd
-} from "./chunk-HJWWJ6IL.js";
-import {
-  require_dist
-} from "./chunk-APJ265NV.js";
-import {
-  __toESM,
-  init_esm_shims
-} from "./chunk-3R73A4XB.js";
-
-// src/tools/verify/catalog.ts
-init_esm_shims();
-var import_yaml = __toESM(require_dist(), 1);
-import { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
-import path from "node:path";
-
-// src/domains/evidence/ordering.ts
-init_esm_shims();
-function compareCodepoints(left, right) {
-  return left < right ? -1 : left > right ? 1 : 0;
-}
-
-// src/tools/verify/catalog.ts
-var PROJECT_VERIFIER_CATALOG_RELATIVE_PATH = ".clio-coder/verifiers.yaml";
-var PROJECT_VERIFIER_CATALOG_VERSION = 1;
-var PROJECT_VERIFIER_CATALOG_CAPS = Object.freeze({
-  fileBytes: 256 * 1024,
-  checks: 128,
-  idBytes: 64,
-  descriptionBytes: 512,
-  argvEntries: 64,
-  argumentBytes: 4096,
-  cwdBytes: 512,
-  timeoutMs: 9e5,
-  tags: 16,
-  tagBytes: 32
-});
-var ROOT_FIELDS = /* @__PURE__ */ new Set(["version", "checks"]);
-var CHECK_FIELDS = /* @__PURE__ */ new Set(["id", "description", "command", "cwd", "timeoutMs", "tags"]);
-var TAG_PATTERN = /^[a-z0-9][a-z0-9._-]*$/;
-var SHELL_EXECUTABLES = /* @__PURE__ */ new Set([
-  "bash",
-  "cmd",
-  "command.com",
-  "dash",
-  "fish",
-  "ksh",
-  "powershell",
-  "pwsh",
-  "sh",
-  "tcsh",
-  "zsh"
-]);
-function isRecord(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function utf8Bytes(value) {
-  return Buffer.byteLength(value, "utf8");
-}
-function hasControlCharacter(value) {
-  for (let index = 0; index < value.length; index += 1) {
-    const code = value.charCodeAt(index);
-    if (code <= 31 || code === 127) return true;
-  }
-  return false;
-}
-function catalogDiagnostic(message) {
-  return { ok: false, reason: `${PROJECT_VERIFIER_CATALOG_RELATIVE_PATH}: ${message}` };
-}
-function unknownFields(record, allowed) {
-  return Object.keys(record).filter((key) => !allowed.has(key)).sort(compareCodepoints);
-}
-function relativeCwd(workspaceRoot, resolved) {
-  const relative = path.relative(workspaceRoot, resolved);
-  return relative.length === 0 ? "." : relative.split(path.sep).join("/");
-}
-function safelyResolveCatalogCwd(rawCwd, workspaceRoot, location) {
-  if (path.isAbsolute(rawCwd) || path.win32.isAbsolute(rawCwd)) {
-    return new Error(`${location} must be repository-relative; absolute cwd '${rawCwd}' is not allowed`);
-  }
-  let resolved;
-  try {
-    resolved = resolveSafeCwd(rawCwd, workspaceRoot);
-  } catch {
-    return new Error(`${location} escapes the workspace root: '${rawCwd}'`);
-  }
-  let realCwd;
-  try {
-    const cwdStat = statSync(resolved);
-    if (!cwdStat.isDirectory()) return new Error(`${location} is not a directory: '${rawCwd}'`);
-    const realRoot = realpathSync(workspaceRoot);
-    realCwd = realpathSync(resolved);
-    resolveSafeCwd(realCwd, realRoot);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    if (message.includes("escapes workspace root")) {
-      return new Error(`${location} escapes the workspace root through a symbolic link: '${rawCwd}'`);
-    }
-    return new Error(`${location} cannot be resolved as a repository directory: '${rawCwd}' (${message})`);
-  }
-  return { declared: relativeCwd(workspaceRoot, resolved), execution: realCwd };
-}
-function resolveProjectVerifierExecutionCwd(rawCwd, workspaceRoot) {
-  const resolution = safelyResolveCatalogCwd(rawCwd, workspaceRoot, "project check cwd");
-  return resolution instanceof Error ? resolution : resolution.execution;
-}
-function validateId(value, location) {
-  if (typeof value !== "string" || value.length === 0) return new Error(`${location} must be a non-empty string`);
-  if (utf8Bytes(value) > PROJECT_VERIFIER_CATALOG_CAPS.idBytes) {
-    return new Error(`${location} exceeds the ${PROJECT_VERIFIER_CATALOG_CAPS.idBytes}-byte cap`);
-  }
-  if (!isProjectVerifierCheckId(value)) {
-    return new Error(`${location} must match /^[a-z0-9][a-z0-9._:-]*$/`);
-  }
-  if (value === "frontend") return new Error(`${location} uses reserved built-in check id 'frontend'`);
-  return value;
-}
-function validateDescription(value, location) {
-  if (typeof value !== "string" || value.length === 0) return new Error(`${location} must be a non-empty string`);
-  if (value.trim() !== value || hasControlCharacter(value)) {
-    return new Error(`${location} must be trimmed, single-line text without control characters`);
-  }
-  if (utf8Bytes(value) > PROJECT_VERIFIER_CATALOG_CAPS.descriptionBytes) {
-    return new Error(`${location} exceeds the ${PROJECT_VERIFIER_CATALOG_CAPS.descriptionBytes}-byte cap`);
-  }
-  return value;
-}
-function validateCommand(value, location) {
-  if (!Array.isArray(value) || value.length === 0) {
-    return new Error(`${location} must be a non-empty argv string array; shell command strings are not allowed`);
-  }
-  if (value.length > PROJECT_VERIFIER_CATALOG_CAPS.argvEntries) {
-    return new Error(`${location} exceeds the ${PROJECT_VERIFIER_CATALOG_CAPS.argvEntries}-entry cap`);
-  }
-  const command = [];
-  for (const [index, entry] of value.entries()) {
-    const entryLocation = `${location}[${index}]`;
-    if (typeof entry !== "string" || entry.length === 0) {
-      return new Error(`${entryLocation} must be a non-empty string`);
-    }
-    if (entry.includes("\0")) return new Error(`${entryLocation} must not contain a NUL byte`);
-    if (utf8Bytes(entry) > PROJECT_VERIFIER_CATALOG_CAPS.argumentBytes) {
-      return new Error(`${entryLocation} exceeds the ${PROJECT_VERIFIER_CATALOG_CAPS.argumentBytes}-byte cap`);
-    }
-    command.push(entry);
-  }
-  const executable = command[0] ?? "";
-  if (/\s/u.test(executable)) {
-    return new Error(`${location}[0] must be one executable token, not a shell command string`);
-  }
-  const executableName = path.basename(executable).toLowerCase().replace(/\.exe$/u, "");
-  if (SHELL_EXECUTABLES.has(executableName)) {
-    return new Error(`${location}[0] may not invoke shell executable '${executable}'`);
-  }
-  return command;
-}
-function validateTimeout(value, location) {
-  if (!Number.isInteger(value) || typeof value !== "number" || value <= 0) {
-    return new Error(`${location} must be a positive integer number of milliseconds`);
-  }
-  if (value > PROJECT_VERIFIER_CATALOG_CAPS.timeoutMs) {
-    return new Error(`${location} exceeds the ${PROJECT_VERIFIER_CATALOG_CAPS.timeoutMs}ms cap`);
-  }
-  return value;
-}
-function validateTags(value, location) {
-  if (!Array.isArray(value)) return new Error(`${location} must be an array of bounded tag strings`);
-  if (value.length > PROJECT_VERIFIER_CATALOG_CAPS.tags) {
-    return new Error(`${location} exceeds the ${PROJECT_VERIFIER_CATALOG_CAPS.tags}-tag cap`);
-  }
-  const tags = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const [index, entry] of value.entries()) {
-    const entryLocation = `${location}[${index}]`;
-    if (typeof entry !== "string" || entry.length === 0) {
-      return new Error(`${entryLocation} must be a non-empty string`);
-    }
-    if (utf8Bytes(entry) > PROJECT_VERIFIER_CATALOG_CAPS.tagBytes) {
-      return new Error(`${entryLocation} exceeds the ${PROJECT_VERIFIER_CATALOG_CAPS.tagBytes}-byte cap`);
-    }
-    if (!TAG_PATTERN.test(entry)) return new Error(`${entryLocation} must match /^[a-z0-9][a-z0-9._-]*$/`);
-    if (seen.has(entry)) return new Error(`${location} contains duplicate tag '${entry}'`);
-    seen.add(entry);
-    tags.push(entry);
-  }
-  return tags;
-}
-function sourcePathInsideWorkspace(catalogPath, workspaceRoot) {
-  try {
-    const realRoot = realpathSync(workspaceRoot);
-    const realCatalogPath = realpathSync(catalogPath);
-    resolveSafeCwd(realCatalogPath, realRoot);
-    return realCatalogPath;
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return new Error(`catalog file must resolve inside the workspace root (${message})`);
-  }
-}
-function loadProjectVerifierCatalog(workspaceRoot) {
-  const catalogPath = path.join(workspaceRoot, PROJECT_VERIFIER_CATALOG_RELATIVE_PATH);
-  if (!existsSync(catalogPath)) return { ok: true, source: null };
-  const safeSourcePath = sourcePathInsideWorkspace(catalogPath, workspaceRoot);
-  if (safeSourcePath instanceof Error) return catalogDiagnostic(safeSourcePath.message);
-  let text;
-  try {
-    const stats = statSync(safeSourcePath);
-    if (!stats.isFile()) return catalogDiagnostic("catalog path must be a regular file");
-    if (stats.size > PROJECT_VERIFIER_CATALOG_CAPS.fileBytes) {
-      return catalogDiagnostic(`file exceeds the ${PROJECT_VERIFIER_CATALOG_CAPS.fileBytes}-byte cap`);
-    }
-    text = readFileSync(safeSourcePath, "utf8");
-  } catch (error) {
-    return catalogDiagnostic(`cannot read catalog (${error instanceof Error ? error.message : String(error)})`);
-  }
-  return parseProjectVerifierCatalogText(text, workspaceRoot, catalogPath);
-}
-function parseProjectVerifierCatalogText(text, workspaceRoot, catalogPath = path.join(workspaceRoot, PROJECT_VERIFIER_CATALOG_RELATIVE_PATH)) {
-  const document = (0, import_yaml.parseDocument)(text, { prettyErrors: false, strict: true, uniqueKeys: true });
-  if (document.errors.length > 0) {
-    return catalogDiagnostic(`invalid YAML: ${document.errors.map((error) => error.message).join("; ")}`);
-  }
-  let parsed;
-  try {
-    parsed = document.toJS({ maxAliasCount: 0 });
-  } catch (error) {
-    return catalogDiagnostic(`invalid YAML: ${error instanceof Error ? error.message : String(error)}`);
-  }
-  if (!isRecord(parsed)) return catalogDiagnostic("root must be an object with version and checks fields");
-  const rootUnknown = unknownFields(parsed, ROOT_FIELDS);
-  if (rootUnknown.length > 0) return catalogDiagnostic(`root has unknown field(s): ${rootUnknown.join(", ")}`);
-  if (!Object.hasOwn(parsed, "version")) return catalogDiagnostic("root.version is required");
-  if (parsed.version !== PROJECT_VERIFIER_CATALOG_VERSION) {
-    return catalogDiagnostic(
-      `unsupported version ${JSON.stringify(parsed.version)}; supported version is ${PROJECT_VERIFIER_CATALOG_VERSION}`
-    );
-  }
-  if (!Object.hasOwn(parsed, "checks")) return catalogDiagnostic("root.checks is required");
-  if (!Array.isArray(parsed.checks)) return catalogDiagnostic("root.checks must be an array");
-  if (parsed.checks.length > PROJECT_VERIFIER_CATALOG_CAPS.checks) {
-    return catalogDiagnostic(`root.checks exceeds the ${PROJECT_VERIFIER_CATALOG_CAPS.checks}-check cap`);
-  }
-  const sourceRef = { kind: "project-catalog", path: catalogPath };
-  const checks = [];
-  const ids = /* @__PURE__ */ new Map();
-  for (const [index, value] of parsed.checks.entries()) {
-    const location = `checks[${index}]`;
-    if (!isRecord(value)) return catalogDiagnostic(`${location} must be an object`);
-    const checkUnknown = unknownFields(value, CHECK_FIELDS);
-    if (checkUnknown.length > 0) {
-      return catalogDiagnostic(`${location} has unknown field(s): ${checkUnknown.join(", ")}`);
-    }
-    for (const field of CHECK_FIELDS) {
-      if (!Object.hasOwn(value, field)) return catalogDiagnostic(`${location}.${field} is required`);
-    }
-    const id = validateId(value.id, `${location}.id`);
-    if (id instanceof Error) return catalogDiagnostic(id.message);
-    const duplicateIndex = ids.get(id);
-    if (duplicateIndex !== void 0) {
-      return catalogDiagnostic(`${location}.id duplicates '${id}' from checks[${duplicateIndex}].id`);
-    }
-    const description = validateDescription(value.description, `${location}.description`);
-    if (description instanceof Error) return catalogDiagnostic(description.message);
-    const command = validateCommand(value.command, `${location}.command`);
-    if (command instanceof Error) return catalogDiagnostic(command.message);
-    if (typeof value.cwd !== "string" || value.cwd.length === 0) {
-      return catalogDiagnostic(`${location}.cwd must be a non-empty repository-relative string`);
-    }
-    if (value.cwd.includes("\0")) return catalogDiagnostic(`${location}.cwd must not contain a NUL byte`);
-    if (utf8Bytes(value.cwd) > PROJECT_VERIFIER_CATALOG_CAPS.cwdBytes) {
-      return catalogDiagnostic(`${location}.cwd exceeds the ${PROJECT_VERIFIER_CATALOG_CAPS.cwdBytes}-byte cap`);
-    }
-    const cwdResolution = safelyResolveCatalogCwd(value.cwd, workspaceRoot, `${location}.cwd`);
-    if (cwdResolution instanceof Error) return catalogDiagnostic(cwdResolution.message);
-    const cwd = cwdResolution.declared;
-    const timeoutMs = validateTimeout(value.timeoutMs, `${location}.timeoutMs`);
-    if (timeoutMs instanceof Error) return catalogDiagnostic(timeoutMs.message);
-    const tags = validateTags(value.tags, `${location}.tags`);
-    if (tags instanceof Error) return catalogDiagnostic(tags.message);
-    ids.set(id, index);
-    checks.push({ id, description, command, cwd, timeoutMs, tags, source: { ...sourceRef } });
-  }
-  checks.sort((left, right) => compareCodepoints(left.id, right.id));
-  return { ok: true, source: { ...sourceRef, checks } };
-}
-function packageDeclaredCheck(id, packagePath, cwd, tags) {
-  return {
-    id,
-    description: `Run package.json script '${id}'.`,
-    command: ["npm", "run", id],
-    cwd,
-    timeoutMs: SAFE_EXEC_DEFAULT_TIMEOUT_MS,
-    tags,
-    source: { kind: "package.json", path: packagePath }
-  };
-}
-
-export {
-  compareCodepoints,
-  PROJECT_VERIFIER_CATALOG_RELATIVE_PATH,
-  PROJECT_VERIFIER_CATALOG_VERSION,
-  PROJECT_VERIFIER_CATALOG_CAPS,
-  resolveProjectVerifierExecutionCwd,
-  loadProjectVerifierCatalog,
-  parseProjectVerifierCatalogText,
-  packageDeclaredCheck
-};
-//# sourceMappingURL=chunk-VN3SHNBN.js.map