baro-ai 0.56.5 → 0.57.1

package/README.md

@@ -18,6 +18,8 @@ cd your-repo
 baro "Add JWT authentication with role-based access control"
 ```
 
+**No machine, or no Claude/Codex subscription?** Run the same fleet on **baro's cloud** — nothing to install, each run in an isolated sandbox, pay as you go. → **[app.baro.jigjoy.ai](https://app.baro.jigjoy.ai)**
+
 ![baro TUI at the end of a real run — 33 of 33 stories complete on a NestJS service, 2.2× parallel speedup, 32 files modified, PR opened](https://raw.githubusercontent.com/jigjoy-ai/baro/main/assets/screenshot.png)
 
 <sub>baro at the end of an [actual run](https://jigjoy.ai/blog/baro-808-nestjs-jest-tests) — one prompt → 33-story DAG → 32 files modified → PR opened. The summary panel shows wall time, parallel speedup (2.2×), token usage, and the PR URL.</sub>

package/dist/cli.mjs

@@ -22243,7 +22243,7 @@ var require_websocket_server = __commonJS({
 
 // ../baro-memory/dist/vectra-store.js
 import { LocalIndex } from "vectra";
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync3, renameSync, rmSync as rmSync2, readdirSync, statSync as statSync2, lstatSync } from "fs";
+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 { tmpdir as tmpdir2, homedir } from "os";
 async function createMemoryStore(config) {
@@ -22259,9 +22259,9 @@ async function createMemoryStore(config) {
   }
   const sessionPath = cfg.sessionPath || join3(tmpdir2(), `baro-memory-${process.pid}-${Date.now()}`);
   validateSessionPath(sessionPath);
-  mkdirSync2(sessionPath, { recursive: true });
+  mkdirSync3(sessionPath, { recursive: true });
   const indexPath = join3(sessionPath, "index");
-  mkdirSync2(indexPath, { recursive: true });
+  mkdirSync3(indexPath, { recursive: true });
   const index = new LocalIndex(indexPath);
   if (!await index.isIndexCreated()) {
     await index.createIndex({ version: 1 });
@@ -22294,7 +22294,7 @@ function pruneOldSessions(sessionsDir) {
     if (!existsSync3(sessionsDir))
       return;
     const now = Date.now();
-    for (const entry of readdirSync(sessionsDir)) {
+    for (const entry of readdirSync2(sessionsDir)) {
       if (!entry.startsWith("run-"))
         continue;
       const entryPath = join3(sessionsDir, entry);
@@ -22696,7 +22696,7 @@ import { existsSync as existsSync6 } from "fs";
 import { resolve as resolve3 } from "path";
 
 // ../baro-orchestrator/src/orchestrate.ts
-import { mkdirSync as mkdirSync5 } from "fs";
+import { mkdirSync as mkdirSync6 } from "fs";
 import { dirname as dirname3, join as join6 } from "path";
 
 // ../../node_modules/openai/internal/tslib.mjs
@@ -40075,12 +40075,23 @@ function extractStderr(e2) {
 
 // ../baro-orchestrator/src/worktree.ts
 import { execFile as execFile2 } from "child_process";
-import { existsSync, rmSync, symlinkSync } from "fs";
+import { existsSync, mkdirSync, readdirSync, rmSync, symlinkSync } from "fs";
 import { tmpdir } from "os";
 import { join } from "path";
 import { promisify as promisify3 } from "util";
 var exec2 = promisify3(execFile2);
-var LINKED_DEP_DIRS = ["node_modules", ".venv", "vendor"];
+var DEP_DIR_BY_MANIFEST = {
+  "package.json": "node_modules",
+  "pnpm-workspace.yaml": "node_modules",
+  "pyproject.toml": ".venv",
+  "requirements.txt": ".venv",
+  "setup.py": ".venv",
+  Pipfile: ".venv",
+  "composer.json": "vendor"
+};
+var DEP_DIR_NAMES = /* @__PURE__ */ new Set(["node_modules", ".venv", "vendor"]);
+var SCAN_SKIP = /* @__PURE__ */ new Set(["node_modules", ".git", ".venv", "vendor", "dist", "build", "target", ".next", "out", "coverage"]);
+var SCAN_DEPTH = 3;
 var WorktreeManager = class {
   constructor(repoRoot, gate, runId, opts = {}) {
     this.repoRoot = repoRoot;
@@ -40264,15 +40275,56 @@ var WorktreeManager = class {
     }
   }
   // ── internals ────────────────────────────────────────────────────
+  /**
+   * Package roots in the repo (root + nested), each mapped to the dep dir its stack
+   * installs into. Computed once per run and cached. Manifest-driven so it works on
+   * any stack and finds monorepo subpackages (e.g. `frontend` → node_modules).
+   */
+  depLocs;
+  depLocations() {
+    if (this.depLocs) return this.depLocs;
+    const out = [];
+    const seen = /* @__PURE__ */ new Set();
+    const scan = (rel, depth) => {
+      let entries;
+      try {
+        entries = readdirSync(join(this.repoRoot, rel) || this.repoRoot, { withFileTypes: true });
+      } catch {
+        return;
+      }
+      const record = (dir) => {
+        const key = `${rel}|${dir}`;
+        if (!seen.has(key)) {
+          seen.add(key);
+          out.push({ rel, dir });
+        }
+      };
+      for (const e2 of entries) {
+        if (e2.isFile() && DEP_DIR_BY_MANIFEST[e2.name]) record(DEP_DIR_BY_MANIFEST[e2.name]);
+        else if (e2.isDirectory() && DEP_DIR_NAMES.has(e2.name)) record(e2.name);
+      }
+      if (depth <= 0) return;
+      for (const e2 of entries) {
+        if (e2.isDirectory() && !SCAN_SKIP.has(e2.name) && !e2.name.startsWith(".")) {
+          scan(rel ? join(rel, e2.name) : e2.name, depth - 1);
+        }
+      }
+    };
+    scan("", SCAN_DEPTH);
+    this.depLocs = out;
+    return out;
+  }
   symlinkDepDirs(worktreePath) {
-    for (const dir of LINKED_DEP_DIRS) {
-      const src = join(this.repoRoot, dir);
-      const dest = join(worktreePath, dir);
-      if (!existsSync(src) || existsSync(dest)) continue;
+    for (const { rel, dir } of this.depLocations()) {
+      const shared = join(this.repoRoot, rel, dir);
+      const dest = join(worktreePath, rel, dir);
+      if (existsSync(dest)) continue;
       try {
-        symlinkSync(src, dest, "dir");
+        if (!existsSync(shared)) mkdirSync(shared, { recursive: true });
+        mkdirSync(join(worktreePath, rel), { recursive: true });
+        symlinkSync(shared, dest, "dir");
       } catch (e2) {
-        this.log(`could not symlink ${dir} into worktree (${errMsg(e2)})`);
+        this.log(`could not symlink ${join(rel, dir)} into worktree (${errMsg(e2)})`);
       }
     }
   }
@@ -40301,7 +40353,8 @@ var WorktreeManager = class {
       );
       return;
     }
-    await execQuiet("git", ["reset", "-q", "--", ...LINKED_DEP_DIRS], worktreePath);
+    const resetSpecs = this.depLocations().map(({ rel, dir }) => join(rel, dir));
+    if (resetSpecs.length) await execQuiet("git", ["reset", "-q", "--", ...resetSpecs], worktreePath);
     let staged = [];
     let diffFailed = false;
     try {
@@ -40315,9 +40368,7 @@ var WorktreeManager = class {
         `WARNING: could not inspect staged changes for story ${storyId} (${errMsg(e2)}); committing whatever is staged`
       );
     }
-    const depStaged = staged.filter(
-      (p) => LINKED_DEP_DIRS.some((d) => p === d || p.startsWith(`${d}/`))
-    );
+    const depStaged = staged.filter((p) => p.split("/").some((seg) => DEP_DIR_NAMES.has(seg)));
     if (depStaged.length > 0) {
       this.log(
         `WARNING: could not keep dep dirs [${depStaged.join(", ")}] out of story ${storyId}'s auto-commit; skipping it to avoid committing symlinks`
@@ -40577,7 +40628,7 @@ function formatRoute(route) {
 }
 
 // ../baro-orchestrator/src/participants/auditor.ts
-import { appendFileSync, mkdirSync } from "fs";
+import { appendFileSync, mkdirSync as mkdirSync2 } from "fs";
 import { dirname } from "path";
 
 // ../baro-orchestrator/src/semantic-events.ts
@@ -40642,7 +40693,7 @@ var Auditor = class extends BaseObserver {
     this.skipStreamChunks = opts.skipStreamChunks ?? true;
     this.filter = opts.filter;
     try {
-      mkdirSync(dirname(this.path), { recursive: true });
+      mkdirSync2(dirname(this.path), { recursive: true });
     } catch (e2) {
       this.disable(`mkdir failed: ${e2?.message ?? String(e2)}`);
     }
@@ -43561,13 +43612,13 @@ function tokenizeHints(prompt) {
 }
 
 // ../baro-orchestrator/src/participants/memory-librarian.ts
-import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync3 } from "fs";
+import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync4 } from "fs";
 import { join as join4 } 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`);
 try {
-  mkdirSync3(LOG_DIR, { recursive: true });
+  mkdirSync4(LOG_DIR, { recursive: true });
 } catch {
 }
 var stats = {
@@ -48089,7 +48140,7 @@ async function orchestrate(config) {
     );
   }
   if (config.auditLogPath) {
-    mkdirSync5(dirname3(config.auditLogPath), { recursive: true });
+    mkdirSync6(dirname3(config.auditLogPath), { recursive: true });
     new Auditor({ path: config.auditLogPath }).join(env);
   }
   if (config.extraParticipants) {