baro-ai 0.2.0 → 0.3.0

package/README.md

@@ -0,0 +1,119 @@
+# baro
+
+Autonomous parallel coding engine. Give it a goal, it breaks it into stories, builds a dependency DAG, and executes them in parallel using AI agents.
+
+```
+npm install -g baro-ai
+```
+
+## How it works
+
+1. **You describe a goal** - "Add authentication with JWT and role-based access control"
+2. **AI plans the work** - Claude (or OpenAI) explores your codebase and creates a dependency graph of user stories
+3. **You review the plan** - Scrollable plan review with accept/refine/quit
+4. **Stories execute in parallel** - Independent stories run simultaneously, each with its own Claude agent
+5. **Live TUI dashboard** - Watch progress, logs, DAG visualization, and stats in real-time
+
+## Usage
+
+### Interactive mode
+
+```bash
+baro
+```
+
+Opens the welcome screen where you type your goal and choose a planner.
+
+### Direct mode
+
+```bash
+baro "Add a REST API for user management"
+```
+
+Skips the welcome screen and starts planning immediately.
+
+### Options
+
+```
+baro [goal] [options]
+
+Arguments:
+  goal                    Project goal (opens welcome screen if omitted)
+
+Options:
+  --planner <planner>     Planner to use: claude or openai (default: claude)
+  --cwd <path>            Working directory (default: current directory)
+  -h, --help              Print help
+```
+
+### Examples
+
+```bash
+# Interactive - opens welcome screen
+baro
+
+# Plan and execute with Claude (default)
+baro "Refactor the database layer to use connection pooling"
+
+# Use OpenAI for planning
+baro --planner openai "Add WebSocket support"
+
+# Run in a specific directory
+baro --cwd ~/projects/myapp "Add unit tests for all API endpoints"
+```
+
+## TUI Screens
+
+### Welcome
+
+ASCII art logo, goal text input, and planner toggle (Claude/OpenAI).
+
+### Planning
+
+Animated spinner showing planning progress with elapsed timer. The selected AI explores your codebase and generates a structured plan.
+
+### Review
+
+Scrollable list of all planned stories with descriptions and dependencies. Navigate with arrow keys, accept with Enter, or quit with q.
+
+### Execution Dashboard
+
+Three tabs while stories execute:
+
+- **Dashboard** - Story list with status icons + live logs from the active agent
+- **DAG** - Dependency graph visualization showing levels and connections
+- **Stats** - Summary table with times, file counts, and completion stats
+
+Keybinds: `1/2/3` switch tabs, `Tab/Shift+Tab` switch log panels, `q` quit.
+
+## Requirements
+
+- [Claude CLI](https://docs.anthropic.com/en/docs/claude-cli) installed and authenticated (for Claude planner/executor)
+- Node.js 18+ (only needed if using `--planner openai`)
+- macOS (arm64/x64) or Linux (x64/arm64)
+
+## Architecture
+
+Baro is a Rust binary distributed via npm:
+
+- **TUI** - ratatui-based terminal UI with 4 screens
+- **Planner** - Spawns Claude CLI or OpenAI (via Node.js bridge) to generate a PRD
+- **DAG Engine** - Kahn's algorithm for topological sort with level grouping
+- **Executor** - Parallel story execution via tokio, one Claude agent per story
+- **npm package** - `postinstall` downloads the prebuilt binary for your platform
+
+## Development
+
+```bash
+# Build the Rust binary
+cargo build -p baro-tui --release
+
+# Run locally
+./target/release/baro "your goal"
+
+# The binary is in crates/baro-tui/
+```
+
+## License
+
+MIT

package/dist/openai-planner.js

@@ -0,0 +1,411 @@
+#!/usr/bin/env node
+
+// src/core/planner.ts
+import { z } from "zod";
+import { zodToJsonSchema } from "zod-to-json-schema";
+
+// src/core/stream.ts
+var API_URL = "https://api.openai.com/v1/responses";
+var MAX_TOOL_ROUNDS = 15;
+async function streamCompletion(opts) {
+  const apiKey = process.env.OPENAI_API_KEY;
+  if (!apiKey) throw new Error("OPENAI_API_KEY not set");
+  let input = [
+    ...opts.messages.map((m) => ({ role: m.role, content: m.content })),
+    { role: "user", content: opts.task }
+  ];
+  for (let round = 0; round < MAX_TOOL_ROUNDS; round++) {
+    const body = { model: opts.model, input, stream: true };
+    if (opts.reasoning) body.reasoning = opts.reasoning;
+    if (opts.jsonSchema) {
+      body.text = {
+        format: { type: "json_schema", name: "prd_output", schema: opts.jsonSchema, strict: true }
+      };
+    }
+    if (opts.tools?.length) {
+      body.tools = opts.tools.map((t) => ({
+        type: "function",
+        name: t.name,
+        description: t.description,
+        parameters: t.parameters
+      }));
+    }
+    const response = await fetch(API_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Authorization: `Bearer ${apiKey}` },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const errText = await response.text();
+      throw new Error(`OpenAI API error ${response.status}: ${errText}`);
+    }
+    if (!response.body) throw new Error("No response body");
+    const { textOutput, toolCalls, responseId } = await parseSSE(response.body, opts);
+    if (toolCalls.length === 0) {
+      return textOutput;
+    }
+    const toolResults = [];
+    for (const tc of toolCalls) {
+      const toolDef = opts.tools?.find((t) => t.name === tc.name);
+      if (!toolDef) continue;
+      opts.onToolCall?.(tc.name, tc.args);
+      let result;
+      try {
+        const parsed = JSON.parse(tc.args);
+        result = await toolDef.invoke(parsed);
+      } catch (err) {
+        result = `Error: ${err.message}`;
+      }
+      toolResults.push({
+        type: "function_call_output",
+        call_id: tc.callId,
+        output: typeof result === "string" ? result : JSON.stringify(result)
+      });
+    }
+    input = toolResults;
+  }
+  throw new Error("Too many tool calling rounds");
+}
+async function parseSSE(body, opts) {
+  let textOutput = "";
+  const toolCalls = [];
+  const toolCallArgs = /* @__PURE__ */ new Map();
+  let responseId = "";
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split("\n");
+    buffer = lines.pop() ?? "";
+    for (const line of lines) {
+      if (!line.startsWith("data: ")) continue;
+      const data = line.slice(6).trim();
+      if (data === "[DONE]") continue;
+      try {
+        const ev = JSON.parse(data);
+        if (ev.type === "response.created") {
+          responseId = ev.response?.id ?? "";
+        } else if (ev.type === "response.output_text.delta") {
+          textOutput += ev.delta ?? "";
+          opts.onToken(ev.delta ?? "");
+        } else if (ev.type === "response.reasoning.delta") {
+          opts.onThinking?.(ev.delta ?? "");
+        } else if (ev.type === "response.output_item.added") {
+          if (ev.item?.type === "function_call") {
+            toolCallArgs.set(ev.output_index, {
+              callId: ev.item.call_id ?? "",
+              name: ev.item.name ?? "",
+              args: ""
+            });
+          }
+        } else if (ev.type === "response.function_call_arguments.delta") {
+          const tc = toolCallArgs.get(ev.output_index);
+          if (tc) tc.args += ev.delta ?? "";
+        } else if (ev.type === "response.output_item.done") {
+          if (ev.item?.type === "function_call") {
+            const tc = toolCallArgs.get(ev.output_index);
+            if (tc) {
+              toolCalls.push({ callId: tc.callId, name: tc.name, args: tc.args });
+            }
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  return { textOutput, toolCalls, responseId };
+}
+
+// src/core/tools.ts
+import * as fs from "fs";
+import * as path from "path";
+import { execSync } from "child_process";
+var IGNORE = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".next",
+  ".nuxt",
+  "coverage",
+  ".cache",
+  "__pycache__",
+  "target",
+  ".output"
+]);
+var MAX_FILE_SIZE = 15e3;
+function createCodebaseTools(cwd2) {
+  return [
+    {
+      name: "list_files",
+      description: "List files and directories. Use path='' for project root. Returns file names with types. Ignores node_modules, .git, etc.",
+      parameters: {
+        type: "object",
+        properties: {
+          path: { type: "string", description: "Relative path from project root. Empty for root." },
+          recursive: { type: "boolean", description: "List all files recursively (max 200). Default false." }
+        },
+        required: ["path"],
+        additionalProperties: false
+      },
+      async invoke(args2) {
+        const target = safePath(cwd2, args2.path || ".");
+        if (!target || !fs.existsSync(target)) return `Directory not found: ${args2.path}`;
+        if (!fs.statSync(target).isDirectory()) return `Not a directory: ${args2.path}`;
+        const results = [];
+        function walk(dir, prefix, depth) {
+          if (results.length >= 200 || depth > 4) return;
+          for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+            if (IGNORE.has(entry.name) || entry.name.startsWith(".")) continue;
+            const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+            if (entry.isDirectory()) {
+              results.push(rel + "/");
+              if (args2.recursive) walk(path.join(dir, entry.name), rel, depth + 1);
+            } else {
+              results.push(rel);
+            }
+          }
+        }
+        walk(target, "", 0);
+        return results.join("\n") || "(empty directory)";
+      }
+    },
+    {
+      name: "read_file",
+      description: "Read file contents. Large files truncated to ~15000 chars. Use to understand code structure, configs, etc.",
+      parameters: {
+        type: "object",
+        properties: {
+          path: { type: "string", description: "Relative path to file (e.g. 'src/index.ts')" }
+        },
+        required: ["path"],
+        additionalProperties: false
+      },
+      async invoke(args2) {
+        const target = safePath(cwd2, args2.path);
+        if (!target || !fs.existsSync(target)) return `File not found: ${args2.path}`;
+        if (fs.statSync(target).isDirectory()) return `${args2.path} is a directory. Use list_files.`;
+        if (fs.statSync(target).size > 5e5) return `File too large (${(fs.statSync(target).size / 1024).toFixed(0)}KB)`;
+        let content = fs.readFileSync(target, "utf-8");
+        if (content.length > MAX_FILE_SIZE) {
+          content = content.slice(0, MAX_FILE_SIZE) + "\n... (truncated)";
+        }
+        return content;
+      }
+    },
+    {
+      name: "grep",
+      description: "Search for a text pattern across project files. Returns matching lines with file paths. Ignores node_modules, .git, etc.",
+      parameters: {
+        type: "object",
+        properties: {
+          pattern: { type: "string", description: "Text to search for (case-insensitive)" },
+          path: { type: "string", description: "Directory to search in. Default: entire project." },
+          file_pattern: { type: "string", description: "File glob (e.g. '*.ts'). Default: all." }
+        },
+        required: ["pattern"],
+        additionalProperties: false
+      },
+      async invoke(args2) {
+        const searchDir = safePath(cwd2, args2.path || ".");
+        if (!searchDir || !fs.existsSync(searchDir)) return `Directory not found: ${args2.path}`;
+        try {
+          const excludes = Array.from(IGNORE).map((d) => `--exclude-dir=${d}`).join(" ");
+          const include = args2.file_pattern ? `--include='${args2.file_pattern}'` : "";
+          const cmd = `grep -rn -i ${excludes} ${include} --max-count=50 -- ${JSON.stringify(args2.pattern)} ${JSON.stringify(searchDir)} 2>/dev/null || true`;
+          const output = execSync(cmd, { encoding: "utf-8", maxBuffer: 1024 * 1024 });
+          const lines = output.split("\n").filter(Boolean).map(
+            (line) => line.startsWith(cwd2) ? line.slice(cwd2.length + 1) : line
+          );
+          return lines.slice(0, 50).join("\n") || "No matches found.";
+        } catch {
+          return "No matches found.";
+        }
+      }
+    },
+    {
+      name: "file_tree",
+      description: "Get a condensed tree view of the project structure up to 3 levels deep. Good starting point to understand the codebase.",
+      parameters: {
+        type: "object",
+        properties: {},
+        additionalProperties: false
+      },
+      async invoke() {
+        const lines = [path.basename(cwd2) + "/"];
+        function walk(dir, prefix, depth) {
+          if (lines.length >= 150 || depth > 3) return;
+          let entries;
+          try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+          } catch {
+            return;
+          }
+          entries.sort((a, b) => {
+            if (a.isDirectory() && !b.isDirectory()) return -1;
+            if (!a.isDirectory() && b.isDirectory()) return 1;
+            return a.name.localeCompare(b.name);
+          });
+          for (let i = 0; i < entries.length; i++) {
+            if (IGNORE.has(entries[i].name) || entries[i].name.startsWith(".")) continue;
+            const isLast = i === entries.length - 1;
+            const connector = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+            const childPrefix = isLast ? "    " : "\u2502   ";
+            if (entries[i].isDirectory()) {
+              lines.push(`${prefix}${connector}${entries[i].name}/`);
+              walk(path.join(dir, entries[i].name), prefix + childPrefix, depth + 1);
+            } else {
+              lines.push(`${prefix}${connector}${entries[i].name}`);
+            }
+          }
+        }
+        walk(cwd2, "", 0);
+        return lines.join("\n");
+      }
+    }
+  ];
+}
+function safePath(cwd2, filePath) {
+  const resolved = path.resolve(cwd2, filePath);
+  if (!resolved.startsWith(path.resolve(cwd2))) return null;
+  return resolved;
+}
+
+// src/core/planner.ts
+var StorySchema = z.object({
+  id: z.string().describe("Short ID like S1, S2, S3"),
+  priority: z.number().describe("Priority level: lower = earlier"),
+  title: z.string().describe("Short title for the story"),
+  description: z.string().describe("What needs to be implemented"),
+  dependsOn: z.array(z.string()).describe("IDs of stories this depends on"),
+  retries: z.number().describe("Retry attempts if story fails (usually 2)"),
+  acceptance: z.array(z.string()).describe("Testable acceptance criteria"),
+  tests: z.array(z.string()).describe("Test commands (e.g. ['npm test'])")
+});
+var PrdSchema = z.object({
+  project: z.string().describe("Short project name"),
+  branchName: z.string().describe("Git branch name (kebab-case)"),
+  description: z.string().describe("One-line project description"),
+  userStories: z.array(StorySchema).describe("User stories forming a DAG")
+});
+var SYSTEM_PROMPT = `You are an expert software architect. Break down project goals into concrete user stories that form a dependency DAG.
+
+IMPORTANT: Before generating a plan, USE YOUR TOOLS to explore the existing codebase:
+1. Call file_tree to see the project structure
+2. Call read_file on key files (package.json, README, entry points, configs)
+3. Call grep to find relevant patterns
+4. THEN generate a plan that fits the existing code
+
+Rules:
+- Each story: single focused unit of work for one AI agent
+- Use dependsOn for dependencies; same-priority stories with no deps run IN PARALLEL
+- Keep stories small (15-60 min of work)
+- Include testable acceptance criteria and test commands
+- No circular dependencies
+- Start with foundational stories, build up
+- retries: 2-3 for most stories
+- IDs: S1, S2, S3...
+- branchName: kebab-case
+- Build on existing code, don't recreate what exists`;
+function fixSchemaForOpenAI(schema) {
+  if (!schema || typeof schema !== "object") return schema;
+  if (schema.type === "object" && schema.properties) {
+    schema.additionalProperties = false;
+  }
+  if (schema.properties) {
+    for (const key of Object.keys(schema.properties)) {
+      fixSchemaForOpenAI(schema.properties[key]);
+    }
+  }
+  if (schema.items) fixSchemaForOpenAI(schema.items);
+  delete schema.$schema;
+  return schema;
+}
+var Planner = class {
+  messages;
+  model;
+  onToken;
+  onToolCall;
+  tools;
+  constructor(options = {}) {
+    this.model = options.model ?? "gpt-5.4";
+    this.onToken = options.onToken;
+    this.onToolCall = options.onToolCall;
+    this.tools = options.cwd ? createCodebaseTools(options.cwd) : [];
+    this.messages = [{ role: "system", content: SYSTEM_PROMPT }];
+  }
+  async send(userMessage) {
+    const raw = zodToJsonSchema(PrdSchema, "prd");
+    const schema = fixSchemaForOpenAI(
+      raw.definitions?.prd ?? raw
+    );
+    const fullText = await streamCompletion({
+      model: this.model,
+      messages: this.messages,
+      task: userMessage,
+      jsonSchema: schema,
+      reasoning: { effort: "high" },
+      tools: this.tools.length > 0 ? this.tools : void 0,
+      onToken: this.onToken ?? (() => {
+      }),
+      onToolCall: this.onToolCall
+    });
+    let prd;
+    try {
+      prd = JSON.parse(fullText);
+    } catch {
+      throw new Error("Failed to parse plan output as JSON");
+    }
+    this.messages.push(
+      { role: "user", content: userMessage },
+      { role: "assistant", content: fullText }
+    );
+    return {
+      ...prd,
+      userStories: prd.userStories.map((s) => ({
+        ...s,
+        passes: false,
+        completedAt: null,
+        durationSecs: null
+      }))
+    };
+  }
+};
+
+// src/core/openai-planner.ts
+var args = process.argv.slice(2);
+var goal = "";
+var cwd = process.cwd();
+for (let i = 0; i < args.length; i++) {
+  if (args[i] === "--cwd" && args[i + 1]) {
+    cwd = args[++i];
+  } else if (!goal) {
+    goal = args[i];
+  }
+}
+if (!goal) {
+  console.error("Usage: openai-planner <goal> [--cwd <path>]");
+  process.exit(1);
+}
+async function main() {
+  const planner = new Planner({
+    cwd,
+    onToken: () => {
+    },
+    onToolCall: (name, args2) => {
+      process.stderr.write(`[openai] tool: ${name}
+`);
+    }
+  });
+  try {
+    const prd = await planner.send(goal);
+    process.stdout.write(JSON.stringify(prd, null, 2) + "\n");
+  } catch (err) {
+    console.error(`OpenAI planner error: ${err.message}`);
+    process.exit(1);
+  }
+}
+main();

package/package.json

@@ -1,29 +1,25 @@
 {
   "name": "baro-ai",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Autonomous parallel coding - plan and execute with AI",
   "type": "module",
   "bin": {
-    "baro": "./dist/cli.js"
+    "baro": "./bin/baro"
   },
   "files": [
-    "dist/",
     "bin/",
+    "dist/",
     "scripts/postinstall.js"
   ],
   "scripts": {
-    "build": "tsup src/cli.tsx src/core/executor.ts --format esm --external ink --external react --external ink-spinner",
+    "build": "tsup src/core/openai-planner.ts --format esm",
     "postinstall": "node scripts/postinstall.js"
   },
   "dependencies": {
-    "ink": "^5.2.0",
-    "ink-spinner": "^5.0.0",
-    "react": "^18.3.1",
     "zod": "^3.24.0",
     "zod-to-json-schema": "^3.25.1"
   },
   "devDependencies": {
-    "@types/react": "^18.3.0",
     "@types/node": "^22.0.0",
     "tsup": "^8.0.2",
     "typescript": "^5.3.3"

package/scripts/postinstall.js

@@ -1,10 +1,9 @@
 #!/usr/bin/env node
 /**
- * Postinstall script - downloads the baro-tui binary for the current platform.
+ * Postinstall script - downloads the baro binary for the current platform.
  * Binary is fetched from GitHub Releases.
  */
 
-import { execSync } from "child_process"
 import * as fs from "fs"
 import * as path from "path"
 import { fileURLToPath } from "url"
@@ -13,12 +12,12 @@ import * as https from "https"
 const __dirname = path.dirname(fileURLToPath(import.meta.url))
 const PACKAGE_ROOT = path.resolve(__dirname, "..")
 const BIN_DIR = path.join(PACKAGE_ROOT, "bin")
-const BINARY_NAME = "baro-tui"
+const BINARY_NAME = "baro"
 const REPO = "Lotus015/baro"
 
 function getPlatformKey() {
-    const platform = process.platform   // darwin, linux, win32
-    const arch = process.arch           // arm64, x64
+    const platform = process.platform
+    const arch = process.arch
 
     const map = {
         "darwin-arm64": "darwin-arm64",
@@ -29,9 +28,9 @@ function getPlatformKey() {
 
     const key = `${platform}-${arch}`
     if (!map[key]) {
-        console.warn(`⚠ baro-tui: no prebuilt binary for ${key}. Execution dashboard won't be available.`)
-        console.warn(`  You can build it manually: cargo build --release in the baro repo.`)
-        process.exit(0) // Don't fail install
+        console.warn(`Warning: no prebuilt baro binary for ${key}.`)
+        console.warn(`  You can build it manually: cargo build --release -p baro-tui`)
+        process.exit(0)
     }
     return map[key]
 }
@@ -64,7 +63,6 @@ async function download(url, dest) {
 }
 
 async function main() {
-    // Skip if binary already exists (e.g. local dev)
     const binaryPath = path.join(BIN_DIR, BINARY_NAME)
     if (fs.existsSync(binaryPath)) {
         return
@@ -75,19 +73,17 @@ async function main() {
 
     const url = `https://github.com/${REPO}/releases/download/v${version}/${BINARY_NAME}-${platformKey}`
 
-    console.log(`Downloading baro-tui for ${platformKey}...`)
+    console.log(`Downloading baro for ${platformKey}...`)
 
     fs.mkdirSync(BIN_DIR, { recursive: true })
 
     try {
         await download(url, binaryPath)
         fs.chmodSync(binaryPath, 0o755)
-        console.log(`✓ baro-tui installed`)
+        console.log(`baro installed successfully`)
     } catch (err) {
-        console.warn(`⚠ Could not download baro-tui: ${err.message}`)
-        console.warn(`  Planning will work. Execution dashboard requires the binary.`)
-        console.warn(`  Build manually: cargo build --release`)
-        // Don't fail the install
+        console.warn(`Warning: Could not download baro: ${err.message}`)
+        console.warn(`  Build manually: cargo build --release -p baro-tui`)
     }
 }
 

package/dist/chunk-HWC47EK2.js

@@ -1,61 +0,0 @@
-// src/core/cli-task.ts
-import { spawn } from "child_process";
-var CliTask = class {
-  id;
-  opts;
-  constructor(opts) {
-    this.id = opts.id;
-    this.opts = opts;
-  }
-  execute() {
-    return new Promise((resolve, reject) => {
-      const start = Date.now();
-      let stdout = "";
-      let stderr = "";
-      const proc = spawn(this.opts.command, this.opts.args, {
-        cwd: this.opts.cwd,
-        stdio: ["ignore", "pipe", "pipe"],
-        env: { ...process.env }
-      });
-      proc.stdout.on("data", (chunk) => {
-        const text = chunk.toString();
-        stdout += text;
-        if (this.opts.onStdout) {
-          for (const line of text.split("\n").filter(Boolean)) {
-            this.opts.onStdout(line);
-          }
-        }
-      });
-      proc.stderr.on("data", (chunk) => {
-        const text = chunk.toString();
-        stderr += text;
-        if (this.opts.onStderr) {
-          for (const line of text.split("\n").filter(Boolean)) {
-            this.opts.onStderr(line);
-          }
-        }
-      });
-      proc.on("error", (err) => {
-        reject(new Error(`Failed to spawn ${this.opts.command}: ${err.message}`));
-      });
-      proc.on("close", (code) => {
-        const result = {
-          stdout,
-          stderr,
-          exitCode: code ?? 1,
-          durationMs: Date.now() - start
-        };
-        if (code === 0) resolve(result);
-        else {
-          const err = new Error(`${this.opts.command} exited with code ${code}`);
-          err.result = result;
-          reject(err);
-        }
-      });
-    });
-  }
-};
-
-export {
-  CliTask
-};