@riddledc/riddle-proof 0.5.44 → 0.5.46

package/dist/cli.d.cts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.js

@@ -0,0 +1,160 @@
+#!/usr/bin/env node
+import {
+  createCodexExecAgentAdapter,
+  runCodexExecAgentDoctor
+} from "./chunk-NOBFZDZG.js";
+import {
+  createDisabledRiddleProofAgentAdapter,
+  readRiddleProofRunStatus,
+  runRiddleProofEngineHarness
+} from "./chunk-X3AQ2WUM.js";
+import "./chunk-4ASMX4R6.js";
+import "./chunk-JTNMEH57.js";
+import "./chunk-PLSGW2GI.js";
+import "./chunk-R6SCWJCI.js";
+import "./chunk-DUFDZJOF.js";
+
+// src/cli.ts
+import { existsSync, readFileSync } from "fs";
+function usage() {
+  return [
+    "Usage:",
+    "  riddle-proof-loop run --request-json <file|json|-> [--agent disabled|codex_exec] [--checkpoint-mode yield|auto]",
+    "  riddle-proof-loop respond --state-path <path> --response-json <file|json|->",
+    "  riddle-proof-loop status --state-path <path>",
+    "  riddle-proof-loop doctor codex_exec [--codex-command <path>]",
+    "",
+    "The default CLI run mode is checkpoint-mode=yield unless --agent codex_exec is used."
+  ].join("\n");
+}
+function parseArgs(argv) {
+  const positional = [];
+  const options = {};
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (!arg.startsWith("--")) {
+      positional.push(arg);
+      continue;
+    }
+    const key = arg.slice(2).replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+    const next = argv[index + 1];
+    if (!next || next.startsWith("--")) {
+      options[key] = true;
+      continue;
+    }
+    options[key] = next;
+    index += 1;
+  }
+  return { positional, options };
+}
+function optionString(options, key) {
+  const value = options[key];
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function readStdin() {
+  return readFileSync(0, "utf-8");
+}
+function readJsonValue(value, label) {
+  if (!value) throw new Error(`${label} is required.`);
+  const raw = value === "-" ? readStdin() : existsSync(value) ? readFileSync(value, "utf-8") : value;
+  const parsed = JSON.parse(raw);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`${label} must be a JSON object.`);
+  }
+  return parsed;
+}
+function readRunState(statePath) {
+  const parsed = readJsonValue(statePath, "--state-path");
+  if (parsed.version !== "riddle-proof.run-state.v1" || !Array.isArray(parsed.events)) {
+    throw new Error(`${statePath} is not a riddle-proof.run-state.v1 file.`);
+  }
+  return parsed;
+}
+function codexConfig(options) {
+  const codexFullAuto = optionString(options, "codexFullAuto");
+  return {
+    codexCommand: optionString(options, "codexCommand"),
+    codexHome: optionString(options, "codexHome"),
+    codexModel: optionString(options, "codexModel"),
+    codexTimeoutMs: optionString(options, "codexTimeoutMs") ? Number(optionString(options, "codexTimeoutMs")) : void 0,
+    codexSandbox: optionString(options, "codexSandbox"),
+    codexFullAuto: codexFullAuto === "false" ? false : void 0
+  };
+}
+function agentFor(options) {
+  const agentMode = optionString(options, "agent") || "disabled";
+  if (agentMode === "codex_exec") return createCodexExecAgentAdapter(codexConfig(options));
+  if (agentMode === "disabled") return createDisabledRiddleProofAgentAdapter();
+  throw new Error(`Unsupported --agent ${agentMode}. Use disabled or codex_exec.`);
+}
+function requestForRun(options) {
+  const statePath = optionString(options, "statePath");
+  if (optionString(options, "requestJson")) {
+    return readJsonValue(optionString(options, "requestJson"), "--request-json");
+  }
+  if (statePath) return readRunState(statePath).request;
+  throw new Error("--request-json is required unless --state-path points to an existing run state.");
+}
+function checkpointModeFor(options) {
+  const explicit = optionString(options, "checkpointMode");
+  if (explicit) return explicit;
+  return optionString(options, "agent") === "codex_exec" ? "auto" : "yield";
+}
+async function main() {
+  const { positional, options } = parseArgs(process.argv.slice(2));
+  const command = positional[0];
+  if (!command || command === "help" || command === "--help") {
+    process.stdout.write(`${usage()}
+`);
+    return;
+  }
+  if (command === "doctor") {
+    const subject = positional[1];
+    if (subject !== "codex_exec") throw new Error("Only `doctor codex_exec` is supported.");
+    const result = await runCodexExecAgentDoctor(codexConfig(options));
+    process.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+    process.exitCode = result.ok ? 0 : 1;
+    return;
+  }
+  if (command === "status") {
+    const statePath = optionString(options, "statePath");
+    if (!statePath) throw new Error("--state-path is required.");
+    const snapshot = readRiddleProofRunStatus(statePath);
+    if (!snapshot) throw new Error(`${statePath} is not a readable Riddle Proof run state.`);
+    process.stdout.write(`${JSON.stringify(snapshot, null, 2)}
+`);
+    return;
+  }
+  if (command === "run" || command === "respond") {
+    const statePath = optionString(options, "statePath");
+    const request = requestForRun(options);
+    const response = command === "respond" ? readJsonValue(optionString(options, "responseJson"), "--response-json") : void 0;
+    const result = await runRiddleProofEngineHarness({
+      request,
+      state_path: statePath,
+      checkpoint_response: response,
+      checkpoint_mode: checkpointModeFor(options),
+      checkpoint_visibility: optionString(options, "checkpointVisibility") || "manual",
+      max_iterations: optionString(options, "maxIterations") ? Number(optionString(options, "maxIterations")) : void 0,
+      agent: agentFor(options),
+      config: {
+        stateDir: optionString(options, "stateDir"),
+        riddleProofDir: optionString(options, "riddleProofDir"),
+        defaultReviewer: optionString(options, "defaultReviewer"),
+        defaultShipMode: optionString(options, "defaultShipMode")
+      }
+    });
+    process.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+    process.exitCode = result.ok || result.status === "awaiting_checkpoint" ? 0 : 1;
+    return;
+  }
+  throw new Error(`Unknown command: ${command}
+${usage()}`);
+}
+main().catch((error) => {
+  process.stderr.write(`${error instanceof Error ? error.message : String(error)}
+`);
+  process.exitCode = 1;
+});