@iowarp/clio-coder 0.3.0

package/dist/evidence-V67CHM35.js

@@ -0,0 +1,233 @@
+import {
+  EvidenceNotFoundError,
+  buildEvalEvidence,
+  buildEvidence,
+  inspectEvidence,
+  listEvidenceOverviews,
+  loadEvidenceRunProvenance,
+  provenanceTranscriptLines
+} from "./chunk-GNGDQYDU.js";
+import "./chunk-2J63S4SF.js";
+import "./chunk-RQDWMVRB.js";
+import "./chunk-7BHLZB3A.js";
+import "./chunk-TPOCL34A.js";
+import "./chunk-E3NYWENM.js";
+import "./chunk-XV4ZJ6ZM.js";
+import "./chunk-26BZQOAD.js";
+import "./chunk-WD6AJM35.js";
+import "./chunk-QV47YRF4.js";
+import "./chunk-CLJ5HLUD.js";
+import "./chunk-BBUH4VAA.js";
+import "./chunk-GOTUR54M.js";
+import "./chunk-PIDUD6M2.js";
+import {
+  printError,
+  printOk
+} from "./chunk-67MTHP2E.js";
+import "./chunk-TKHQ4DGZ.js";
+import "./chunk-D5YD55AR.js";
+import "./chunk-JWHCJDCI.js";
+import "./chunk-UHTSULZS.js";
+import "./chunk-5LDRNKX2.js";
+import "./chunk-UGYAX5YI.js";
+import {
+  InvalidIdError
+} from "./chunk-5N2FG33Q.js";
+import "./chunk-VPAWTYLY.js";
+import {
+  clioDataDir,
+  clioStateDir
+} from "./chunk-X3NE4WVW.js";
+import "./chunk-DXQNI4PC.js";
+
+// src/cli/evidence.ts
+var HELP = `clio-coder evidence build --run <runId>
+clio-coder evidence build --session <sessionId>
+clio-coder evidence build --eval <evalId>
+clio-coder evidence inspect <evidenceId>
+clio-coder evidence list
+
+Build or inspect deterministic Clio evidence artifacts.
+`;
+function parseEvidenceArgs(args) {
+  const parsed = { help: false };
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === void 0) continue;
+    if (arg === "--help" || arg === "-h") {
+      parsed.help = true;
+      continue;
+    }
+    if (parsed.command === void 0) {
+      if (arg === "build" || arg === "inspect" || arg === "list") {
+        parsed.command = arg;
+        continue;
+      }
+      throw new Error(`unknown evidence command: ${arg}`);
+    }
+    if (parsed.command === "build") {
+      if (arg === "--run") {
+        const value = args[index + 1];
+        if (value === void 0 || value.startsWith("-")) throw new Error("--run requires a run id");
+        parsed.runId = value;
+        index += 1;
+        continue;
+      }
+      if (arg === "--session") {
+        const value = args[index + 1];
+        if (value === void 0 || value.startsWith("-")) throw new Error("--session requires a session id");
+        parsed.sessionId = value;
+        index += 1;
+        continue;
+      }
+      if (arg === "--eval") {
+        const value = args[index + 1];
+        if (value === void 0 || value.startsWith("-")) throw new Error("--eval requires an eval id");
+        parsed.evalId = value;
+        index += 1;
+        continue;
+      }
+      throw new Error(`unknown evidence build argument: ${arg}`);
+    }
+    if (parsed.command === "inspect" && parsed.evidenceId === void 0) {
+      if (arg.startsWith("-")) throw new Error("inspect requires an evidence id");
+      parsed.evidenceId = arg;
+      continue;
+    }
+    throw new Error(`unexpected evidence argument: ${arg}`);
+  }
+  if (parsed.help) return parsed;
+  if (parsed.command === void 0) throw new Error("evidence requires build, inspect, or list");
+  if (parsed.command === "build") {
+    const selectorCount = [parsed.runId, parsed.sessionId, parsed.evalId].filter((value) => value !== void 0).length;
+    if (selectorCount > 1) {
+      throw new Error("build accepts only one of --run, --session, or --eval");
+    }
+    if (selectorCount === 0) {
+      throw new Error("build requires --run <runId>, --session <sessionId>, or --eval <evalId>");
+    }
+  }
+  if (parsed.command === "inspect" && parsed.evidenceId === void 0)
+    throw new Error("inspect requires an evidence id");
+  if (parsed.command === "list" && (parsed.runId !== void 0 || parsed.sessionId !== void 0 || parsed.evalId !== void 0 || parsed.evidenceId !== void 0)) {
+    throw new Error("list does not accept extra arguments");
+  }
+  return parsed;
+}
+async function runEvidenceCommand(args) {
+  let parsed;
+  try {
+    parsed = parseEvidenceArgs(args);
+  } catch (error) {
+    printError(error instanceof Error ? error.message : String(error));
+    process.stdout.write(HELP);
+    return 2;
+  }
+  if (parsed.help) {
+    process.stdout.write(HELP);
+    return 0;
+  }
+  const dataDir = clioDataDir();
+  const stateDir = clioStateDir();
+  try {
+    if (parsed.command === "build") {
+      const result = parsed.evalId === void 0 ? await buildEvidence({
+        dataDir,
+        stateDir,
+        ...parsed.runId === void 0 ? {} : { runId: parsed.runId },
+        ...parsed.sessionId === void 0 ? {} : { sessionId: parsed.sessionId }
+      }) : await buildEvalEvidence({ dataDir, stateDir, evalId: parsed.evalId });
+      const integrityFailures = result.findings.filter((entry) => entry.tag === "receipt-integrity");
+      if (integrityFailures.length > 0) {
+        process.stdout.write(`wrote ${result.evidenceId} ${result.directory}
+`);
+        for (const failure of integrityFailures) {
+          printError(`${failure.runId !== null ? `run ${failure.runId}: ` : ""}${failure.message}`);
+        }
+        return 1;
+      }
+      printOk(`wrote ${result.evidenceId} ${result.directory}`);
+      return 0;
+    }
+    if (parsed.command === "inspect") {
+      const evidenceId = parsed.evidenceId;
+      if (evidenceId === void 0) {
+        printError("inspect requires an evidence id");
+        return 2;
+      }
+      const inspected = await inspectEvidence(dataDir, evidenceId);
+      const provenance = await loadEvidenceRunProvenance(dataDir, evidenceId);
+      renderEvidence(inspected, provenance);
+      return 0;
+    }
+    if (parsed.command === "list") {
+      renderEvidenceList(await listEvidenceOverviews(dataDir));
+      return 0;
+    }
+    printError("evidence requires build, inspect, or list");
+    return 2;
+  } catch (error) {
+    printError(error instanceof Error ? error.message : String(error));
+    if (error instanceof EvidenceNotFoundError)
+      process.stderr.write("  run `clio-coder evidence list` to see local bundles\n");
+    return error instanceof InvalidIdError ? 2 : 1;
+  }
+}
+function renderEvidence(input, provenance = []) {
+  const { overview, findings } = input;
+  process.stdout.write(`evidence: ${overview.evidenceId}
+`);
+  process.stdout.write(`source: ${formatSource(overview)}
+`);
+  process.stdout.write(`generated: ${overview.generatedAt}
+`);
+  process.stdout.write(`runs: ${overview.totals.runs}
+`);
+  process.stdout.write(`receipts: ${overview.totals.receipts}
+`);
+  process.stdout.write(`tool calls: ${overview.totals.toolCalls}
+`);
+  process.stdout.write(`blocked tools: ${overview.totals.blockedToolCalls}
+`);
+  process.stdout.write(`tags: ${formatList(overview.tags)}
+`);
+  process.stdout.write(`findings: ${findings.length}
+`);
+  for (const { runId, view } of provenance) {
+    process.stdout.write(`provenance ${runId}:
+`);
+    for (const line of provenanceTranscriptLines(view)) process.stdout.write(`  ${line}
+`);
+  }
+  process.stdout.write(`files: ${formatList(overview.files)}
+`);
+}
+function renderEvidenceList(overviews) {
+  process.stdout.write(`${overviews.length} evidence artifacts
+`);
+  if (overviews.length === 0) return;
+  process.stdout.write("\n");
+  for (const overview of overviews) {
+    process.stdout.write(
+      [
+        overview.evidenceId.padEnd(28),
+        formatSource(overview).padEnd(24),
+        `${overview.totals.runs} run${overview.totals.runs === 1 ? "" : "s"}`.padEnd(8),
+        formatList(overview.tags)
+      ].join("")
+    );
+    process.stdout.write("\n");
+  }
+}
+function formatSource(overview) {
+  if (overview.source.kind === "run") return `run ${overview.source.runId}`;
+  if (overview.source.kind === "session") return `session ${overview.source.sessionId}`;
+  return `eval ${overview.source.evalId}`;
+}
+function formatList(values) {
+  return values.length === 0 ? "none" : values.join(", ");
+}
+export {
+  runEvidenceCommand
+};
+//# sourceMappingURL=evidence-V67CHM35.js.map