baro-ai 0.62.0 → 0.64.0

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 writeFileSync2, mkdirSync as mkdirSync3, existsSync as existsSync3, renameSync, rmSync as rmSync2, readdirSync as readdirSync2, statSync as statSync2, lstatSync } from "fs";
-import { join as join3 } from "path";
+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 { 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 || join3(tmpdir2(), `baro-memory-${process.pid}-${Date.now()}`);
+  const sessionPath = cfg.sessionPath || join4(tmpdir2(), `baro-memory-${process.pid}-${Date.now()}`);
   validateSessionPath(sessionPath);
-  mkdirSync3(sessionPath, { recursive: true });
-  const indexPath = join3(sessionPath, "index");
-  mkdirSync3(indexPath, { recursive: true });
+  mkdirSync4(sessionPath, { recursive: true });
+  const indexPath = join4(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 || join3(homedir(), ".baro", "models");
+  transformers.env.cacheDir = process.env.TRANSFORMERS_CACHE || join4(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 = join3(sessionPath);
+  const resolved = join4(sessionPath);
   if (resolved.includes("..")) {
     throw new Error(`Invalid session path (contains ..): ${resolved}`);
   }
@@ -22297,7 +22297,7 @@ function pruneOldSessions(sessionsDir) {
     for (const entry of readdirSync2(sessionsDir)) {
       if (!entry.startsWith("run-"))
         continue;
-      const entryPath = join3(sessionsDir, entry);
+      const entryPath = join4(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 = join3(sessionPath, "index");
-        this.indexFilePath = join3(this.indexPath, "index.json");
-        this.cachePath = join3(sessionPath, "cache.json");
-        this.lockPath = join3(sessionPath, "cache.lock");
+        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.config = config;
       }
       /**
@@ -22622,13 +22622,13 @@ ${result.content}
        */
       saveCache(cache) {
         try {
-          writeFileSync2(this.lockPath, String(process.pid), "utf-8");
+          writeFileSync3(this.lockPath, String(process.pid), "utf-8");
           const tmp = this.cachePath + `.${process.pid}.tmp`;
-          writeFileSync2(tmp, JSON.stringify(cache), "utf-8");
+          writeFileSync3(tmp, JSON.stringify(cache), "utf-8");
           renameSync(tmp, this.cachePath);
         } catch {
           try {
-            writeFileSync2(this.cachePath, JSON.stringify(cache), "utf-8");
+            writeFileSync3(this.cachePath, JSON.stringify(cache), "utf-8");
           } catch {
           }
         } finally {
@@ -22696,8 +22696,8 @@ import { existsSync as existsSync6 } from "fs";
 import { resolve as resolve3 } from "path";
 
 // ../baro-orchestrator/src/orchestrate.ts
-import { mkdirSync as mkdirSync6 } from "fs";
-import { dirname as dirname3, join as join6 } from "path";
+import { mkdirSync as mkdirSync7 } from "fs";
+import { dirname as dirname3, join as join7 } from "path";
 
 // ../../node_modules/openai/internal/tslib.mjs
 function __classPrivateFieldSet(receiver, state, value, kind, f3) {
@@ -42634,6 +42634,8 @@ ${userPrompt}`;
 
 // ../baro-orchestrator/src/participants/finalizer.ts
 import { execFile as execFile4 } from "child_process";
+import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync2 } from "fs";
+import { join as join3 } from "path";
 import { promisify as promisify5 } from "util";
 var execFileAsync2 = promisify5(execFile4);
 var Finalizer = class extends BaseObserver {
@@ -42800,6 +42802,7 @@ var Finalizer = class extends BaseObserver {
         if (rec && !rec.title) rec.title = s2.title;
       }
     }
+    await this.writeAndCommitAdrs(prd);
     const commits = await this.collectCommitsSinceBase();
     const orderedStories = this.orderStories();
     const { passed, failed } = this.partition(orderedStories);
@@ -42840,6 +42843,45 @@ var Finalizer = class extends BaseObserver {
       return null;
     }
   }
+  // ─── ADRs ───────────────────────────────────────────────────────
+  /**
+   * Split the Architect's decision document into individual ADRs and write
+   * each as adr/NNNN-slug.md, then commit them so they ship in the PR. The
+   * trivial "no cross-cutting decisions needed" placeholder is skipped, and
+   * an unchanged adr/ (re-run) produces no empty commit. Best-effort: any
+   * failure is logged and never aborts finalization.
+   */
+  async writeAndCommitAdrs(prd) {
+    const doc = prd?.decisionDocument;
+    if (!doc || !doc.trim()) return;
+    const adrs = parseAdrs(doc);
+    if (adrs.length === 0) return;
+    try {
+      const dir = join3(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}
+
+${a.body}
+`);
+      }
+      await execFileAsync2("git", ["add", "adr"], { cwd: this.opts.cwd });
+      try {
+        await execFileAsync2(
+          "git",
+          ["commit", "-m", `docs: architecture decision records (${adrs.length})
+
+${BARO_COAUTHOR_TRAILER}`],
+          { cwd: this.opts.cwd }
+        );
+        this.log(`[finalizer] wrote ${adrs.length} ADR(s) to adr/`);
+      } catch {
+      }
+    } catch (e2) {
+      this.log(`[finalizer] could not write ADRs: ${e2.message}`);
+    }
+  }
   // ─── Story ordering & partitioning ──────────────────────────────
   /**
    * Stories returned in DAG order so the table reads top-down the same
@@ -43084,6 +43126,24 @@ var Finalizer = class extends BaseObserver {
     }
   }
 };
+function parseAdrs(doc) {
+  const adrs = [];
+  let cur = null;
+  for (const ln of doc.replace(/\r/g, "").split("\n")) {
+    const m2 = ln.match(/^##\s+ADR-(\d+):\s*(.*)$/);
+    if (m2) {
+      if (cur) adrs.push(cur);
+      cur = { num: m2[1], title: m2[2].trim(), body: [] };
+    } else if (cur) {
+      cur.body.push(ln);
+    }
+  }
+  if (cur) adrs.push(cur);
+  return adrs.filter((a) => !/no cross-cutting decisions/i.test(a.title)).map((a) => ({ num: a.num, title: a.title, body: a.body.join("\n").trim() }));
+}
+function slugify(s2) {
+  return s2.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60) || "decision";
+}
 function formatDuration(secs) {
   if (secs < 60) return `${Math.round(secs)}s`;
   const m2 = Math.floor(secs / 60);
@@ -43652,13 +43712,13 @@ function tokenizeHints(prompt) {
 }
 
 // ../baro-orchestrator/src/participants/memory-librarian.ts
-import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync4 } from "fs";
-import { join as join4 } from "path";
+import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync5 } from "fs";
+import { join as join5 } from "path";
 var DEBUG = process.env.BARO_DEBUG?.includes("memory") ?? false;
-var LOG_DIR = join4(process.env.HOME || "/tmp", ".baro", "runs");
-var LOG_FILE = join4(LOG_DIR, `memory-${Date.now()}.log`);
+var LOG_DIR = join5(process.env.HOME || "/tmp", ".baro", "runs");
+var LOG_FILE = join5(LOG_DIR, `memory-${Date.now()}.log`);
 try {
-  mkdirSync4(LOG_DIR, { recursive: true });
+  mkdirSync5(LOG_DIR, { recursive: true });
 } catch {
 }
 var stats = {
@@ -48191,7 +48251,7 @@ async function orchestrate(config) {
     );
   }
   if (config.auditLogPath) {
-    mkdirSync6(dirname3(config.auditLogPath), { recursive: true });
+    mkdirSync7(dirname3(config.auditLogPath), { recursive: true });
     new Auditor({ path: config.auditLogPath }).join(env);
   }
   if (config.extraParticipants) {
@@ -48217,8 +48277,8 @@ async function orchestrate(config) {
   const useLibrarian = config.withLibrarian ?? true;
   const useSentry = config.withSentry ?? true;
   const useMemory = config.withMemory ?? true;
-  const sessionsDir = join6(process.env.HOME || "/tmp", ".baro", "sessions");
-  const memorySessionPath = useMemory ? join6(sessionsDir, runId, "memory") : void 0;
+  const sessionsDir = join7(process.env.HOME || "/tmp", ".baro", "sessions");
+  const memorySessionPath = useMemory ? join7(sessionsDir, runId, "memory") : void 0;
   if (useMemory) {
     try {
       const { pruneOldSessions: pruneOldSessions2 } = await Promise.resolve().then(() => (init_dist2(), dist_exports));