baro-ai 0.74.5 → 0.74.6

package/dist/cli.mjs

@@ -22243,8 +22243,8 @@ var require_websocket_server = __commonJS({
 
 // ../baro-memory/dist/vectra-store.js
 import { LocalIndex } from "vectra";
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync4, existsSync as existsSync3, renameSync, rmSync as rmSync2, readdirSync as readdirSync2, statSync as statSync2, lstatSync } from "fs";
-import { join as join4 } from "path";
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync3, mkdirSync as mkdirSync4, existsSync as existsSync4, renameSync, rmSync as rmSync2, readdirSync as readdirSync2, statSync as statSync2, lstatSync } from "fs";
+import { join as join5 } from "path";
 import { tmpdir as tmpdir2, homedir } from "os";
 async function createMemoryStore(config) {
   const cfg = { ...DEFAULTS, ...config };
@@ -22257,23 +22257,23 @@ async function createMemoryStore(config) {
   if (cfg.disabled) {
     return new NoOpMemoryStore();
   }
-  const sessionPath = cfg.sessionPath || join4(tmpdir2(), `baro-memory-${process.pid}-${Date.now()}`);
+  const sessionPath = cfg.sessionPath || join5(tmpdir2(), `baro-memory-${process.pid}-${Date.now()}`);
   validateSessionPath(sessionPath);
   mkdirSync4(sessionPath, { recursive: true });
-  const indexPath = join4(sessionPath, "index");
+  const indexPath = join5(sessionPath, "index");
   mkdirSync4(indexPath, { recursive: true });
   const index = new LocalIndex(indexPath);
   if (!await index.isIndexCreated()) {
     await index.createIndex({ version: 1 });
   }
   const transformers = await import("@xenova/transformers");
-  transformers.env.cacheDir = process.env.TRANSFORMERS_CACHE || join4(homedir(), ".baro", "models");
+  transformers.env.cacheDir = process.env.TRANSFORMERS_CACHE || join5(homedir(), ".baro", "models");
   const { pipeline: pipeline2 } = transformers;
   const extractor = await pipeline2("feature-extraction", cfg.embeddingModel);
   return new VectraMemoryStore(index, extractor, sessionPath, cfg);
 }
 function validateSessionPath(sessionPath) {
-  const resolved = join4(sessionPath);
+  const resolved = join5(sessionPath);
   if (resolved.includes("..")) {
     throw new Error(`Invalid session path (contains ..): ${resolved}`);
   }
@@ -22291,13 +22291,13 @@ function validateSessionPath(sessionPath) {
 }
 function pruneOldSessions(sessionsDir) {
   try {
-    if (!existsSync3(sessionsDir))
+    if (!existsSync4(sessionsDir))
       return;
     const now = Date.now();
     for (const entry of readdirSync2(sessionsDir)) {
       if (!entry.startsWith("run-"))
         continue;
-      const entryPath = join4(sessionsDir, entry);
+      const entryPath = join5(sessionsDir, entry);
       try {
         const stat2 = lstatSync(entryPath);
         if (stat2.isSymbolicLink())
@@ -22354,10 +22354,10 @@ var init_vectra_store = __esm({
         this.index = index;
         this.extractor = extractor;
         this.sessionPath = sessionPath;
-        this.indexPath = join4(sessionPath, "index");
-        this.indexFilePath = join4(this.indexPath, "index.json");
-        this.cachePath = join4(sessionPath, "cache.json");
-        this.lockPath = join4(sessionPath, "cache.lock");
+        this.indexPath = join5(sessionPath, "index");
+        this.indexFilePath = join5(this.indexPath, "index.json");
+        this.cachePath = join5(sessionPath, "cache.json");
+        this.lockPath = join5(sessionPath, "cache.lock");
         this.config = config;
       }
       /**
@@ -22369,7 +22369,7 @@ var init_vectra_store = __esm({
        */
       refreshIndexIfChanged() {
         try {
-          if (!existsSync3(this.indexFilePath))
+          if (!existsSync4(this.indexFilePath))
             return;
           const mtimeMs = statSync2(this.indexFilePath).mtimeMs;
           if (mtimeMs === this.lastIndexMtimeMs)
@@ -22583,8 +22583,8 @@ ${result.content}
        */
       loadCache() {
         try {
-          if (existsSync3(this.cachePath)) {
-            const raw = readFileSync3(this.cachePath, "utf-8");
+          if (existsSync4(this.cachePath)) {
+            const raw = readFileSync4(this.cachePath, "utf-8");
             if (raw.trim()) {
               return JSON.parse(raw);
             }
@@ -22610,7 +22610,7 @@ ${result.content}
           }
         } finally {
           try {
-            if (existsSync3(this.lockPath))
+            if (existsSync4(this.lockPath))
               rmSync2(this.lockPath);
           } catch {
           }
@@ -22669,13 +22669,13 @@ var init_dist2 = __esm({
 });
 
 // ../baro-orchestrator/scripts/cli.ts
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync7 } from "fs";
 import { resolve as resolve3 } from "path";
 
 // ../baro-orchestrator/src/orchestrate.ts
 import { mkdirSync as mkdirSync7 } from "fs";
 import { hostname } from "os";
-import { dirname as dirname3, join as join7 } from "path";
+import { dirname as dirname3, join as join8 } from "path";
 
 // ../../node_modules/openai/internal/tslib.mjs
 function __classPrivateFieldSet(receiver, state, value, kind, f3) {
@@ -42759,11 +42759,73 @@ ${userPrompt}`;
 };
 
 // ../baro-orchestrator/src/participants/finalizer.ts
-import { execFile as execFile4 } from "child_process";
+import { execFile as execFile5 } from "child_process";
 import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync2 } from "fs";
+import { join as join4 } from "path";
+import { promisify as promisify6 } from "util";
+
+// ../baro-orchestrator/src/verify.ts
+import { execFile as execFile4 } from "child_process";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
 import { join as join3 } from "path";
 import { promisify as promisify5 } from "util";
 var execFileAsync2 = promisify5(execFile4);
+var TIMEOUT_MS = 5 * 6e4;
+var TAIL_BYTES = 1500;
+function detectCommands(cwd) {
+  const cmds = [];
+  const pkgPath = join3(cwd, "package.json");
+  if (existsSync3(pkgPath)) {
+    let scripts = {};
+    try {
+      scripts = JSON.parse(readFileSync3(pkgPath, "utf8"))?.scripts ?? {};
+    } catch {
+      scripts = {};
+    }
+    const pm = existsSync3(join3(cwd, "pnpm-lock.yaml")) ? "pnpm" : existsSync3(join3(cwd, "yarn.lock")) ? "yarn" : "npm";
+    if (typeof scripts.build === "string") cmds.push({ label: `${pm} run build`, tool: pm, args: ["run", "build"] });
+    if (typeof scripts.test === "string") cmds.push({ label: `${pm} run test`, tool: pm, args: ["run", "test"] });
+  }
+  if (existsSync3(join3(cwd, "Cargo.toml"))) {
+    cmds.push({ label: "cargo build", tool: "cargo", args: ["build"] });
+    cmds.push({ label: "cargo test", tool: "cargo", args: ["test"] });
+  }
+  if (existsSync3(join3(cwd, "go.mod"))) {
+    cmds.push({ label: "go build ./...", tool: "go", args: ["build", "./..."] });
+    cmds.push({ label: "go test ./...", tool: "go", args: ["test", "./..."] });
+  }
+  return cmds;
+}
+async function runCmd(cwd, c) {
+  try {
+    await execFileAsync2(c.tool, c.args, {
+      cwd,
+      timeout: TIMEOUT_MS,
+      maxBuffer: 8 * 1024 * 1024,
+      shell: process.platform === "win32"
+    });
+    return { status: "pass" };
+  } catch (e2) {
+    if (e2.code === "ENOENT") return { status: "skipped" };
+    const err = e2;
+    const combined = `${err.stdout ?? ""}${err.stderr ?? ""}`.trim() || err.message || "";
+    return { status: "fail", tail: combined.slice(-TAIL_BYTES) };
+  }
+}
+async function verifyBuild(cwd) {
+  const failures = [];
+  let ran = false;
+  for (const c of detectCommands(cwd)) {
+    const outcome = await runCmd(cwd, c);
+    if (outcome.status === "skipped") continue;
+    ran = true;
+    if (outcome.status === "fail") failures.push({ cmd: c.label, tail: outcome.tail });
+  }
+  return { ran, ok: failures.length === 0, failures };
+}
+
+// ../baro-orchestrator/src/participants/finalizer.ts
+var execFileAsync3 = promisify6(execFile5);
 var Finalizer = class extends BaseObserver {
   opts;
   envRef = null;
@@ -42936,12 +42998,22 @@ var Finalizer = class extends BaseObserver {
     const { passed, failed } = this.partition(orderedStories);
     const filesStats = await this.collectFileStats();
     const totalSecs = run.totalDurationSecs;
-    const checkpoint = !run.success;
+    this.log("[finalizer] verifying build\u2026");
+    const verify = await verifyBuild(this.opts.cwd);
+    if (!verify.ran) {
+      this.log("[finalizer] nothing to verify (no build/test)");
+    } else if (verify.ok) {
+      this.log("[finalizer] \u2713 build-verified");
+    } else {
+      this.log(`[finalizer] \u26A0 verification failed: ${verify.failures[0]?.cmd ?? "build/test"}`);
+    }
+    const checkpoint = !run.success || verify.ran && !verify.ok;
     const title = this.buildPrTitle(prd, passed.length, orderedStories.length, checkpoint);
     const body = this.buildPrBody({
       prd,
       run,
       checkpoint,
+      verify,
       orderedStories,
       passed,
       failed,
@@ -42987,18 +43059,18 @@ var Finalizer = class extends BaseObserver {
     const adrs = parseAdrs(doc);
     if (adrs.length === 0) return;
     try {
-      const dir = join3(this.opts.cwd, "adr");
+      const dir = join4(this.opts.cwd, "adr");
       mkdirSync3(dir, { recursive: true });
       for (const a of adrs) {
         const num = a.num.padStart(4, "0");
-        writeFileSync2(join3(dir, `${num}-${slugify(a.title)}.md`), `# ADR-${num}: ${a.title}
+        writeFileSync2(join4(dir, `${num}-${slugify(a.title)}.md`), `# ADR-${num}: ${a.title}
 
 ${a.body}
 `);
       }
-      await execFileAsync2("git", ["add", "adr"], { cwd: this.opts.cwd });
+      await execFileAsync3("git", ["add", "adr"], { cwd: this.opts.cwd });
       try {
-        await execFileAsync2(
+        await execFileAsync3(
           "git",
           ["commit", "-m", `docs: architecture decision records (${adrs.length})
 
@@ -43059,7 +43131,7 @@ ${BARO_COAUTHOR_TRAILER}`],
   async collectCommitsSinceBase() {
     if (!this.baseSha) return [];
     try {
-      const { stdout } = await execFileAsync2(
+      const { stdout } = await execFileAsync3(
         "git",
         ["log", `${this.baseSha}..HEAD`, "--pretty=format:%H%x09%s"],
         { cwd: this.opts.cwd }
@@ -43075,7 +43147,7 @@ ${BARO_COAUTHOR_TRAILER}`],
   async collectFileStats() {
     if (!this.baseSha) return { created: 0, modified: 0 };
     try {
-      const { stdout } = await execFileAsync2(
+      const { stdout } = await execFileAsync3(
         "git",
         ["diff", "--name-status", this.baseSha, "HEAD"],
         { cwd: this.opts.cwd }
@@ -43094,7 +43166,7 @@ ${BARO_COAUTHOR_TRAILER}`],
   }
   async detectBranch() {
     try {
-      const { stdout } = await execFileAsync2(
+      const { stdout } = await execFileAsync3(
         "git",
         ["branch", "--show-current"],
         { cwd: this.opts.cwd }
@@ -43106,7 +43178,7 @@ ${BARO_COAUTHOR_TRAILER}`],
   }
   async detectDefaultBaseBranch() {
     try {
-      const { stdout } = await execFileAsync2(
+      const { stdout } = await execFileAsync3(
         "gh",
         ["repo", "view", "--json", "defaultBranchRef", "--jq", ".defaultBranchRef.name"],
         { cwd: this.opts.cwd }
@@ -43116,7 +43188,7 @@ ${BARO_COAUTHOR_TRAILER}`],
     } catch {
     }
     try {
-      const { stdout } = await execFileAsync2(
+      const { stdout } = await execFileAsync3(
         "git",
         ["symbolic-ref", "--short", "refs/remotes/origin/HEAD"],
         { cwd: this.opts.cwd }
@@ -43147,6 +43219,20 @@ ${BARO_COAUTHOR_TRAILER}`],
       lines.push("> **Checkpoint PR:** baro produced branch changes, but the run failed during verification/retry/replan. Review this as a candidate fix, not a fully verified completion.");
       lines.push("");
     }
+    if (args.verify.ran && !args.verify.ok) {
+      lines.push("## \u26A0 Build/test verification failed");
+      lines.push("");
+      lines.push("The fully-merged branch did not pass an objective build/test check:");
+      lines.push("");
+      for (const f3 of args.verify.failures) {
+        lines.push(`**\`${f3.cmd}\`**`);
+        lines.push("");
+        lines.push("```");
+        lines.push(f3.tail.trim() || "(no output captured)");
+        lines.push("```");
+        lines.push("");
+      }
+    }
     if (prd?.description) {
       lines.push("## Goal");
       lines.push("");
@@ -43209,7 +43295,7 @@ ${BARO_COAUTHOR_TRAILER}`],
   }
   async hasGhBinary() {
     try {
-      await execFileAsync2("gh", ["--version"], { cwd: this.opts.cwd });
+      await execFileAsync3("gh", ["--version"], { cwd: this.opts.cwd });
       return true;
     } catch {
       return false;
@@ -43221,7 +43307,7 @@ ${BARO_COAUTHOR_TRAILER}`],
   // surfaces the real outcome.
   async pushBranch(branch) {
     try {
-      await execFileAsync2("git", ["push", "origin", branch], { cwd: this.opts.cwd });
+      await execFileAsync3("git", ["push", "origin", branch], { cwd: this.opts.cwd });
     } catch (e2) {
       const detail = (e2.stderr ?? e2.message).split("\n")[0]?.trim();
       this.log(`[finalizer] pre-PR push: ${detail}`);
@@ -43229,7 +43315,7 @@ ${BARO_COAUTHOR_TRAILER}`],
   }
   async openPr(args) {
     try {
-      const { stdout } = await execFileAsync2(
+      const { stdout } = await execFileAsync3(
         "gh",
         [
           "pr",
@@ -44226,10 +44312,10 @@ function tokenizeHints(prompt) {
 
 // ../baro-orchestrator/src/participants/memory-librarian.ts
 import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync5 } from "fs";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 var DEBUG = process.env.BARO_DEBUG?.includes("memory") ?? false;
-var LOG_DIR = join5(process.env.HOME || "/tmp", ".baro", "runs");
-var LOG_FILE = join5(LOG_DIR, `memory-${Date.now()}.log`);
+var LOG_DIR = join6(process.env.HOME || "/tmp", ".baro", "runs");
+var LOG_FILE = join6(LOG_DIR, `memory-${Date.now()}.log`);
 try {
   mkdirSync5(LOG_DIR, { recursive: true });
 } catch {
@@ -48014,8 +48100,8 @@ var StoryFactory = class extends BaseObserver {
 };
 
 // ../baro-orchestrator/src/participants/surgeon.ts
-import { execFile as execFile5 } from "child_process";
-import { promisify as promisify6 } from "util";
+import { execFile as execFile6 } from "child_process";
+import { promisify as promisify7 } from "util";
 var CritiqueLog = class {
   constructor(keep = 3) {
     this.keep = keep;
@@ -48032,7 +48118,7 @@ var CritiqueLog = class {
     return this.byStory.get(storyId) ?? [];
   }
 };
-var execFileAsync3 = promisify6(execFile5);
+var execFileAsync4 = promisify7(execFile6);
 var SURGEON_SYSTEM_PROMPT = `You are the Surgeon \u2014 an autonomous planner that adapts a software-project
 DAG when stories fail. Given:
 1. A snapshot of the current PRD (project, story list with dependencies +
@@ -48164,7 +48250,7 @@ var Surgeon = class extends BaseObserver {
       this.critiques.forStory(failure.storyId)
     );
     try {
-      const { stdout } = await execFileAsync3(
+      const { stdout } = await execFileAsync4(
         this.opts.claudeBin,
         [
           "--print",
@@ -48895,8 +48981,8 @@ async function orchestrate(config) {
   const useLibrarian = config.withLibrarian ?? true;
   const useSentry = config.withSentry ?? true;
   const useMemory = config.withMemory ?? true;
-  const sessionsDir = join7(process.env.HOME || "/tmp", ".baro", "sessions");
-  const memorySessionPath = useMemory ? join7(sessionsDir, runId, "memory") : void 0;
+  const sessionsDir = join8(process.env.HOME || "/tmp", ".baro", "sessions");
+  const memorySessionPath = useMemory ? join8(sessionsDir, runId, "memory") : void 0;
   if (useMemory) {
     try {
       const { pruneOldSessions: pruneOldSessions2 } = await Promise.resolve().then(() => (init_dist2(), dist_exports));
@@ -49439,7 +49525,7 @@ async function main() {
   }
   const cwd = resolve3(args.cwd);
   const prdPath = resolve3(cwd, args.prd);
-  if (!existsSync6(prdPath)) {
+  if (!existsSync7(prdPath)) {
     process.stderr.write(`[cli] PRD not found: ${prdPath}
 `);
     process.exit(2);