@awak-app/simy-cli 0.1.0

package/src/runner.js

@@ -0,0 +1,585 @@
+import { execFile, spawn } from "node:child_process";
+import { EventEmitter } from "node:events";
+import { access } from "node:fs/promises";
+import path from "node:path";
+import { promisify } from "node:util";
+
+import {
+  collectPrEvidence,
+  createCodingLoopSnapshot,
+  parseStructuredMarker,
+  parseStructuredResult,
+  recheckPrReadiness,
+  runCodingLoop,
+} from "./orchestrator/index.js";
+import {
+  EXECUTION_IO_POLICY_VERSION,
+  executionTextSha256,
+  redactExecutionLogs,
+  redactExecutionText,
+} from "./orchestrator/execution-io.js";
+
+const execFileAsync = promisify(execFile);
+const TERMINAL_STATES = new Set([
+  "merge_ready",
+  "pr_ready_for_review",
+  "failed",
+  "blocked",
+  "waiting_human",
+]);
+
+export class LocalRunRegistry {
+  #runs = new Map();
+
+  create(run) {
+    if (this.#runs.has(run.id)) throw new Error(`Run ${run.id} already exists.`);
+    this.#runs.set(run.id, run);
+  }
+
+  get(runId) {
+    return this.#runs.get(runId) ?? null;
+  }
+
+  has(runId) {
+    return this.#runs.has(runId);
+  }
+}
+
+export function createRun({ runId, request, session, apiOrigin }) {
+  const emitter = new EventEmitter();
+  return {
+    id: runId,
+    request,
+    session,
+    apiOrigin,
+    status: "queued",
+    lastOutput: "",
+    startedAt: null,
+    completedAt: null,
+    child: null,
+    emitter,
+    pendingLedgerUpdate: null,
+    ledgerUpdateRunning: false,
+    snapshot: createCodingLoopSnapshot({
+      runId,
+      request,
+      metadata: {
+        local_orchestrator_version: 1,
+        local_output_persisted: false,
+      },
+    }),
+  };
+}
+
+export async function startLocalCodingRun(
+  run,
+  { executeAttempt, executeIndependentAudit, collectEvidence } = {},
+) {
+  if (run.child || TERMINAL_STATES.has(run.status) || run.startedAt) return;
+  run.startedAt = new Date().toISOString();
+
+  let repositoryPath;
+  try {
+    repositoryPath = await resolveRepositoryPath(run.request);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Local repository could not be resolved.";
+    run.lastOutput = message;
+    run.snapshot.final_audit = preflightAudit(message);
+    run.snapshot.events.push({
+      state: "waiting_human",
+      message: "Local repository requires configuration.",
+      detail: { code: "local_repository_not_found" },
+      occurred_at: new Date().toISOString(),
+    });
+    await updateRun(run, "waiting_human");
+    return;
+  }
+
+  const executor =
+    executeAttempt ||
+    ((context) =>
+      executeProcessAttempt({
+        ...context,
+        repositoryPath,
+        run,
+      }));
+  const independentAuditor =
+    executeIndependentAudit ||
+    ((context) =>
+      executeProcessAttempt({
+        ...context,
+        repositoryPath,
+        run,
+        marker: "SIMY_AUDIT_JSON:",
+      }));
+  const evidenceCollector =
+    collectEvidence ||
+    ((attempt) =>
+      collectPrEvidence({
+        charter: run.snapshot.charter,
+        attempt,
+        repositoryPath,
+      }));
+
+  try {
+    await runCodingLoop({
+      snapshot: run.snapshot,
+      executeAttempt: executor,
+      executeIndependentAudit: independentAuditor,
+      collectEvidence: evidenceCollector,
+      onUpdate: async (snapshot) => {
+        run.snapshot = snapshot;
+        await updateRun(run, snapshot.state);
+      },
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Local orchestration failed.";
+    emitOutput(run, message);
+    run.snapshot.events.push({
+      state: "failed",
+      message: "Local orchestration failed.",
+      detail: { error: message },
+      occurred_at: new Date().toISOString(),
+    });
+    await updateRun(run, "failed");
+  }
+}
+
+export async function recheckLocalCodingRun(run, { collectEvidence } = {}) {
+  if (!run?.snapshot?.attempts?.length) return run?.snapshot || null;
+  if (!["pr_ready_for_review", "merge_ready"].includes(run.status)) return run.snapshot;
+  const repositoryPath = await resolveRepositoryPath(run.request);
+  const evidenceCollector =
+    collectEvidence ||
+    ((attempt) =>
+      collectPrEvidence({
+        charter: run.snapshot.charter,
+        attempt,
+        repositoryPath,
+      }));
+  await recheckPrReadiness({
+    snapshot: run.snapshot,
+    collectEvidence: evidenceCollector,
+    onUpdate: async (snapshot) => {
+      run.snapshot = snapshot;
+      await updateRun(run, snapshot.state);
+    },
+  });
+  return run.snapshot;
+}
+
+async function executeProcessAttempt({
+  backend,
+  instruction,
+  repositoryPath,
+  run,
+  marker = "SIMY_RESULT_JSON:",
+}) {
+  const command = resolveBackendCommand({ backend, instruction, repositoryPath });
+  const startedAt = new Date().toISOString();
+  const stdout = [];
+  const stderr = [];
+
+  return new Promise((resolve) => {
+    let settled = false;
+    const child = command.spawn(command.bin, command.args, {
+      cwd: repositoryPath,
+      env: { ...process.env, ...command.env },
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    run.child = child;
+
+    const collect = (target, chunk) => {
+      const text = chunk.toString("utf8");
+      target.push(text);
+      emitOutput(run, text);
+    };
+    child.stdout?.on("data", (chunk) => collect(stdout, chunk));
+    child.stderr?.on("data", (chunk) => collect(stderr, chunk));
+
+    const finish = ({ exitCode = null, error = null } = {}) => {
+      if (settled) return;
+      settled = true;
+      run.child = null;
+      const rawStdout = stdout.join("");
+      const assistantText = extractAssistantText(rawStdout);
+      const parse =
+        marker === "SIMY_RESULT_JSON:"
+          ? parseStructuredResult
+          : (value) => parseStructuredMarker(value, marker);
+      const result = parse(assistantText);
+      resolve({
+        exitCode,
+        error,
+        result: Object.keys(result).length > 0 ? result : parse(rawStdout),
+        logs: [...stdout, ...stderr]
+          .join("")
+          .split(/\r?\n/)
+          .map((line) => line.trim())
+          .filter(Boolean),
+        startedAt,
+        finishedAt: new Date().toISOString(),
+      });
+    };
+
+    child.on("error", (error) => finish({ error: error.message }));
+    child.on("close", (code) => finish({ exitCode: code }));
+  });
+}
+
+function resolveBackendCommand({ backend, instruction, repositoryPath }) {
+  if (backend === "claude") {
+    const override = process.env.SIMY_CLAUDE_COMMAND;
+    if (override) return shellCommand(override, repositoryPath, instruction);
+    return {
+      bin: "claude",
+      args: ["-p", instruction, "--output-format", "stream-json", "--verbose"],
+      env: {},
+      spawn,
+    };
+  }
+
+  const override = process.env.SIMY_CODEX_COMMAND;
+  if (override) return shellCommand(override, repositoryPath, instruction);
+  return {
+    bin: "codex",
+    args: ["exec", "--json", instruction],
+    env: {},
+    spawn,
+  };
+}
+
+function shellCommand(command, cwd, instruction) {
+  return {
+    bin: process.platform === "win32" ? "cmd.exe" : "sh",
+    args: process.platform === "win32" ? ["/d", "/s", "/c", command] : ["-lc", command],
+    cwd,
+    env: { SIMY_CODING_LOOP_REQUIREMENT: instruction },
+    spawn,
+  };
+}
+
+async function resolveRepositoryPath(request) {
+  const repository = String(request.repository || "").replace(/^https?:\/\/github\.com\//, "").replace(/\.git$/, "");
+  const repoName = repository.split("/").filter(Boolean).at(-1);
+  if (!repoName) throw new Error("The coding loop did not specify a valid GitHub repository.");
+
+  const roots = [request.local_path, process.env.SIMY_REPO_ROOT, process.cwd()].filter(Boolean);
+  const candidates = new Set();
+  for (const root of roots) {
+    const resolved = path.resolve(String(root));
+    candidates.add(resolved);
+    candidates.add(path.join(resolved, repoName));
+  }
+
+  for (const candidate of candidates) {
+    if (!(await pathExists(candidate))) continue;
+    const remote = await gitRemote(candidate);
+    if (remote === repository.toLowerCase()) return candidate;
+  }
+
+  throw new Error(
+    `Repository ${repository} was not found below ${process.env.SIMY_REPO_ROOT || process.cwd()}. ` +
+      "Start simy from the repository or its workspace root, or set SIMY_REPO_ROOT.",
+  );
+}
+
+async function gitRemote(cwd) {
+  try {
+    const { stdout } = await execFileAsync("git", ["remote", "get-url", "origin"], { cwd });
+    return normalizeGitHubRemote(stdout);
+  } catch {
+    return null;
+  }
+}
+
+function normalizeGitHubRemote(value) {
+  return String(value || "")
+    .trim()
+    .replace(/^git@github\.com:/, "")
+    .replace(/^ssh:\/\/git@github\.com\//, "")
+    .replace(/^https?:\/\/github\.com\//, "")
+    .replace(/\.git$/, "")
+    .toLowerCase();
+}
+
+async function pathExists(value) {
+  try {
+    await access(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function extractAssistantText(raw) {
+  const messages = [];
+  for (const line of String(raw || "").split(/\r?\n/)) {
+    if (!line.trim().startsWith("{")) continue;
+    try {
+      const item = JSON.parse(line);
+      if (item.type === "result" && typeof item.result === "string") messages.push(item.result);
+      if (item.type === "item.completed" && item.item?.type === "agent_message") {
+        if (typeof item.item.text === "string") messages.push(item.item.text);
+      }
+      if (item.type === "assistant" && typeof item.message?.content === "string") {
+        messages.push(item.message.content);
+      }
+    } catch {
+      // Non-JSON executor output is still available to the fallback parser.
+    }
+  }
+  return messages.join("\n");
+}
+
+function emitOutput(run, text) {
+  for (const line of String(text).split(/\r?\n/)) {
+    if (!line.trim()) continue;
+    run.lastOutput = line;
+    run.emitter.emit("event", {
+      type: "output",
+      run_id: run.id,
+      backend: run.request.backend,
+      text: line,
+      occurred_at: new Date().toISOString(),
+    });
+  }
+}
+
+async function updateRun(run, state) {
+  run.status = state;
+  run.snapshot.state = state;
+  run.snapshot.updated_at = new Date().toISOString();
+  run.completedAt = TERMINAL_STATES.has(state) ? run.snapshot.updated_at : null;
+
+  run.emitter.emit("event", { type: "run", run: toLedgerSnapshot(run.snapshot) });
+  const latestEvent = run.snapshot.events.at(-1);
+  run.emitter.emit("event", {
+    type: "status",
+    run_id: run.id,
+    state: toCompatibleCodingLoopState(state),
+    message: latestEvent?.message || "Local SIMY CLI status update.",
+    detail: {
+      ...(latestEvent?.detail || {}),
+      pr_lifecycle_state: state,
+    },
+    last_agent_output: run.lastOutput,
+    occurred_at: run.snapshot.updated_at,
+  });
+  queueLedgerUpdate(run);
+}
+
+function queueLedgerUpdate(run) {
+  if (!run.session?.token || !run.apiOrigin) return;
+  run.pendingLedgerUpdate = {
+    state: toCompatibleCodingLoopState(run.status),
+    completedAt: run.completedAt,
+    snapshot: toLedgerSnapshot(run.snapshot),
+  };
+  if (run.ledgerUpdateRunning) return;
+  run.ledgerUpdateRunning = true;
+  void drainLedgerUpdates(run);
+}
+
+async function drainLedgerUpdates(run) {
+  try {
+    while (run.pendingLedgerUpdate) {
+      const update = run.pendingLedgerUpdate;
+      run.pendingLedgerUpdate = null;
+      await persistRunStatus(run, update);
+    }
+  } finally {
+    run.ledgerUpdateRunning = false;
+    if (run.pendingLedgerUpdate) queueLedgerUpdate(run);
+  }
+}
+
+async function persistRunStatus(run, update) {
+  const url = new URL(`/api/local-cli/runs/${encodeURIComponent(run.id)}/status`, run.apiOrigin);
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      signal: AbortSignal.timeout(5000),
+      headers: {
+        Authorization: `Bearer ${run.session.token}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        state: update.state,
+        last_agent_output: redactExecutionText(run.lastOutput, { maxChars: 2_000 }).text || null,
+        completed_at: update.completedAt,
+        run: update.snapshot,
+      }),
+    });
+    if (!response.ok) {
+      emitOutput(run, `SIMY ledger update failed with HTTP ${response.status}.`);
+    }
+  } catch {
+    // The local snapshot remains authoritative while the CLI is running.
+  }
+}
+
+export function toLedgerSnapshot(snapshot) {
+  return {
+    ...snapshot,
+    state: toCompatibleCodingLoopState(snapshot.state),
+    attempts: snapshot.attempts.map(redactedAttemptForLedger),
+    events: snapshot.events.map((item) => ({
+      ...item,
+      state: toCompatibleCodingLoopState(item.state),
+      detail: redactedEventDetail(item.detail, item.state),
+    })),
+    metadata: {
+      ...(snapshot.metadata || {}),
+      pr_lifecycle_state: snapshot.state,
+      last_agent_output: null,
+      local_output_persisted: true,
+      execution_io_persistence: "redacted",
+      execution_io_policy_version: EXECUTION_IO_POLICY_VERSION,
+    },
+  };
+}
+
+function redactedAttemptForLedger(attempt) {
+  const instruction = redactExecutionText(attempt.instruction);
+  const executorLogs = redactExecutionLogs(attempt.executor_logs);
+  const logText = executorLogs.lines.join("\n");
+  return {
+    ...attempt,
+    instruction: instruction.text,
+    instruction_sha256: executionTextSha256(instruction.text),
+    executor_logs: executorLogs.lines,
+    executor_logs_sha256: executionTextSha256(logText),
+    io_redaction: {
+      policy_version: EXECUTION_IO_POLICY_VERSION,
+      instruction_redacted: instruction.redacted,
+      instruction_truncated: instruction.truncated,
+      executor_logs_redacted: executorLogs.redacted,
+      executor_logs_truncated: executorLogs.truncated,
+    },
+    raw_output: structuredResultForLedger(attempt.raw_output),
+    observed_evidence: observedEvidenceForLedger(attempt.observed_evidence),
+  };
+}
+
+function redactedEventDetail(value, lifecycleState) {
+  const detail = value && typeof value === "object" ? value : {};
+  const result = {};
+  for (const [key, item] of Object.entries(detail)) {
+    if (["instruction", "reinstruction", "prompt", "last_agent_output"].includes(key)) {
+      result[key] = redactExecutionText(item, { maxChars: 24_000 }).text;
+    } else if (["executor_logs", "stdout", "stderr"].includes(key)) {
+      const logs = Array.isArray(item) ? item : [item];
+      result[key] = redactExecutionLogs(logs).lines;
+    } else {
+      result[key] = item;
+    }
+  }
+  result.pr_lifecycle_state = lifecycleState;
+  return result;
+}
+
+function observedEvidenceForLedger(value) {
+  if (!value || typeof value !== "object") return null;
+  const local = value.local && typeof value.local === "object" ? value.local : {};
+  const github = value.github && typeof value.github === "object" ? value.github : {};
+  return {
+    collected_at: value.collected_at || null,
+    local: {
+      available: local.available === true,
+      head_sha: local.head_sha || null,
+      branch_name: local.branch_name || null,
+      commit_headline: local.commit_headline || null,
+      working_tree_clean: local.working_tree_clean === true,
+      changed_files: stringArrayForLedger(local.changed_files),
+    },
+    github: {
+      available: github.available === true,
+      url: github.url || null,
+      number: Number.isInteger(github.number) ? github.number : null,
+      title: github.title || null,
+      repository: github.repository || null,
+      is_draft: github.is_draft === true,
+      mergeable: github.mergeable || null,
+      merge_state_status: github.merge_state_status || null,
+      review_decision: github.review_decision || null,
+      approvals: stringArrayForLedger(github.approvals),
+      head_branch: github.head_branch || null,
+      head_sha: github.head_sha || null,
+      base_branch: github.base_branch || null,
+      checks: Array.isArray(github.checks) ? github.checks : [],
+      checks_present: github.checks_present === true,
+      checks_passing: github.checks_passing === true,
+      required_checks_present: github.required_checks_present === true,
+    },
+  };
+}
+
+function stringArrayForLedger(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+
+export function toCompatibleCodingLoopState(state) {
+  switch (state) {
+    case "risk_classifying":
+      return "chartering";
+    case "independent_auditing":
+    case "checking_pr":
+      return "auditing";
+    case "pr_ready_for_review":
+      return "waiting_human";
+    case "merge_ready":
+      return "done";
+    default:
+      return state;
+  }
+}
+
+function structuredResultForLedger(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  const allowed = new Set([
+    "outcome_kind",
+    "summary",
+    "branch_name",
+    "commit_sha",
+    "commit_message_headline",
+    "pr_url",
+    "pr_number",
+    "pr_title",
+    "pr_base_branch",
+    "tests_run",
+    "tests_passed",
+    "ui_evidence_path",
+    "unrelated_changes_detected",
+    "secret_scan_passed",
+    "changed_files",
+    "residual_risks",
+    "blocked",
+  ]);
+  return Object.fromEntries(Object.entries(value).filter(([key]) => allowed.has(key)));
+}
+
+function preflightAudit(message) {
+  const finding = {
+    code: "LOCAL_REPOSITORY_NOT_FOUND",
+    title: "Local repository not found",
+    severity: "blocker",
+    target: "repository",
+    explanation: message,
+    repairability: "manual",
+    auto_fix_hint: null,
+  };
+  return {
+    passed: false,
+    summary: "Local execution requires a verified repository checkout.",
+    evaluations: [],
+    findings: [finding],
+    auto_repairable: false,
+    requires_human: true,
+    reinstruction: null,
+    evidence_artifacts: [],
+    release_gate: null,
+    work_log_signals: [],
+    work_log_interventions: [],
+  };
+}

package/src/session-store.js

@@ -0,0 +1,41 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+
+const SESSION_PATH = join(homedir(), ".simy", "session.json");
+const SESSION_TTL_MS = 48 * 60 * 60 * 1000;
+
+export function sessionPath() {
+  return SESSION_PATH;
+}
+
+export function expiresAtFromNow(now = Date.now()) {
+  return new Date(now + SESSION_TTL_MS).toISOString();
+}
+
+export async function readSession() {
+  try {
+    const raw = await readFile(SESSION_PATH, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") return null;
+    if (typeof parsed.token !== "string" || typeof parsed.expires_at !== "string") return null;
+    return parsed;
+  } catch (err) {
+    if (err && err.code === "ENOENT") return null;
+    throw err;
+  }
+}
+
+export function isSessionValid(session, now = Date.now()) {
+  if (!session?.expires_at) return false;
+  const expiresAt = Date.parse(session.expires_at);
+  return Number.isFinite(expiresAt) && expiresAt > now;
+}
+
+export async function writeSession(session) {
+  await mkdir(dirname(SESSION_PATH), { recursive: true, mode: 0o700 });
+  await writeFile(SESSION_PATH, `${JSON.stringify(session, null, 2)}\n`, {
+    encoding: "utf8",
+    mode: 0o600,
+  });
+}