jeo-code 0.1.0 → 0.4.5

package/src/commands/ultragoal.ts

@@ -1,102 +1,163 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
-import { readWorkflowState, getLocalJocDir } from "../agent/state";
+import { readWorkflowState, writeWorkflowState, getLocalJeoDir, type WorkflowState } from "../agent/state";
 import { bashTool } from "../agent/tools";
+import { parseSeedAcceptanceCriteria } from "../agent/seed";
 
-export async function runUltragoalCommand(): Promise<void> {
-  const cwd = process.cwd();
+export interface UltragoalEngineOptions {
+  cwd?: string;
+  signal?: AbortSignal;
+  onProgress?: (e: { skill: string; phase: string; detail?: string }) => void;
+  io?: {
+    output?: (line: string) => void;
+  };
+}
+
+export async function runUltragoalEngine(opts: UltragoalEngineOptions = {}): Promise<{ ok: boolean; reason?: string }> {
+  const cwd = opts.cwd ?? process.cwd();
+
+  const log = (msg?: any) => {
+    const str = msg !== undefined ? String(msg) : "";
+    if (opts.io?.output) {
+      const lines = str.split("\n");
+      for (const line of lines) {
+        opts.io.output(line);
+      }
+    } else {
+      console.log(str);
+    }
+  };
+
+  if (opts.onProgress) {
+    opts.onProgress({ skill: "ultragoal", phase: "start" });
+  }
+
+  if (opts.signal?.aborted) {
+    return { ok: false, reason: "aborted" };
+  }
 
   // Read state to find acceptance criteria
   const interviewState = await readWorkflowState("deep-interview", cwd);
   if (!interviewState || !interviewState.seed_path) {
-    console.log(
-      `[ERROR] No crystallized requirements found. Please run 'joc deep-interview' first.`
+    log(
+      `[ERROR] No crystallized requirements found. Please run 'jeo deep-interview' first.`
     );
-    return;
+    return { ok: false, reason: "No crystallized requirements found" };
   }
 
   const seedPath = interviewState.seed_path;
-  console.log(`\n=== Starting Ultragoal Verification Stage ===`);
-  console.log(`Reading requirements and acceptance criteria from: ${seedPath}`);
+  log(`\n=== Starting Ultragoal Verification Stage ===`);
+  log(`Reading requirements and acceptance criteria from: ${seedPath}`);
+
+  // Thread team execution state: verification should run AFTER the plan was executed.
+  const teamState = await readWorkflowState("team", cwd);
+  if (!teamState || teamState.current_phase !== "complete") {
+    log(
+      `[WARN] No completed 'jeo team' execution found (run deep-interview → ralplan → approve → team first).\n` +
+      `       Verifying current repository state anyway — results reflect whatever is on disk now.`
+    );
+  } else {
+    log(`Verifying against team execution (plan: ${teamState.plan_path ?? "?"}).`);
+  }
 
   let seedContent = "";
   try {
     seedContent = await fs.readFile(seedPath, "utf-8");
   } catch (err: any) {
-    console.log(`[ERROR] Failed to read seed file: ${err.message}`);
-    return;
+    log(`[ERROR] Failed to read seed file: ${err.message}`);
+    return { ok: false, reason: err.message };
   }
 
-  // Parse acceptance criteria from seed YAML
-  const criteria: string[] = [];
-  const lines = seedContent.split("\n");
-  let parsingCriteria = false;
-  for (const line of lines) {
-    const trimmed = line.trim();
-    if (trimmed.startsWith("acceptance_criteria:")) {
-      parsingCriteria = true;
-      continue;
-    }
-    if (parsingCriteria) {
-      if (trimmed.startsWith("-")) {
-        criteria.push(trimmed.replace(/^-\s*/, "").replace(/"/g, "").trim());
-      } else if (trimmed === "" || trimmed.includes(":")) {
-        // End of list or next section
-        parsingCriteria = false;
-      }
-    }
-  }
+  // Parse acceptance criteria via the SHARED seed module (round-12) — the old
+  // inline scan stripped EVERY double quote and mangled criteria like
+  // `Display "Done" message`; the shared parser JSON-decodes what the
+  // deep-interview writer JSON-encoded, so values round-trip exactly.
+  const criteria: string[] = parseSeedAcceptanceCriteria(seedContent);
 
   if (criteria.length === 0) {
     criteria.push("Runs successfully in the terminal");
   }
 
-  console.log(`Loaded ${criteria.length} acceptance criteria for verification.\n`);
+  log(`Loaded ${criteria.length} acceptance criteria for verification.\n`);
 
-  const results: { criterion: string; passed: boolean; output: string }[] = [];
-
-  for (const criterion of criteria) {
-    console.log(`[CHECK] Verifying: "${criterion}"`);
-    
-    // We can execute a automatic verification pass.
-    // E.g., if there are tests, we run bun test. If not, we do a smoke check by running bun src/cli.ts setup or compile.
-    let cmd = "bun test";
-    if (criterion.toLowerCase().includes("run") || criterion.toLowerCase().includes("cli")) {
-      cmd = "bun run src/cli.ts --help";
-    }
+  // Round-7 #2 (architect ref 7-Round7Workflow): the previous per-criterion loop
+  // was verification THEATER — every criterion ran the same global `bun test`
+  // (or a guaranteed-green `--help` when the text mentioned run/cli) and a
+  // fabricated per-criterion ✅/❌ matrix was written to the ledger. Honest
+  // contract: run the suite ONCE as a global signal; individual criteria are
+  // UNVERIFIED unless individually proven. SUCCESS is not claimable from a
+  // signal that cannot fail for the cases it pretends to cover.
+  log(`[CHECK] Running the verification suite once ('bun test') — a global signal, not per-criterion proof.`);
+  if (opts.onProgress) {
+    opts.onProgress({ skill: "ultragoal", phase: "verifying", detail: "Running verification suite" });
+  }
+  const suite = await bashTool("bun test", cwd);
+  log(`  └─ Suite: ${suite.success ? "GREEN" : "FAILED"}`);
 
-    console.log(`  └─ Running validation command: '${cmd}'`);
-    const res = await bashTool(cmd, cwd);
-    
-    results.push({
-      criterion,
-      passed: res.success,
-      output: res.output.slice(0, 300) + (res.output.length > 300 ? "..." : "")
-    });
+  const results: { criterion: string; status: "unverified" | "failed"; note: string }[] = criteria.map(criterion =>
+    suite.success
+      ? { criterion, status: "unverified", note: "suite green — criterion not individually verified" }
+      : { criterion, status: "failed", note: "verification suite failed" },
+  );
 
-    console.log(`  └─ Result: ${res.success ? "PASSED" : "FAILED"}`);
+  if (opts.signal?.aborted) {
+    return { ok: false, reason: "aborted" };
   }
 
   // Write verification report
-  const reportDir = path.join(getLocalJocDir(cwd), "state");
+  const reportDir = path.join(getLocalJeoDir(cwd), "state");
   await fs.mkdir(reportDir, { recursive: true });
   const reportPath = path.join(reportDir, "ultragoal-report.md");
 
-  const passedCount = results.filter(r => r.passed).length;
   const totalCount = results.length;
-  const status = passedCount === totalCount ? "SUCCESS" : "DEGRADED";
+  const status = suite.success ? "SUITE_GREEN" : "FAILED";
 
-  const reportContent = 
+  const reportContent =
     `# Ultragoal Verification Report: ${interviewState.slug}\n` +
     `Date: ${new Date().toISOString()}\n` +
-    `Status: ${status} (${passedCount}/${totalCount} criteria passed)\n\n` +
-    `## Criteria Verification Matrix\n` +
-    `| Criterion | Status | Verification Output |\n` +
+    `Status: ${status} — suite ${suite.success ? "green" : "FAILED"}; ${totalCount} acceptance criteria recorded (not individually verified)\n` +
+    `Plan: ${teamState?.plan_path ?? "(team not run)"}\n` +
+    `Execution: ${teamState?.current_phase === "complete" ? "team complete" : "team NOT complete — verified current disk state"}\n\n` +
+    `## Criteria Record\n` +
+    `| Criterion | Status | Note |\n` +
     `|---|---|---|\n` +
-    results.map(r => `| ${r.criterion} | ${r.passed ? "✅ PASSED" : "❌ FAILED"} | \`${r.output.replace(/\n/g, " ")}\` |`).join("\n") +
+    results.map(r => `| ${r.criterion} | ${r.status === "failed" ? "❌ FAILED" : "⚠️ UNVERIFIED"} | ${r.note} |`).join("\n") +
     `\n`;
 
-  await fs.writeFile(reportPath, reportContent, "utf-8");
-  console.log(`\n[VERIFICATION COMPLETE] Report saved to: ${reportPath}`);
-  console.log(`Overall status: ${status} (${passedCount}/${totalCount} passed)`);
+  // Atomic temp+rename (zeroclaw): a torn report must not disagree with the state JSON.
+  const tmpReport = `${reportPath}.${Math.random().toString(36).slice(2)}.tmp`;
+  try {
+    await fs.writeFile(tmpReport, reportContent, "utf-8");
+    await fs.rename(tmpReport, reportPath);
+  } catch (err) {
+    await fs.unlink(tmpReport).catch(() => {});
+    throw err;
+  }
+
+  // Persist a machine-readable terminal phase so the chain is queryable end-to-end.
+  const ultragoalState: WorkflowState = {
+    active: false,
+    current_phase: "complete",
+    skill: "ultragoal",
+    slug: interviewState.slug,
+    seed_path: seedPath,
+    plan_path: teamState?.plan_path,
+    status,
+    suite_green: suite.success,
+    total: totalCount,
+  };
+  await writeWorkflowState("ultragoal", ultragoalState, cwd);
+
+  log(`\n[VERIFICATION COMPLETE] Report saved to: ${reportPath}`);
+  log(`Overall status: ${status} — ${totalCount} criteria recorded; none individually verified (add per-criterion checks for stronger claims).`);
+
+  if (opts.onProgress) {
+    opts.onProgress({ skill: "ultragoal", phase: "complete" });
+  }
+
+  return { ok: suite.success };
+}
+
+export async function runUltragoalCommand(): Promise<void> {
+  await runUltragoalEngine();
 }

package/src/commands/update.ts

@@ -0,0 +1,244 @@
+import pkg from "../../package.json";
+
+/**
+ * Compares two semver-ish version strings.
+ * Choice: A version with a prerelease suffix is considered older than the same version without a prerelease suffix (e.g. 1.0.0 > 1.0.0-alpha).
+ * If both versions have prerelease suffixes, they are compared lexicographically as a string tiebreak (e.g. 1.0.0-beta > 1.0.0-alpha).
+ */
+export function compareVersions(a: string, b: string): -1 | 0 | 1 {
+  const cleanA = a.split("+")[0] || "";
+  const cleanB = b.split("+")[0] || "";
+
+  const [aBase = "", aPre] = cleanA.split("-");
+  const [bBase = "", bPre] = cleanB.split("-");
+
+  const aParts = aBase.split(".").map(x => parseInt(x, 10) || 0);
+  const bParts = bBase.split(".").map(x => parseInt(x, 10) || 0);
+
+  const maxLen = Math.max(aParts.length, bParts.length);
+  for (let i = 0; i < maxLen; i++) {
+    const aVal = aParts[i] ?? 0;
+    const bVal = bParts[i] ?? 0;
+    if (aVal > bVal) return 1;
+    if (aVal < bVal) return -1;
+  }
+
+  if (aPre === undefined && bPre !== undefined) return 1;
+  if (aPre !== undefined && bPre === undefined) return -1;
+  if (aPre === undefined && bPre === undefined) return 0;
+
+  if (aPre > bPre) return 1;
+  if (aPre < bPre) return -1;
+  return 0;
+}
+
+export interface UpdateDeps {
+  fetchJson: (url: string, options?: { signal?: AbortSignal }) => Promise<any>;
+  localVersion: () => string;
+  install: () => Promise<{ success: boolean; stdout?: string; stderr?: string }>;
+}
+
+export const defaultDeps: UpdateDeps = {
+  fetchJson: async (url: string, options?: { signal?: AbortSignal }) => {
+    const res = await fetch(url, options);
+    if (res.status === 404) {
+      const err = new Error("Package not found on registry");
+      (err as any).status = 404;
+      throw err;
+    }
+    if (!res.ok) {
+      const err = new Error(`HTTP status ${res.status}`);
+      (err as any).status = res.status;
+      throw err;
+    }
+    return res.json();
+  },
+  localVersion: () => {
+    return pkg.version;
+  },
+  install: async () => {
+    const proc = Bun.spawnSync(["bun", "install", "-g", "jeo-code"], {
+      stdout: "inherit",
+      stderr: "inherit",
+    });
+    return { success: proc.success };
+  }
+};
+
+export async function runUpdateCommand(args: string[] = []): Promise<void> {
+  return runUpdateCommandWith(args, defaultDeps);
+}
+
+export async function runUpdateCommandWith(args: string[], deps: UpdateDeps): Promise<void> {
+  const isHelp = args.includes("--help") || args.includes("-h");
+  const hasInstall = args.includes("--install");
+  const hasJson = args.includes("--json");
+  const hasStrict = args.includes("--strict");
+
+  const KNOWN_FLAGS = new Set(["--check", "--install", "--json", "--strict", "-h", "--help"]);
+
+  if (isHelp) {
+    printUsage();
+    return;
+  }
+
+  // Check for unknown flags
+  for (const arg of args) {
+    if (!KNOWN_FLAGS.has(arg)) {
+      console.log(`Unknown flag: ${arg}`);
+      printUsage();
+      process.exitCode = 1;
+      return;
+    }
+  }
+
+  const current = deps.localVersion();
+  let latest: string | null = null;
+  let upToDate = false;
+
+  try {
+    const signal = AbortSignal.timeout(10000);
+    const data = await deps.fetchJson("https://registry.npmjs.org/jeo-code/latest", { signal });
+    if (!data || typeof data.version !== "string") {
+      throw new Error("Invalid response format from npm registry");
+    }
+    latest = data.version as string;
+    const cmp = compareVersions(current, latest);
+    upToDate = cmp >= 0;
+  } catch (err: any) {
+    const is404 = err.status === 404 || String(err.message).includes("404") || String(err.message).toLowerCase().includes("not found");
+    if (is404) {
+      if (hasJson) {
+        console.log(JSON.stringify({
+          current,
+          latest: null,
+          upToDate: true,
+          error: "Package not found on registry"
+        }));
+      } else {
+        console.log("Package not found on registry: jeo-code");
+      }
+      return;
+    } else {
+      // Network failure
+      const errMsg = err.message || String(err);
+      if (hasJson) {
+        console.log(JSON.stringify({
+          current,
+          latest: null,
+          upToDate: false,
+          error: `Network failure: ${errMsg}`
+        }));
+      } else {
+        if (hasStrict) {
+          console.error(`Error: Network failure: ${errMsg}`);
+        } else {
+          console.warn(`Warning: Network failure: ${errMsg}`);
+        }
+      }
+      if (hasStrict) {
+        process.exitCode = 1;
+      }
+      return;
+    }
+  }
+
+  // We got the version successfully
+  if (hasInstall) {
+    if (upToDate) {
+      if (hasJson) {
+        console.log(JSON.stringify({
+          current,
+          latest,
+          upToDate: true,
+          installed: false
+        }));
+      } else {
+        console.log(`jeo-code is up-to-date (${current}). Skipping installation.`);
+      }
+    } else {
+      if (!hasJson) {
+        console.log(`Installing update: ${current} -> ${latest}...`);
+      }
+      try {
+        const result = await deps.install();
+        if (result.success) {
+          if (hasJson) {
+            console.log(JSON.stringify({
+              current,
+              latest,
+              upToDate: false,
+              installed: true
+            }));
+          } else {
+            console.log(`Successfully installed jeo-code@${latest}`);
+          }
+        } else {
+          if (hasJson) {
+            console.log(JSON.stringify({
+              current,
+              latest,
+              upToDate: false,
+              installed: false,
+              error: "Installation failed"
+            }));
+          } else {
+            console.error("Failed to install update.");
+          }
+          process.exitCode = 1;
+        }
+      } catch (installErr: any) {
+        const installErrMsg = installErr.message || String(installErr);
+        if (hasJson) {
+          console.log(JSON.stringify({
+            current,
+            latest,
+            upToDate: false,
+            installed: false,
+            error: `Installation error: ${installErrMsg}`
+          }));
+        } else {
+          console.error(`Failed to install update: ${installErrMsg}`);
+        }
+        process.exitCode = 1;
+      }
+    }
+  } else {
+    // Just checking
+    if (upToDate) {
+      if (hasJson) {
+        console.log(JSON.stringify({
+          current,
+          latest,
+          upToDate: true
+        }));
+      } else {
+        console.log(`jeo-code is up-to-date (${current}).`);
+      }
+    } else {
+      if (hasJson) {
+        console.log(JSON.stringify({
+          current,
+          latest,
+          upToDate: false
+        }));
+      } else {
+        console.log(`Newer version available: ${latest} (current: ${current}).`);
+        console.log("Run 'bun install -g jeo-code' to upgrade.");
+      }
+    }
+  }
+}
+
+function printUsage() {
+  console.log("Usage: jeo update [options]");
+  console.log("");
+  console.log("Check for and install updates for jeo-code.");
+  console.log("");
+  console.log("Options:");
+  console.log("  --check      Check for updates (default)");
+  console.log("  --install    Check and install if newer");
+  console.log("  --json       Output result in JSON format");
+  console.log("  --strict     Exit with code 1 on network/registry errors");
+  console.log("  -h, --help   Show this help message");
+}