@riddledc/riddle-proof 0.1.1 → 0.3.0

package/dist/result.js

@@ -7,7 +7,7 @@ import {
   nonEmptyString,
   normalizeTerminalMetadata,
   recordValue
-} from "./chunk-2ZQNXVQC.js";
+} from "./chunk-5DC6YXN4.js";
 export {
   applyTerminalMetadata,
   compactRecord,

package/dist/runner.cjs

@@ -0,0 +1,697 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/runner.ts
+var runner_exports = {};
+__export(runner_exports, {
+  runRiddleProof: () => runRiddleProof
+});
+module.exports = __toCommonJS(runner_exports);
+
+// src/result.ts
+function isSuccessfulStatus(status) {
+  return status !== "blocked" && status !== "failed";
+}
+function compactRecord(input) {
+  return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== void 0 && value !== null && value !== ""));
+}
+function nonEmptyString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function recordValue(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function applyTerminalMetadata(state, metadata) {
+  const prUrl = nonEmptyString(metadata.pr_url);
+  if (prUrl) state.pr_url = prUrl;
+  if (typeof metadata.marked_ready === "boolean") state.marked_ready = metadata.marked_ready;
+  const notification = recordValue(metadata.notification);
+  if (notification) state.notification = notification;
+  const proofDecision = nonEmptyString(metadata.proof_decision);
+  if (proofDecision) state.proof_decision = proofDecision;
+  const mergeRecommendation = nonEmptyString(metadata.merge_recommendation);
+  if (mergeRecommendation) state.merge_recommendation = mergeRecommendation;
+  if (typeof metadata.finalized === "boolean") state.finalized = metadata.finalized;
+  return state;
+}
+function createRunResult(input) {
+  const status = input.status || input.state.status;
+  const ok = isSuccessfulStatus(status);
+  const state = input.metadata ? applyTerminalMetadata(input.state, input.metadata) : input.state;
+  state.status = status;
+  state.ok = ok;
+  return compactRecord({
+    ok,
+    status,
+    run_id: state.run_id,
+    state_path: input.state_path ?? state.state_path ?? null,
+    worktree_path: state.worktree_path ?? null,
+    branch: state.branch ?? null,
+    current_stage: state.current_stage ?? null,
+    iterations: state.iterations,
+    last_checkpoint: state.last_checkpoint ?? null,
+    last_summary: input.last_summary ?? null,
+    event_count: state.events.length,
+    pr_url: state.pr_url,
+    marked_ready: state.marked_ready,
+    notification: state.notification,
+    proof_decision: state.proof_decision,
+    merge_recommendation: state.merge_recommendation,
+    finalized: state.finalized,
+    blocker: state.blocker,
+    evidence_bundle: input.evidence_bundle,
+    raw: input.raw
+  });
+}
+
+// src/state.ts
+var RIDDLE_PROOF_RUN_STATE_VERSION = "riddle-proof.run-state.v1";
+function timestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function createRunId(createdAt) {
+  const stamp = createdAt.replace(/\D/g, "").slice(0, 14) || "unknown";
+  const entropy = Math.random().toString(36).slice(2, 8) || "run";
+  return `rp_${stamp}_${entropy}`;
+}
+function elapsedMs(start, end) {
+  const startMs = start ? Date.parse(start) : NaN;
+  const endMs = end ? Date.parse(end) : NaN;
+  if (!Number.isFinite(startMs) || !Number.isFinite(endMs)) return void 0;
+  return Math.max(0, endMs - startMs);
+}
+function normalizeIntegrationContext(input, fallbackSource) {
+  const value = recordValue(input);
+  if (!value) {
+    return fallbackSource ? { source: fallbackSource } : void 0;
+  }
+  const metadata = recordValue(value.metadata);
+  return compactRecord({
+    source: nonEmptyString(value.source) || fallbackSource,
+    channel_id: nonEmptyString(value.channel_id),
+    thread_id: nonEmptyString(value.thread_id),
+    message_id: nonEmptyString(value.message_id),
+    source_url: nonEmptyString(value.source_url),
+    metadata: metadata && Object.keys(metadata).length ? metadata : void 0
+  });
+}
+function normalizeRunParams(input) {
+  return compactRecord({
+    repo: input.repo,
+    branch: input.branch,
+    change_request: input.change_request,
+    commit_message: input.commit_message,
+    prod_url: input.prod_url,
+    capture_script: input.capture_script,
+    success_criteria: input.success_criteria,
+    assertions: input.assertions,
+    verification_mode: input.verification_mode,
+    reference: input.reference,
+    base_branch: input.base_branch,
+    before_ref: input.before_ref,
+    allow_static_preview_fallback: input.allow_static_preview_fallback,
+    context: input.context,
+    reviewer: input.reviewer,
+    mode: input.mode,
+    build_command: input.build_command,
+    build_output: input.build_output,
+    server_image: input.server_image,
+    server_command: input.server_command,
+    server_port: input.server_port,
+    server_path: input.server_path,
+    use_auth: input.use_auth,
+    color_scheme: input.color_scheme,
+    wait_for_selector: input.wait_for_selector,
+    ship_mode: input.ship_mode,
+    integration_context: normalizeIntegrationContext(input.integration_context)
+  });
+}
+function createRunState(input) {
+  const createdAt = input.created_at || timestamp();
+  return compactRecord({
+    version: RIDDLE_PROOF_RUN_STATE_VERSION,
+    run_id: input.run_id || createRunId(createdAt),
+    state_path: input.state_path,
+    worktree_path: input.worktree_path,
+    branch: input.branch || input.request.branch,
+    current_stage: input.current_stage ?? null,
+    stage_started_at: input.stage_started_at ?? null,
+    status: input.status || "running",
+    created_at: createdAt,
+    updated_at: input.updated_at || createdAt,
+    request: normalizeRunParams(input.request),
+    iterations: input.iterations ?? 0,
+    last_checkpoint: input.last_checkpoint ?? null,
+    events: input.events ? [...input.events] : []
+  });
+}
+function appendRunEvent(state, input) {
+  const event = {
+    ts: input.ts || timestamp(),
+    kind: input.kind,
+    checkpoint: input.checkpoint,
+    stage: input.stage,
+    summary: input.summary,
+    details: input.details
+  };
+  state.events.push(compactRecord({
+    ts: event.ts,
+    kind: event.kind,
+    checkpoint: event.checkpoint,
+    stage: event.stage,
+    summary: event.summary,
+    details: event.details
+  }));
+  if (input.checkpoint !== void 0) state.last_checkpoint = input.checkpoint;
+  if (input.stage !== void 0) {
+    if (state.current_stage !== input.stage) state.stage_started_at = event.ts;
+    state.current_stage = input.stage;
+  }
+  state.updated_at = event.ts;
+  return state;
+}
+function appendStageHeartbeat(state, input) {
+  const at = input.ts || timestamp();
+  return appendRunEvent(state, {
+    ts: at,
+    kind: "stage.heartbeat",
+    checkpoint: input.checkpoint || `${input.stage}_heartbeat`,
+    stage: input.stage,
+    summary: input.summary || `${input.stage} stage is active.`,
+    details: compactRecord({
+      elapsed_ms: elapsedMs(state.created_at, at),
+      stage_elapsed_ms: elapsedMs(state.stage_started_at, at),
+      wait_reason: input.wait_reason,
+      blocker: input.blocker,
+      ...input.details
+    })
+  });
+}
+function setRunStatus(state, status, at = timestamp()) {
+  state.status = status;
+  state.ok = status !== "blocked" && status !== "failed";
+  state.updated_at = at;
+  return state;
+}
+
+// src/runner.ts
+function errorDetails(error) {
+  if (error instanceof Error) {
+    return {
+      name: error.name,
+      message: error.message
+    };
+  }
+  return { message: String(error) };
+}
+function adapterBlocker(code, message, checkpoint, details) {
+  return {
+    code,
+    message,
+    checkpoint,
+    details
+  };
+}
+function blockRun(input) {
+  input.state.blocker = input.blocker;
+  appendRunEvent(input.state, {
+    kind: "run.blocked",
+    checkpoint: input.blocker.checkpoint,
+    stage: input.stage,
+    summary: input.blocker.message,
+    details: {
+      code: input.blocker.code,
+      ...input.blocker.details
+    }
+  });
+  setRunStatus(input.state, "blocked");
+  return createRunResult({
+    state: input.state,
+    status: "blocked",
+    last_summary: input.blocker.message,
+    evidence_bundle: input.evidence_bundle,
+    raw: input.raw
+  });
+}
+function shouldIterate(assessment) {
+  const nextStage = assessment.continue_with_stage || assessment.recommended_stage;
+  return nextStage === "implement" || nextStage === "author";
+}
+async function notifyIfConfigured(input) {
+  if (!input.notification) return input.result;
+  try {
+    const notification = await input.notification.notify({
+      state: input.state,
+      result: input.result
+    });
+    input.state.notification = notification;
+    appendRunEvent(input.state, {
+      kind: "notification.completed",
+      checkpoint: "notification_completed",
+      stage: "notify",
+      summary: "Integration notification completed."
+    });
+  } catch (error) {
+    appendRunEvent(input.state, {
+      kind: "notification.failed",
+      checkpoint: "notification_failed",
+      stage: "notify",
+      summary: "Integration notification failed.",
+      details: errorDetails(error)
+    });
+  }
+  return createRunResult({
+    state: input.state,
+    status: input.state.status,
+    last_summary: input.result.last_summary,
+    evidence_bundle: input.result.evidence_bundle,
+    raw: input.result.raw
+  });
+}
+async function runRiddleProof(input) {
+  const state = input.state || createRunState({
+    request: input.request,
+    state_path: input.state_path,
+    worktree_path: input.workdir
+  });
+  const adapters = input.adapters || {};
+  const maxIterations = Math.max(1, Math.trunc(input.max_iterations ?? 1));
+  appendRunEvent(state, {
+    kind: "run.started",
+    checkpoint: "run_started",
+    stage: "setup",
+    summary: "Riddle Proof run started.",
+    details: {
+      run_id: state.run_id,
+      state_path: state.state_path,
+      worktree_path: state.worktree_path,
+      branch: state.branch,
+      max_iterations: maxIterations,
+      ship_mode: state.request.ship_mode || "none"
+    }
+  });
+  appendStageHeartbeat(state, {
+    stage: "setup",
+    summary: "Setup stage is active.",
+    details: {
+      run_id: state.run_id,
+      state_path: state.state_path,
+      worktree_path: state.worktree_path,
+      branch: state.branch
+    }
+  });
+  let workdir = input.workdir;
+  let evidenceContext;
+  if (adapters.preflight) {
+    appendRunEvent(state, {
+      kind: "preflight.started",
+      checkpoint: "preflight_started",
+      stage: "preflight",
+      summary: "Riddle Proof preflight adapter started."
+    });
+    try {
+      const preflight = await adapters.preflight.preflight({ request: state.request, state });
+      if (!preflight.ok) {
+        return blockRun({
+          state,
+          stage: "preflight",
+          blocker: adapterBlocker(
+            "preflight_failed",
+            "The preflight adapter found blocking tool or model configuration issues.",
+            "preflight_failed",
+            {
+              blockers: preflight.blockers,
+              warnings: preflight.warnings,
+              degraded_capabilities: preflight.degraded_capabilities
+            }
+          ),
+          raw: { preflight }
+        });
+      }
+      appendRunEvent(state, {
+        kind: "preflight.completed",
+        checkpoint: "preflight_completed",
+        stage: "preflight",
+        summary: "Riddle Proof preflight adapter completed.",
+        details: {
+          warnings: preflight.warnings,
+          degraded_capabilities: preflight.degraded_capabilities
+        }
+      });
+    } catch (error) {
+      return blockRun({
+        state,
+        stage: "preflight",
+        blocker: adapterBlocker("preflight_exception", "The preflight adapter threw an exception.", "preflight_failed", errorDetails(error))
+      });
+    }
+  }
+  if (adapters.setup) {
+    appendRunEvent(state, {
+      kind: "setup.started",
+      checkpoint: "setup_started",
+      stage: "setup",
+      summary: "Riddle Proof setup adapter started."
+    });
+    try {
+      const setup = await adapters.setup.setup({ request: state.request, state });
+      if (!setup.ok) {
+        return blockRun({
+          state,
+          stage: "setup",
+          blocker: adapterBlocker(
+            "setup_failed",
+            "The setup adapter did not complete successfully.",
+            "setup_failed",
+            { blockers: setup.blockers }
+          ),
+          raw: { setup }
+        });
+      }
+      workdir = setup.worktree_path || setup.workdir || workdir;
+      state.worktree_path = setup.worktree_path || setup.workdir || state.worktree_path;
+      state.branch = setup.branch || state.branch;
+      evidenceContext = setup.evidence_context;
+      appendRunEvent(state, {
+        kind: "setup.completed",
+        checkpoint: "setup_completed",
+        stage: "setup",
+        summary: "Riddle Proof setup adapter completed.",
+        details: {
+          has_workdir: Boolean(workdir),
+          worktree_path: state.worktree_path,
+          branch: state.branch,
+          cleanup_policy: setup.cleanup_policy,
+          has_evidence_context: Boolean(evidenceContext)
+        }
+      });
+    } catch (error) {
+      return blockRun({
+        state,
+        stage: "setup",
+        blocker: adapterBlocker("setup_exception", "The setup adapter threw an exception.", "setup_failed", errorDetails(error))
+      });
+    }
+  }
+  const changeRequest = state.request.change_request?.trim();
+  if (!changeRequest) {
+    return blockRun({
+      state,
+      stage: "setup",
+      blocker: adapterBlocker("change_request_required", "A change request is required before implementation.", "request_invalid")
+    });
+  }
+  if (!workdir) {
+    return blockRun({
+      state,
+      stage: "setup",
+      blocker: adapterBlocker("workdir_not_configured", "A workdir or setup adapter result is required before implementation.", "setup_required")
+    });
+  }
+  if (!adapters.implementation) {
+    return blockRun({
+      state,
+      stage: "implement",
+      blocker: adapterBlocker("implementation_adapter_not_configured", "An implementation adapter is required to change code.", "implementation_required")
+    });
+  }
+  if (!adapters.proof) {
+    return blockRun({
+      state,
+      stage: "prove",
+      blocker: adapterBlocker("proof_adapter_not_configured", "A proof adapter is required to capture evidence.", "proof_required")
+    });
+  }
+  if (!adapters.judge) {
+    return blockRun({
+      state,
+      stage: "verify",
+      blocker: adapterBlocker("judge_adapter_not_configured", "A judge adapter is required to assess proof.", "judge_required")
+    });
+  }
+  let implementation;
+  let evidenceBundle;
+  let assessment;
+  for (let attempt = 0; attempt < maxIterations; attempt += 1) {
+    state.iterations += 1;
+    appendStageHeartbeat(state, {
+      stage: "implement",
+      summary: "Implementation stage is active.",
+      details: { iteration: state.iterations }
+    });
+    appendRunEvent(state, {
+      kind: "implementation.started",
+      checkpoint: "implementation_started",
+      stage: "implement",
+      summary: "Implementation adapter started.",
+      details: { iteration: state.iterations }
+    });
+    try {
+      implementation = await adapters.implementation.implement({
+        workdir,
+        change_request: changeRequest,
+        evidence_context: evidenceContext,
+        state
+      });
+    } catch (error) {
+      return blockRun({
+        state,
+        stage: "implement",
+        blocker: adapterBlocker("implementation_exception", "The implementation adapter threw an exception.", "implementation_failed", errorDetails(error)),
+        evidence_bundle: evidenceBundle
+      });
+    }
+    if (!implementation.ok) {
+      return blockRun({
+        state,
+        stage: "implement",
+        blocker: adapterBlocker(
+          "implementation_failed",
+          "The implementation adapter did not complete successfully.",
+          "implementation_failed",
+          { blockers: implementation.blockers }
+        ),
+        evidence_bundle: evidenceBundle,
+        raw: { implementation }
+      });
+    }
+    appendRunEvent(state, {
+      kind: "implementation.completed",
+      checkpoint: "implementation_completed",
+      stage: "implement",
+      summary: "Implementation adapter completed.",
+      details: {
+        changed_files: implementation.changed_files,
+        tests_run: implementation.tests_run
+      }
+    });
+    appendStageHeartbeat(state, {
+      stage: "prove",
+      summary: "Proof capture stage is active.",
+      details: {
+        verification_mode: state.request.verification_mode
+      }
+    });
+    appendRunEvent(state, {
+      kind: "proof.started",
+      checkpoint: "proof_started",
+      stage: "prove",
+      summary: "Proof adapter started."
+    });
+    try {
+      const proof = await adapters.proof.prove({
+        state,
+        implementation,
+        evidence_context: evidenceContext
+      });
+      if (!proof.ok || !proof.evidence_bundle) {
+        return blockRun({
+          state,
+          stage: "prove",
+          blocker: adapterBlocker(
+            "proof_failed",
+            "The proof adapter did not produce a usable evidence bundle.",
+            "proof_failed",
+            { blockers: proof.blockers }
+          ),
+          raw: { proof }
+        });
+      }
+      evidenceBundle = proof.evidence_bundle;
+      appendRunEvent(state, {
+        kind: "proof.completed",
+        checkpoint: "proof_completed",
+        stage: "prove",
+        summary: "Proof adapter completed.",
+        details: {
+          verification_mode: evidenceBundle.verification_mode,
+          artifact_count: evidenceBundle.artifacts?.length ?? 0
+        }
+      });
+    } catch (error) {
+      return blockRun({
+        state,
+        stage: "prove",
+        blocker: adapterBlocker("proof_exception", "The proof adapter threw an exception.", "proof_failed", errorDetails(error))
+      });
+    }
+    appendRunEvent(state, {
+      kind: "judge.started",
+      checkpoint: "judge_started",
+      stage: "verify",
+      summary: "Judge adapter started."
+    });
+    appendStageHeartbeat(state, {
+      stage: "verify",
+      summary: "Verification stage is active.",
+      details: {
+        verification_mode: evidenceBundle.verification_mode
+      }
+    });
+    try {
+      assessment = await adapters.judge.assessProof({ state, evidence_bundle: evidenceBundle });
+      state.proof_decision = assessment.decision;
+      appendRunEvent(state, {
+        kind: "judge.completed",
+        checkpoint: "judge_completed",
+        stage: "verify",
+        summary: assessment.summary,
+        details: {
+          decision: assessment.decision,
+          recommended_stage: assessment.recommended_stage,
+          continue_with_stage: assessment.continue_with_stage,
+          reasons: assessment.reasons
+        }
+      });
+    } catch (error) {
+      return blockRun({
+        state,
+        stage: "verify",
+        blocker: adapterBlocker("judge_exception", "The judge adapter threw an exception.", "judge_failed", errorDetails(error)),
+        evidence_bundle: evidenceBundle
+      });
+    }
+    if (assessment.decision === "ready_to_ship") break;
+    if (attempt + 1 < maxIterations && shouldIterate(assessment)) {
+      evidenceContext = evidenceBundle;
+      appendRunEvent(state, {
+        kind: "run.iterating",
+        checkpoint: "iteration_requested",
+        stage: "implement",
+        summary: "Judge requested another implementation iteration.",
+        details: {
+          decision: assessment.decision,
+          next_iteration: state.iterations + 1
+        }
+      });
+      continue;
+    }
+    return blockRun({
+      state,
+      stage: "verify",
+      blocker: adapterBlocker(
+        "proof_not_ready",
+        assessment.summary || "Proof is not ready to ship.",
+        "judge_completed",
+        {
+          decision: assessment.decision,
+          recommended_stage: assessment.recommended_stage,
+          continue_with_stage: assessment.continue_with_stage,
+          reasons: assessment.reasons
+        }
+      ),
+      evidence_bundle: evidenceBundle,
+      raw: { assessment }
+    });
+  }
+  if (!assessment || !evidenceBundle) {
+    return blockRun({
+      state,
+      stage: "verify",
+      blocker: adapterBlocker("runner_incomplete", "The runner ended without proof assessment.", "runner_incomplete")
+    });
+  }
+  if (state.request.ship_mode !== "ship") {
+    setRunStatus(state, "ready_to_ship");
+    const result2 = createRunResult({
+      state,
+      status: "ready_to_ship",
+      last_summary: assessment.summary,
+      evidence_bundle: evidenceBundle,
+      raw: { implementation, assessment }
+    });
+    return notifyIfConfigured({ state, result: result2, notification: adapters.notification });
+  }
+  if (!adapters.ship) {
+    return blockRun({
+      state,
+      stage: "ship",
+      blocker: adapterBlocker("ship_adapter_not_configured", "A ship adapter is required when ship_mode is ship.", "ship_required"),
+      evidence_bundle: evidenceBundle,
+      raw: { implementation, assessment }
+    });
+  }
+  appendRunEvent(state, {
+    kind: "ship.started",
+    checkpoint: "ship_started",
+    stage: "ship",
+    summary: "Ship adapter started."
+  });
+  appendStageHeartbeat(state, {
+    stage: "ship",
+    summary: "Ship stage is active."
+  });
+  let metadata;
+  try {
+    metadata = await adapters.ship.ship({ state, assessment });
+  } catch (error) {
+    return blockRun({
+      state,
+      stage: "ship",
+      blocker: adapterBlocker("ship_exception", "The ship adapter threw an exception.", "ship_failed", errorDetails(error)),
+      evidence_bundle: evidenceBundle,
+      raw: { implementation, assessment }
+    });
+  }
+  appendRunEvent(state, {
+    kind: "ship.completed",
+    checkpoint: "ship_completed",
+    stage: "ship",
+    summary: "Ship adapter completed.",
+    details: {
+      pr_url: metadata.pr_url,
+      marked_ready: metadata.marked_ready,
+      finalized: metadata.finalized
+    }
+  });
+  setRunStatus(state, "shipped");
+  const result = createRunResult({
+    state,
+    status: "shipped",
+    last_summary: "Riddle Proof shipped.",
+    metadata,
+    evidence_bundle: evidenceBundle,
+    raw: { implementation, assessment }
+  });
+  return notifyIfConfigured({ state, result, notification: adapters.notification });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runRiddleProof
+});