baro-ai 0.23.2 → 0.23.3

package/dist/cli.mjs

@@ -7918,6 +7918,33 @@ var StorySpawnedItem = class extends ContextItem {
     return { type: this.type, storyId: this.storyId };
   }
 };
+var FinalizeStartedItem = class extends ContextItem {
+  constructor(branch) {
+    super();
+    this.branch = branch;
+  }
+  type = "finalize_started";
+  toJSON() {
+    return { type: this.type, branch: this.branch };
+  }
+};
+var PrCreatedItem = class extends ContextItem {
+  constructor(url, branch, baseBranch) {
+    super();
+    this.url = url;
+    this.branch = branch;
+    this.baseBranch = baseBranch;
+  }
+  type = "pr_created";
+  toJSON() {
+    return {
+      type: this.type,
+      url: this.url,
+      branch: this.branch,
+      baseBranch: this.baseBranch
+    };
+  }
+};
 var RunCompletedItem = class extends ContextItem {
   constructor(success, completedStories, failedStories, totalDurationSecs, totalAttempts, abortReason = null) {
     super();
@@ -9305,6 +9332,427 @@ function extractVerdictJson(text) {
   throw new Error(`unbalanced JSON object in critic response: ${trimmed.slice(0, 200)}`);
 }
 
+// ../baro-orchestrator/src/participants/finalizer.ts
+import { execFile as execFile3 } from "child_process";
+import { promisify as promisify3 } from "util";
+var execFileAsync2 = promisify3(execFile3);
+var Finalizer = class extends Participant {
+  opts;
+  envRef = null;
+  startedAtMs = null;
+  baseSha;
+  branchName = null;
+  levels = [];
+  stories = /* @__PURE__ */ new Map();
+  /**
+   * Resolves once finalize() has completed (or been short-circuited).
+   * Lets orchestrate.ts gate its TUI `done` event so the PR URL lands
+   * in the completion screen instead of after it.
+   */
+  finalizePromise = null;
+  constructor(opts) {
+    super();
+    this.opts = {
+      cwd: opts.cwd,
+      prdPath: opts.prdPath,
+      createPr: opts.createPr ?? true,
+      onLog: opts.onLog
+    };
+    this.baseSha = opts.baseSha ?? null;
+  }
+  setEnvironment(env) {
+    this.envRef = env;
+  }
+  async onContextItem(_source, item) {
+    if (item instanceof RunStartedItem) {
+      this.startedAtMs = Date.now();
+      if (this.baseSha == null) {
+        this.baseSha = await getHeadSha(this.opts.cwd);
+      }
+      const prd = this.safeLoadPrd();
+      this.branchName = prd?.branchName ?? null;
+      return;
+    }
+    if (item instanceof LevelStartedItem) {
+      this.levels[item.ordinal] = [...item.storyIds];
+      for (const id of item.storyIds) {
+        if (!this.stories.has(id)) {
+          this.stories.set(id, {
+            id,
+            title: "",
+            success: null,
+            durationSecs: null,
+            attempts: 0,
+            levelOrdinal: item.ordinal
+          });
+        } else {
+          const rec = this.stories.get(id);
+          rec.levelOrdinal = item.ordinal;
+        }
+      }
+      return;
+    }
+    if (item instanceof StoryResultItem) {
+      const existing = this.stories.get(item.storyId) ?? {
+        id: item.storyId,
+        title: "",
+        success: null,
+        durationSecs: null,
+        attempts: 0,
+        levelOrdinal: null
+      };
+      existing.success = item.success;
+      existing.durationSecs = item.durationSecs;
+      existing.attempts = item.attempts;
+      this.stories.set(item.storyId, existing);
+      return;
+    }
+    if (item instanceof RunCompletedItem) {
+      this.finalizePromise = this.finalize(item);
+      await this.finalizePromise;
+      return;
+    }
+  }
+  /**
+   * Resolves once Finalizer has finished handling RunCompletedItem
+   * (PR opened, skipped, or failed). Resolves immediately if no run
+   * has completed yet. Safe to call multiple times.
+   */
+  complete() {
+    return this.finalizePromise ?? Promise.resolve();
+  }
+  async finalize(run) {
+    if (!this.opts.createPr) return;
+    if (!run.success && run.completedStories.length === 0) {
+      this.log("[finalizer] run failed before producing any commits; skipping PR");
+      this.emit(new PrCreatedItem(null, this.branchName ?? "", ""));
+      return;
+    }
+    if (!await this.hasGhBinary()) {
+      this.log("[finalizer] `gh` not found on PATH; skipping PR creation");
+      this.emit(new PrCreatedItem(null, this.branchName ?? "", ""));
+      return;
+    }
+    const branch = this.branchName ?? await this.detectBranch();
+    if (!branch) {
+      this.log("[finalizer] could not determine branch; skipping PR");
+      this.emit(new PrCreatedItem(null, "", ""));
+      return;
+    }
+    const baseBranch = await this.detectDefaultBaseBranch();
+    if (!baseBranch) {
+      this.log("[finalizer] could not determine base branch; skipping PR");
+      this.emit(new PrCreatedItem(null, branch, ""));
+      return;
+    }
+    if (branch === baseBranch) {
+      this.log(
+        `[finalizer] branch '${branch}' matches base; skipping PR (run committed straight to main?)`
+      );
+      this.emit(new PrCreatedItem(null, branch, baseBranch));
+      return;
+    }
+    this.emit(new FinalizeStartedItem(branch));
+    const prd = this.safeLoadPrd();
+    if (prd) {
+      for (const s of prd.userStories) {
+        const rec = this.stories.get(s.id);
+        if (rec && !rec.title) rec.title = s.title;
+      }
+    }
+    const commits = await this.collectCommitsSinceBase();
+    const orderedStories = this.orderStories();
+    const { passed, failed } = this.partition(orderedStories);
+    const filesStats = await this.collectFileStats();
+    const totalSecs = run.totalDurationSecs;
+    const title = this.buildPrTitle(prd, passed.length, orderedStories.length);
+    const body = this.buildPrBody({
+      prd,
+      run,
+      orderedStories,
+      passed,
+      failed,
+      commits,
+      filesStats,
+      totalSecs,
+      sequentialSecs: this.sequentialSeconds()
+    });
+    this.log(`[finalizer] opening PR on ${baseBranch} \u2190 ${branch}`);
+    const url = await this.openPr({ title, body, baseBranch, branch });
+    if (url) {
+      this.log(`[finalizer] PR opened: ${url}`);
+    }
+    this.emit(new PrCreatedItem(url, branch, baseBranch));
+  }
+  // ─── Bus & env helpers ──────────────────────────────────────────
+  emit(item) {
+    this.envRef?.deliverContextItem(this, item);
+  }
+  log(line) {
+    this.opts.onLog?.(line);
+  }
+  // ─── PRD ────────────────────────────────────────────────────────
+  safeLoadPrd() {
+    try {
+      return loadPrd(this.opts.prdPath);
+    } catch {
+      return null;
+    }
+  }
+  // ─── Story ordering & partitioning ──────────────────────────────
+  /**
+   * Stories returned in DAG order so the table reads top-down the same
+   * way the run executed: level 0 first, then level 1, etc. Within a
+   * level we sort by id (stable) to keep the table deterministic.
+   */
+  orderStories() {
+    const seen = /* @__PURE__ */ new Set();
+    const ordered = [];
+    for (const lvl of this.levels) {
+      const sorted = [...lvl].sort();
+      for (const id of sorted) {
+        const rec = this.stories.get(id);
+        if (rec && !seen.has(id)) {
+          ordered.push(rec);
+          seen.add(id);
+        }
+      }
+    }
+    for (const [id, rec] of this.stories.entries()) {
+      if (!seen.has(id)) ordered.push(rec);
+    }
+    return ordered;
+  }
+  partition(stories) {
+    const passed = [];
+    const failed = [];
+    for (const s of stories) {
+      if (s.success === true) passed.push(s);
+      else if (s.success === false) failed.push(s);
+    }
+    return { passed, failed };
+  }
+  sequentialSeconds() {
+    let sum = 0;
+    for (const s of this.stories.values()) {
+      if (s.durationSecs && s.success !== false) sum += s.durationSecs;
+    }
+    return sum;
+  }
+  // ─── Git / commits / files ──────────────────────────────────────
+  async collectCommitsSinceBase() {
+    if (!this.baseSha) return [];
+    try {
+      const { stdout } = await execFileAsync2(
+        "git",
+        ["log", `${this.baseSha}..HEAD`, "--pretty=format:%H%x09%s"],
+        { cwd: this.opts.cwd }
+      );
+      return stdout.split("\n").filter((l) => l.includes("	")).map((l) => {
+        const [sha, ...rest] = l.split("	");
+        return { sha, subject: rest.join("	").trim() };
+      });
+    } catch {
+      return [];
+    }
+  }
+  async collectFileStats() {
+    if (!this.baseSha) return { created: 0, modified: 0 };
+    try {
+      const { stdout } = await execFileAsync2(
+        "git",
+        ["diff", "--name-status", this.baseSha, "HEAD"],
+        { cwd: this.opts.cwd }
+      );
+      let created = 0;
+      let modified = 0;
+      for (const line of stdout.split("\n")) {
+        const ch = line.charAt(0);
+        if (ch === "A") created++;
+        else if (ch === "M" || ch === "R") modified++;
+      }
+      return { created, modified };
+    } catch {
+      return { created: 0, modified: 0 };
+    }
+  }
+  async detectBranch() {
+    try {
+      const { stdout } = await execFileAsync2(
+        "git",
+        ["branch", "--show-current"],
+        { cwd: this.opts.cwd }
+      );
+      return stdout.trim() || null;
+    } catch {
+      return null;
+    }
+  }
+  async detectDefaultBaseBranch() {
+    try {
+      const { stdout } = await execFileAsync2(
+        "gh",
+        ["repo", "view", "--json", "defaultBranchRef", "--jq", ".defaultBranchRef.name"],
+        { cwd: this.opts.cwd }
+      );
+      const name = stdout.trim();
+      if (name) return name;
+    } catch {
+    }
+    try {
+      const { stdout } = await execFileAsync2(
+        "git",
+        ["symbolic-ref", "--short", "refs/remotes/origin/HEAD"],
+        { cwd: this.opts.cwd }
+      );
+      const ref = stdout.trim();
+      if (ref.startsWith("origin/")) return ref.slice("origin/".length);
+    } catch {
+    }
+    return "main";
+  }
+  // ─── PR body composition ────────────────────────────────────────
+  buildPrTitle(prd, passed, total) {
+    const project = prd?.project ?? "baro run";
+    if (passed === total) {
+      return `${project} (${total} ${total === 1 ? "story" : "stories"})`;
+    }
+    return `${project} (${passed}/${total} stories)`;
+  }
+  buildPrBody(args) {
+    const { prd, run, orderedStories, passed, failed, commits, filesStats } = args;
+    const lines = [];
+    lines.push(
+      `> Opened by [baro](https://baro.rs) \u2014 Mozaik-orchestrated parallel coding agents.`
+    );
+    lines.push("");
+    if (prd?.description) {
+      lines.push("## Goal");
+      lines.push("");
+      lines.push(prd.description.trim());
+      lines.push("");
+    }
+    if (this.levels.length > 0) {
+      lines.push("## Plan");
+      lines.push("");
+      lines.push("```");
+      for (let i = 0; i < this.levels.length; i++) {
+        const ids = this.levels[i];
+        lines.push(`Level ${i} \u2500\u2500\u2500 ${ids.join(", ")}`);
+      }
+      lines.push("```");
+      lines.push("");
+    }
+    lines.push("## Stories");
+    lines.push("");
+    lines.push("| # | Story | Status | Duration | Commit |");
+    lines.push("|---|-------|--------|----------|--------|");
+    for (const s of orderedStories) {
+      const title = (s.title || s.id).replace(/\|/g, "\\|");
+      const status = s.success === true ? "\u2713" : s.success === false ? "\u2717" : "\u2014";
+      const dur = s.durationSecs != null ? formatDuration(s.durationSecs) : "\u2014";
+      const commit = matchCommit(s, commits);
+      lines.push(
+        `| ${s.id} | ${title} | ${status} | ${dur} | ${commit ? "`" + commit.slice(0, 7) + "`" : "\u2014"} |`
+      );
+    }
+    lines.push("");
+    lines.push("## Diff stats");
+    lines.push("");
+    lines.push(`- **Files created**: ${filesStats.created}`);
+    lines.push(`- **Files modified**: ${filesStats.modified}`);
+    lines.push(`- **Total commits**: ${commits.length}`);
+    lines.push("");
+    lines.push("## Run summary");
+    lines.push("");
+    const wall = formatDuration(args.totalSecs);
+    const seq = formatDuration(args.sequentialSecs);
+    const speedup = args.totalSecs > 0 ? (args.sequentialSecs / args.totalSecs).toFixed(2) + "\xD7" : "\u2014";
+    lines.push(`- **Wall time**: ${wall}`);
+    lines.push(`- **Sequential time**: ${seq}`);
+    lines.push(`- **Parallel speedup**: ${speedup}`);
+    lines.push(`- **Stories passed**: ${passed.length}/${orderedStories.length}`);
+    lines.push(`- **Stories failed**: ${failed.length}`);
+    lines.push(`- **Total story attempts**: ${run.totalAttempts}`);
+    if (run.abortReason) {
+      lines.push(`- **Abort reason**: ${run.abortReason}`);
+    }
+    lines.push("");
+    lines.push("---");
+    lines.push("");
+    lines.push("\u{1F916} Plan. Parallelize. Review. Ship. \u2014 opened by baro");
+    return lines.join("\n");
+  }
+  async hasGhBinary() {
+    try {
+      await execFileAsync2("gh", ["--version"], { cwd: this.opts.cwd });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async openPr(args) {
+    try {
+      const { stdout } = await execFileAsync2(
+        "gh",
+        [
+          "pr",
+          "create",
+          "--base",
+          args.baseBranch,
+          "--head",
+          args.branch,
+          "--title",
+          args.title,
+          "--body",
+          args.body
+        ],
+        { cwd: this.opts.cwd }
+      );
+      const url = stdout.trim().split("\n").pop() ?? "";
+      return url || null;
+    } catch (e) {
+      const stderr = e?.stderr ?? "";
+      const existing = stderr.match(/https:\/\/github\.com\/\S+\/pull\/\d+/)?.[0];
+      if (existing) {
+        this.log(`[finalizer] PR already exists: ${existing}`);
+        return existing;
+      }
+      this.log(
+        `[finalizer] gh pr create failed: ${stderr.split("\n")[0]?.trim() || e.message}`
+      );
+      return null;
+    }
+  }
+};
+function formatDuration(secs) {
+  if (secs < 60) return `${Math.round(secs)}s`;
+  const m = Math.floor(secs / 60);
+  const s = Math.round(secs % 60);
+  return `${m}:${s.toString().padStart(2, "0")}`;
+}
+function matchCommit(story, commits) {
+  if (commits.length === 0) return null;
+  const idPattern = new RegExp(`\\b${story.id}\\b`, "i");
+  for (const c of commits) {
+    if (idPattern.test(c.subject)) return c.sha;
+  }
+  if (!story.title) return null;
+  const keywords = story.title.toLowerCase().split(/[^a-z0-9]+/).filter((w) => w.length >= 4);
+  if (keywords.length === 0) return null;
+  let bestSha = null;
+  let bestScore = 0;
+  for (const c of commits) {
+    const subj = c.subject.toLowerCase();
+    const hits = keywords.reduce((n, k) => subj.includes(k) ? n + 1 : n, 0);
+    if (hits > bestScore) {
+      bestScore = hits;
+      bestSha = c.sha;
+    }
+  }
+  return bestScore >= 2 ? bestSha : null;
+}
+
 // ../baro-orchestrator/src/participants/librarian.ts
 var EXPLORATION_TOOLS = /* @__PURE__ */ new Set([
   "Read",
@@ -9651,9 +10099,9 @@ var StoryFactory = class extends Participant {
 };
 
 // ../baro-orchestrator/src/participants/surgeon.ts
-import { execFile as execFile3 } from "child_process";
-import { promisify as promisify3 } from "util";
-var execFileAsync2 = promisify3(execFile3);
+import { execFile as execFile4 } from "child_process";
+import { promisify as promisify4 } from "util";
+var execFileAsync3 = promisify4(execFile4);
 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 +
@@ -9765,7 +10213,7 @@ var Surgeon = class extends Participant {
     const snap = this.opts.snapshot();
     const prompt = buildSurgeonPrompt(snap, failure);
     try {
-      const { stdout } = await execFileAsync2(
+      const { stdout } = await execFileAsync3(
         this.opts.claudeBin,
         [
           "--print",
@@ -9926,6 +10374,15 @@ async function orchestrate(config) {
     });
     critic.join(env);
   }
+  const finalizer = useGit ? new Finalizer({
+    cwd: config.cwd,
+    prdPath: config.prdPath,
+    onLog: (line) => emitTui && emit({ type: "story_log", id: "_finalizer", line })
+  }) : null;
+  if (finalizer) {
+    finalizer.setEnvironment(env);
+    finalizer.join(env);
+  }
   const conductor = new Conductor({
     prdPath: config.prdPath,
     cwd: config.cwd,
@@ -10006,6 +10463,7 @@ async function orchestrate(config) {
   const summary = await conductor.done;
   if (critic) await critic.idle();
   if (surgeon) await surgeon.idle();
+  if (finalizer) await finalizer.complete();
   let filesCreated = 0;
   let filesModified = 0;
   if (useGit && baseSha) {
@@ -10081,6 +10539,14 @@ var BaroEventForwarder = class extends Participant {
       this.handleCritique(item);
       return;
     }
+    if (item instanceof FinalizeStartedItem) {
+      emit({ type: "finalize_start" });
+      return;
+    }
+    if (item instanceof PrCreatedItem) {
+      emit({ type: "finalize_complete", pr_url: item.url });
+      return;
+    }
   }
   handleCoordination(item) {
     emit({