@iowarp/clio-coder 0.3.1 → 0.3.2

package/dist/chunk-CMZWFGD2.js

@@ -0,0 +1,352 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/worker/protocol.ts
+init_esm_shims();
+import { createHash } from "node:crypto";
+var WORKER_PROTOCOL_VERSION = 1;
+var CONTROL_FRAME_PREFIX = "@clio-control/1 ";
+var WORKER_CONTROL_FRAME_MAX_BYTES = 16 * 1024;
+var WORKER_BULK_FRAME_MAX_BYTES = 4 * 1024 * 1024;
+var WORKER_STDIN_FRAME_MAX_BYTES = 1024 * 1024;
+var WORKER_STDIN_QUEUE_MAX_BYTES = 4 * 1024 * 1024;
+var WORKER_EVENT_QUEUE_MAX_FRAMES = 4096;
+function knownResource(value) {
+  return { known: true, value };
+}
+var UNKNOWN_RESOURCE = { known: false };
+var WORKER_RESOURCE_LABEL_MAX = 32;
+var WORKER_RESIDENT_MODEL_MAX = 64;
+var AGENT_LEDGER_SCOPE_MAX_ENTRIES = 8;
+var AGENT_LEDGER_SCOPE_ENTRY_MAX_CHARS = 200;
+var AGENT_LEDGER_INTENT_MAX_CHARS = 200;
+var AGENT_LEDGER_CLAIM_MAX_CHARS = 400;
+var AGENT_LEDGER_EVIDENCE_MAX_CHARS = 400;
+var AGENT_LEDGER_PATH_MAX_CHARS = 400;
+var AGENT_LEDGER_ENTRY_ID = /^e[1-9][0-9]*$/;
+function isAgentLedgerEntryId(value) {
+  return typeof value === "string" && AGENT_LEDGER_ENTRY_ID.test(value);
+}
+function boundedString(value, max) {
+  return typeof value === "string" && value.length > 0 && value.length <= max;
+}
+function parseAgentLedgerBody(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return { ok: false, reason: "ledger body is not an object" };
+  }
+  const record = value;
+  switch (record.kind) {
+    case "claim": {
+      const scope = record.scope;
+      if (!Array.isArray(scope) || scope.length === 0) {
+        return { ok: false, reason: "claim scope must be a non-empty array of path prefixes" };
+      }
+      if (scope.length > AGENT_LEDGER_SCOPE_MAX_ENTRIES) {
+        return { ok: false, reason: `claim scope exceeds ${AGENT_LEDGER_SCOPE_MAX_ENTRIES} entries` };
+      }
+      for (const entry of scope) {
+        if (!boundedString(entry, AGENT_LEDGER_SCOPE_ENTRY_MAX_CHARS)) {
+          return {
+            ok: false,
+            reason: `claim scope entries must be 1..${AGENT_LEDGER_SCOPE_ENTRY_MAX_CHARS} characters`
+          };
+        }
+      }
+      if (!boundedString(record.intent, AGENT_LEDGER_INTENT_MAX_CHARS)) {
+        return { ok: false, reason: `claim intent must be 1..${AGENT_LEDGER_INTENT_MAX_CHARS} characters` };
+      }
+      return { ok: true, body: { kind: "claim", scope: scope.map(String), intent: record.intent } };
+    }
+    case "finding": {
+      if (!boundedString(record.claim, AGENT_LEDGER_CLAIM_MAX_CHARS)) {
+        return { ok: false, reason: `finding claim must be 1..${AGENT_LEDGER_CLAIM_MAX_CHARS} characters` };
+      }
+      const body = {
+        kind: "finding",
+        claim: record.claim
+      };
+      if (record.path !== void 0) {
+        if (!boundedString(record.path, AGENT_LEDGER_PATH_MAX_CHARS)) {
+          return { ok: false, reason: `finding path must be 1..${AGENT_LEDGER_PATH_MAX_CHARS} characters` };
+        }
+        body.path = record.path;
+      }
+      if (record.line !== void 0) {
+        const line = record.line;
+        if (typeof line !== "number" || !Number.isSafeInteger(line) || line <= 0) {
+          return { ok: false, reason: "finding line must be a positive safe integer" };
+        }
+        body.line = line;
+      }
+      return { ok: true, body };
+    }
+    case "review": {
+      if (!isAgentLedgerEntryId(record.target)) {
+        return { ok: false, reason: "review target must be a ledger entry id such as e3" };
+      }
+      if (typeof record.passed !== "boolean") {
+        return { ok: false, reason: "review passed must be a boolean" };
+      }
+      if (!boundedString(record.evidence, AGENT_LEDGER_EVIDENCE_MAX_CHARS)) {
+        return { ok: false, reason: `review evidence must be 1..${AGENT_LEDGER_EVIDENCE_MAX_CHARS} characters` };
+      }
+      return {
+        ok: true,
+        body: { kind: "review", target: record.target, passed: record.passed, evidence: record.evidence }
+      };
+    }
+    default:
+      return { ok: false, reason: `unknown ledger entry kind ${String(record.kind)}` };
+  }
+}
+function parseAgentLedgerEntry(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+  const record = value;
+  const sequence = record.sequence;
+  if (typeof sequence !== "number" || !Number.isSafeInteger(sequence) || sequence <= 0) return null;
+  if (!isAgentLedgerEntryId(record.id)) return null;
+  for (const key of ["at", "runId", "assignmentId", "agentId", "nodeId"]) {
+    if (typeof record[key] !== "string" || record[key].length === 0) return null;
+  }
+  const body = parseAgentLedgerBody(record.body);
+  if (!body.ok) return null;
+  const conflicts = record.conflictsWith;
+  if (conflicts !== void 0 && !(Array.isArray(conflicts) && conflicts.every(isAgentLedgerEntryId))) return null;
+  return {
+    id: record.id,
+    sequence,
+    at: record.at,
+    runId: record.runId,
+    assignmentId: record.assignmentId,
+    agentId: record.agentId,
+    nodeId: record.nodeId,
+    body: body.body,
+    ...conflicts === void 0 ? {} : { conflictsWith: [...conflicts] }
+  };
+}
+function sha256Hex(input) {
+  return createHash("sha256").update(input, "utf8").digest("hex");
+}
+var HEX_64 = /^[0-9a-f]{64}$/;
+function endpointIdentityHash(url) {
+  if (url === void 0 || url.trim().length === 0) return sha256Hex("clio.endpoint:none");
+  const raw = url.trim();
+  let canonical;
+  try {
+    const parsed = new URL(raw);
+    const path = parsed.pathname.replace(/\/+$/u, "");
+    canonical = `${parsed.protocol}//${parsed.hostname}:${parsed.port}${path}`;
+  } catch {
+    canonical = raw.replace(/\/+$/u, "");
+  }
+  return sha256Hex(`clio.endpoint:${canonical}`);
+}
+function workerSpecDigest(spec) {
+  return sha256Hex(`clio.workerSpec:${canonicalJson(spec)}`);
+}
+function toolSignatureOf(names) {
+  return sha256Hex(`clio.tools:${[...names].sort().join(",")}`);
+}
+function canonicalJson(value) {
+  if (value === null) return "null";
+  if (typeof value === "number") return Number.isFinite(value) ? JSON.stringify(value) : "null";
+  if (typeof value === "string" || typeof value === "boolean") return JSON.stringify(value);
+  if (Array.isArray(value))
+    return `[${value.map((entry) => entry === void 0 ? "null" : canonicalJson(entry)).join(",")}]`;
+  if (typeof value === "object") {
+    const record = value;
+    const parts = [];
+    for (const key of Object.keys(record).sort()) {
+      const child = record[key];
+      if (child === void 0) continue;
+      parts.push(`${JSON.stringify(key)}:${canonicalJson(child)}`);
+    }
+    return `{${parts.join(",")}}`;
+  }
+  return "null";
+}
+function withinFrameBudget(line, maxBytes) {
+  return Buffer.byteLength(line, "utf8") <= maxBytes;
+}
+function parseJsonObject(line, maxBytes, lane) {
+  if (!withinFrameBudget(line, maxBytes)) {
+    return { ok: false, reason: `${lane} frame exceeds ${maxBytes} bytes` };
+  }
+  let value;
+  try {
+    value = JSON.parse(line);
+  } catch {
+    return { ok: false, reason: `${lane} frame is not JSON` };
+  }
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return { ok: false, reason: `${lane} frame is not a JSON object` };
+  }
+  return { ok: true, value };
+}
+function parseBulkFrame(line) {
+  return parseJsonObject(line, WORKER_BULK_FRAME_MAX_BYTES, "bulk");
+}
+function isControlLine(line) {
+  return line.startsWith(CONTROL_FRAME_PREFIX);
+}
+function encodeControlFrame(frame) {
+  return `${CONTROL_FRAME_PREFIX}${JSON.stringify(frame)}
+`;
+}
+function readFiniteNumber(record, key) {
+  const value = record[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function readResourceValue(value, validate) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+  const record = value;
+  if (record.known === false) return { known: false };
+  if (record.known !== true || !validate(record.value)) return null;
+  return { known: true, value: record.value };
+}
+function isFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+function isBoundedStringArray(value, max) {
+  return Array.isArray(value) && value.length <= max && value.every((entry) => typeof entry === "string");
+}
+function parseResourceFacts(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+  const record = value;
+  if (!isBoundedStringArray(record.labels, WORKER_RESOURCE_LABEL_MAX)) return null;
+  const numeric = ["cpuCount", "totalMemoryBytes", "freeMemoryBytes", "gpuCount", "vramBytes"];
+  const parsed = { labels: [...record.labels] };
+  for (const key of numeric) {
+    const fact = readResourceValue(record[key], isFiniteNumber);
+    if (fact === null) return null;
+    parsed[key] = fact;
+  }
+  const residentModels = readResourceValue(
+    record.residentModels,
+    (raw) => isBoundedStringArray(raw, WORKER_RESIDENT_MODEL_MAX)
+  );
+  if (residentModels === null) return null;
+  parsed.residentModels = residentModels;
+  return parsed;
+}
+function parseAttestation(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return { ok: false, reason: "announce attestation is not an object" };
+  }
+  const record = value;
+  if (record.protocolVersion !== WORKER_PROTOCOL_VERSION) {
+    return { ok: false, reason: `announce protocol version ${String(record.protocolVersion)} is unsupported` };
+  }
+  const specVersion = readFiniteNumber(record, "specVersion");
+  if (specVersion === null) return { ok: false, reason: "announce specVersion must be a finite number" };
+  const pid = readFiniteNumber(record, "pid");
+  if (pid === null) return { ok: false, reason: "announce pid must be a finite number" };
+  const rawPgid = record.processGroupId;
+  if (rawPgid !== null && !(typeof rawPgid === "number" && Number.isFinite(rawPgid))) {
+    return { ok: false, reason: "announce processGroupId must be a finite number or null" };
+  }
+  for (const key of ["host", "runtimeId", "targetId", "wireModelId"]) {
+    if (typeof record[key] !== "string" || record[key].length === 0) {
+      return { ok: false, reason: `announce ${key} must be a non-empty string` };
+    }
+  }
+  for (const key of ["settingsFingerprint", "specDigest", "endpointIdentityHash", "toolSignature"]) {
+    if (typeof record[key] !== "string" || !HEX_64.test(record[key])) {
+      return { ok: false, reason: `announce ${key} must be a sha256 hex digest` };
+    }
+  }
+  const resources = parseResourceFacts(record.resources);
+  if (resources === null) return { ok: false, reason: "announce resources are missing or malformed" };
+  return {
+    ok: true,
+    value: {
+      protocolVersion: WORKER_PROTOCOL_VERSION,
+      specVersion,
+      pid,
+      processGroupId: typeof rawPgid === "number" ? rawPgid : null,
+      host: record.host,
+      settingsFingerprint: record.settingsFingerprint,
+      specDigest: record.specDigest,
+      runtimeId: record.runtimeId,
+      targetId: record.targetId,
+      endpointIdentityHash: record.endpointIdentityHash,
+      wireModelId: record.wireModelId,
+      toolSignature: record.toolSignature,
+      resources
+    }
+  };
+}
+function parseControlFrame(line) {
+  if (!isControlLine(line)) return { ok: false, reason: "control frame is missing its lane marker" };
+  const body = line.slice(CONTROL_FRAME_PREFIX.length);
+  const parsed = parseJsonObject(body, WORKER_CONTROL_FRAME_MAX_BYTES, "control");
+  if (!parsed.ok) return parsed;
+  const record = parsed.value;
+  switch (record.kind) {
+    case "announce": {
+      const attestation = parseAttestation(record.attestation);
+      if (!attestation.ok) return attestation;
+      return { ok: true, value: { kind: "announce", attestation: attestation.value } };
+    }
+    case "heartbeat":
+      return { ok: true, value: { kind: "heartbeat" } };
+    case "cancel_ack": {
+      const at = readFiniteNumber(record, "at");
+      if (at === null) return { ok: false, reason: "cancel_ack frame requires a finite at" };
+      return { ok: true, value: { kind: "cancel_ack", at } };
+    }
+    case "ledger_post": {
+      const body2 = parseAgentLedgerBody(record.body);
+      if (!body2.ok) return { ok: false, reason: `ledger_post frame rejected: ${body2.reason}` };
+      return { ok: true, value: { kind: "ledger_post", body: body2.body } };
+    }
+    default:
+      return { ok: false, reason: `unknown control frame kind ${String(record.kind)}` };
+  }
+}
+var RECEIPT_BEARING_BULK_TYPES = /* @__PURE__ */ new Set([
+  "message_end",
+  "clio_run_outcome",
+  "clio_permission_escalated",
+  "clio_permission_resolved",
+  "clio_steer_received",
+  "clio_tool_activity",
+  "clio_skill_activation",
+  "clio_safety_decision",
+  "clio_verification",
+  "clio_usage",
+  "tool_execution_end",
+  "spawn_error"
+]);
+function isReceiptBearingFrame(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return true;
+  const type = value.type;
+  if (typeof type !== "string") return true;
+  return RECEIPT_BEARING_BULK_TYPES.has(type);
+}
+
+export {
+  WORKER_PROTOCOL_VERSION,
+  WORKER_BULK_FRAME_MAX_BYTES,
+  WORKER_STDIN_FRAME_MAX_BYTES,
+  WORKER_STDIN_QUEUE_MAX_BYTES,
+  WORKER_EVENT_QUEUE_MAX_FRAMES,
+  knownResource,
+  UNKNOWN_RESOURCE,
+  WORKER_RESOURCE_LABEL_MAX,
+  parseAgentLedgerBody,
+  parseAgentLedgerEntry,
+  endpointIdentityHash,
+  workerSpecDigest,
+  toolSignatureOf,
+  canonicalJson,
+  withinFrameBudget,
+  parseBulkFrame,
+  isControlLine,
+  encodeControlFrame,
+  parseControlFrame,
+  isReceiptBearingFrame
+};
+//# sourceMappingURL=chunk-CMZWFGD2.js.map

package/dist/chunk-ECH6PKUQ.js

@@ -0,0 +1,39 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/core/path-canonical.ts
+init_esm_shims();
+import { realpathSync } from "node:fs";
+import path from "node:path";
+function canonicalizeExistingPath(absPath) {
+  const resolved = path.resolve(absPath);
+  try {
+    return path.resolve(realpathSync(resolved));
+  } catch {
+  }
+  const tail = [];
+  let cursor = resolved;
+  while (true) {
+    const parent = path.dirname(cursor);
+    if (parent === cursor) {
+      try {
+        return path.resolve(realpathSync(cursor), ...tail);
+      } catch {
+        return resolved;
+      }
+    }
+    tail.unshift(path.basename(cursor));
+    cursor = parent;
+    try {
+      return path.resolve(realpathSync(cursor), ...tail);
+    } catch {
+    }
+  }
+}
+
+export {
+  canonicalizeExistingPath
+};
+//# sourceMappingURL=chunk-ECH6PKUQ.js.map

package/dist/chunk-ED4KHGC3.js

@@ -0,0 +1,143 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  source_default
+} from "./chunk-5TSRNF4G.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/cli/argv.ts
+init_esm_shims();
+function printError(message, detail) {
+  const head = source_default.red("error:");
+  process.stderr.write(`${head} ${message}
+`);
+  if (detail) process.stderr.write(`  ${detail}
+`);
+}
+function printOk(message) {
+  process.stdout.write(`${source_default.green("ok:")} ${message}
+`);
+}
+function printHeader(message) {
+  process.stdout.write(`${source_default.cyan(message)}
+`);
+}
+function columnWidths(rows) {
+  const widths = [];
+  for (const row of rows) {
+    for (let i = 0; i < row.length; i += 1) {
+      widths[i] = Math.max(widths[i] ?? 0, row[i]?.length ?? 0);
+    }
+  }
+  return widths;
+}
+function formatColumnRow(row, widths, gap = 2) {
+  return row.map((cell, index) => {
+    if (index === row.length - 1) return cell;
+    return cell.padEnd((widths[index] ?? cell.length) + gap);
+  }).join("").trimEnd();
+}
+function formatColumns(rows, gap = 2) {
+  if (rows.length === 0) return "";
+  const widths = columnWidths(rows);
+  return `${rows.map((row) => formatColumnRow(row, widths, gap)).join("\n")}
+`;
+}
+function parseFlags(argv) {
+  const flags = /* @__PURE__ */ new Set();
+  const positional = [];
+  for (const arg of argv) {
+    if (arg.startsWith("--")) flags.add(arg.slice(2));
+    else if (arg.startsWith("-") && arg.length > 1) flags.add(arg.slice(1));
+    else positional.push(arg);
+  }
+  return { flags, positional };
+}
+var ROOT_FLAG_TOKENS = /* @__PURE__ */ new Set(["--help", "-h", "--all", "--version", "-v"]);
+var GLOBAL_ONLY_FLAGS = /* @__PURE__ */ new Map([
+  ["--api-key", "--api-key <key>"],
+  ["--no-context-files", "--no-context-files"],
+  ["-nc", "-nc"]
+]);
+function globalFlagPositionHint(arg, command) {
+  const usage = GLOBAL_ONLY_FLAGS.get(arg);
+  if (usage === void 0) return null;
+  return `${arg} is a global option and must come before the subcommand: clio-coder ${usage} ${command} ...`;
+}
+function extractGlobalFlags(argv, isSubcommand = () => false) {
+  const rest = [];
+  let apiKey;
+  let noContextFiles = false;
+  let noSkills = false;
+  const skillPaths = [];
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === void 0) continue;
+    if (arg === "--") {
+      rest.push(...argv.slice(i + 1));
+      break;
+    }
+    if (!arg.startsWith("-")) {
+      rest.push(...argv.slice(i));
+      break;
+    }
+    if (ROOT_FLAG_TOKENS.has(arg)) {
+      rest.push(arg);
+      continue;
+    }
+    if (arg === "--no-context-files" || arg === "-nc") {
+      noContextFiles = true;
+      continue;
+    }
+    if (arg === "--no-skills") {
+      noSkills = true;
+      continue;
+    }
+    if (arg === "--api-key" || arg === "--skill") {
+      const value = argv[i + 1];
+      if (value === void 0 || value.startsWith("-") || isSubcommand(value)) {
+        return {
+          noContextFiles,
+          noSkills,
+          skillPaths,
+          rest,
+          error: `${arg} requires a value`,
+          ...apiKey === void 0 ? {} : { apiKey }
+        };
+      }
+      if (arg === "--api-key") apiKey = value;
+      else skillPaths.push(value);
+      i += 1;
+      continue;
+    }
+    return {
+      noContextFiles,
+      noSkills,
+      skillPaths,
+      rest,
+      error: `unknown global option: ${arg}`,
+      ...apiKey === void 0 ? {} : { apiKey }
+    };
+  }
+  return {
+    noContextFiles,
+    noSkills,
+    skillPaths,
+    rest,
+    ...apiKey === void 0 ? {} : { apiKey }
+  };
+}
+
+export {
+  printError,
+  printOk,
+  printHeader,
+  columnWidths,
+  formatColumnRow,
+  formatColumns,
+  parseFlags,
+  globalFlagPositionHint,
+  extractGlobalFlags
+};
+//# sourceMappingURL=chunk-ED4KHGC3.js.map