baro-ai 0.1.0 → 0.2.0

package/dist/chunk-HWC47EK2.js

@@ -0,0 +1,61 @@
+// 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
+};

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
-  __require
-} from "./chunk-3RG5ZIWI.js";
+  CliTask
+} from "./chunk-HWC47EK2.js";
 
 // src/cli.tsx
 import { render, Box as Box6 } from "ink";
@@ -9,6 +9,7 @@ import { render, Box as Box6 } from "ink";
 // src/App.tsx
 import { useState as useState3 } from "react";
 import { useApp as useApp2, useInput as useInput4 } from "ink";
+import * as fs5 from "fs";
 
 // src/screens/ApiKeyScreen.tsx
 import { useState } from "react";
@@ -222,10 +223,10 @@ function createCodebaseTools(cwd) {
         required: ["path"],
         additionalProperties: false
       },
-      async invoke(args) {
-        const target = safePath(cwd, args.path || ".");
-        if (!target || !fs2.existsSync(target)) return `Directory not found: ${args.path}`;
-        if (!fs2.statSync(target).isDirectory()) return `Not a directory: ${args.path}`;
+      async invoke(args2) {
+        const target = safePath(cwd, args2.path || ".");
+        if (!target || !fs2.existsSync(target)) return `Directory not found: ${args2.path}`;
+        if (!fs2.statSync(target).isDirectory()) return `Not a directory: ${args2.path}`;
         const results = [];
         function walk(dir, prefix, depth) {
           if (results.length >= 200 || depth > 4) return;
@@ -234,7 +235,7 @@ function createCodebaseTools(cwd) {
             const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
             if (entry.isDirectory()) {
               results.push(rel + "/");
-              if (args.recursive) walk(path2.join(dir, entry.name), rel, depth + 1);
+              if (args2.recursive) walk(path2.join(dir, entry.name), rel, depth + 1);
             } else {
               results.push(rel);
             }
@@ -255,10 +256,10 @@ function createCodebaseTools(cwd) {
         required: ["path"],
         additionalProperties: false
       },
-      async invoke(args) {
-        const target = safePath(cwd, args.path);
-        if (!target || !fs2.existsSync(target)) return `File not found: ${args.path}`;
-        if (fs2.statSync(target).isDirectory()) return `${args.path} is a directory. Use list_files.`;
+      async invoke(args2) {
+        const target = safePath(cwd, args2.path);
+        if (!target || !fs2.existsSync(target)) return `File not found: ${args2.path}`;
+        if (fs2.statSync(target).isDirectory()) return `${args2.path} is a directory. Use list_files.`;
         if (fs2.statSync(target).size > 5e5) return `File too large (${(fs2.statSync(target).size / 1024).toFixed(0)}KB)`;
         let content = fs2.readFileSync(target, "utf-8");
         if (content.length > MAX_FILE_SIZE) {
@@ -280,13 +281,13 @@ function createCodebaseTools(cwd) {
         required: ["pattern"],
         additionalProperties: false
       },
-      async invoke(args) {
-        const searchDir = safePath(cwd, args.path || ".");
-        if (!searchDir || !fs2.existsSync(searchDir)) return `Directory not found: ${args.path}`;
+      async invoke(args2) {
+        const searchDir = safePath(cwd, args2.path || ".");
+        if (!searchDir || !fs2.existsSync(searchDir)) return `Directory not found: ${args2.path}`;
         try {
           const excludes = Array.from(IGNORE).map((d) => `--exclude-dir=${d}`).join(" ");
-          const include = args.file_pattern ? `--include='${args.file_pattern}'` : "";
-          const cmd = `grep -rn -i ${excludes} ${include} --max-count=50 -- ${JSON.stringify(args.pattern)} ${JSON.stringify(searchDir)} 2>/dev/null || true`;
+          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(cwd) ? line.slice(cwd.length + 1) : line
@@ -446,26 +447,136 @@ var Planner = class {
   }
 };
 
+// src/core/claude-planner.ts
+var SYSTEM_PROMPT2 = `You are an expert software architect. Break down the user's project goal into concrete user stories that form a dependency DAG.
+
+You MUST explore the existing codebase first using your tools (read files, list directories, etc.) before generating the plan.
+
+Output ONLY valid JSON matching this exact schema (no markdown, no explanation, just JSON):
+{
+  "project": "short project name",
+  "branchName": "kebab-case-branch-name",
+  "description": "one-line description",
+  "userStories": [
+    {
+      "id": "S1",
+      "priority": 1,
+      "title": "short title",
+      "description": "what to implement",
+      "dependsOn": [],
+      "retries": 2,
+      "acceptance": ["testable criterion"],
+      "tests": ["npm test"]
+    }
+  ]
+}
+
+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 each)
+- Include testable acceptance criteria and test commands
+- No circular dependencies
+- Start with foundational stories, build up
+- IDs: S1, S2, S3...
+- Build on existing code, don't recreate what exists
+- Output ONLY the JSON, nothing else`;
+var ClaudePlanner = class {
+  cwd;
+  onLog;
+  constructor(options = {}) {
+    this.cwd = options.cwd ?? process.cwd();
+    this.onLog = options.onLog;
+  }
+  async send(userMessage) {
+    const prompt = `${SYSTEM_PROMPT2}
+
+User goal: ${userMessage}`;
+    const task = new CliTask({
+      id: "planner",
+      command: "claude",
+      args: [
+        "--dangerously-skip-permissions",
+        "--output-format",
+        "json",
+        "-p",
+        prompt
+      ],
+      cwd: this.cwd,
+      onStdout: (line) => this.onLog?.(line),
+      onStderr: (line) => this.onLog?.(line)
+    });
+    const result = await task.execute();
+    let jsonText = result.stdout.trim();
+    try {
+      const wrapper = JSON.parse(jsonText);
+      if (wrapper.result) {
+        jsonText = wrapper.result;
+      }
+    } catch {
+    }
+    const jsonMatch = jsonText.match(/```(?:json)?\s*([\s\S]*?)```/);
+    if (jsonMatch) {
+      jsonText = jsonMatch[1].trim();
+    }
+    let prd;
+    try {
+      prd = JSON.parse(jsonText);
+    } catch {
+      throw new Error("Claude didn't return valid JSON. Try again with a clearer goal.");
+    }
+    if (!prd.project || !prd.userStories) {
+      throw new Error("Invalid plan format. Missing project or userStories.");
+    }
+    return {
+      ...prd,
+      userStories: prd.userStories.map((s) => ({
+        id: s.id ?? "S?",
+        priority: s.priority ?? 0,
+        title: s.title ?? "",
+        description: s.description ?? "",
+        dependsOn: s.dependsOn ?? [],
+        retries: s.retries ?? 2,
+        acceptance: s.acceptance ?? [],
+        tests: s.tests ?? [],
+        passes: false,
+        completedAt: null,
+        durationSecs: null
+      }))
+    };
+  }
+};
+
 // src/screens/PlanScreen.tsx
 import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
-function PlanScreen({ onPlanReady, onQuit }) {
+function PlanScreen({ plannerMode: plannerMode2, onPlanReady, onQuit }) {
   const [input, setInput] = useState2("");
   const [loading, setLoading] = useState2(false);
   const [tokenCount, setTokenCount] = useState2(0);
   const [toolCalls, setToolCalls] = useState2([]);
   const [error, setError] = useState2("");
-  const [planner] = useState2(() => new Planner({
-    cwd: process.cwd(),
-    onToken: () => setTokenCount((c) => c + 1),
-    onToolCall: (name, args) => {
-      let label = name;
-      if (name === "read_file") label = `Reading ${args?.path ?? "..."}`;
-      else if (name === "grep") label = `Searching for "${args?.pattern ?? "..."}"`;
-      else if (name === "list_files") label = `Listing ${args?.path || "root"}`;
-      else if (name === "file_tree") label = "Scanning project structure";
-      setToolCalls((prev) => [...prev.slice(-8), label]);
+  const [planner] = useState2(() => {
+    if (plannerMode2 === "openai") {
+      return new Planner({
+        cwd: process.cwd(),
+        onToken: () => setTokenCount((c) => c + 1),
+        onToolCall: (name, args2) => {
+          let label = name;
+          if (name === "read_file") label = `Reading ${args2?.path ?? "..."}`;
+          else if (name === "grep") label = `Searching for "${args2?.pattern ?? "..."}"`;
+          else if (name === "list_files") label = `Listing ${args2?.path || "root"}`;
+          else if (name === "file_tree") label = "Scanning project structure";
+          setToolCalls((prev) => [...prev.slice(-8), label]);
+        }
+      });
     }
-  }));
+    return new ClaudePlanner({
+      cwd: process.cwd(),
+      onLog: (line) => {
+        setToolCalls((prev) => [...prev.slice(-8), line.slice(0, 80)]);
+      }
+    });
+  });
   const submit = useCallback(async () => {
     const goal = input.trim();
     if (!goal) return;
@@ -665,14 +776,12 @@ function ExecuteScreen({ prd, onDone }) {
 
 // src/App.tsx
 import { jsx as jsx5 } from "react/jsx-runtime";
-function App() {
+function App({ plannerMode: plannerMode2 }) {
   const app = useApp2();
   const [screen, setScreen] = useState3(() => {
-    if (process.env.OPENAI_API_KEY || process.env.ANTHROPIC_API_KEY) {
-      return "plan";
-    }
+    if (plannerMode2 === "claude") return "plan";
+    if (process.env.OPENAI_API_KEY) return "plan";
     try {
-      const fs5 = __require("fs");
       const home = process.env.HOME ?? "";
       const envPath = `${home}/.baro/.env`;
       if (fs5.existsSync(envPath)) {
@@ -681,33 +790,24 @@ function App() {
           const [key, val] = line.split("=");
           if (key && val) process.env[key.trim()] = val.trim();
         }
-        if (process.env.OPENAI_API_KEY || process.env.ANTHROPIC_API_KEY) {
-          return "plan";
-        }
+        if (process.env.OPENAI_API_KEY) return "plan";
       }
     } catch {
     }
     return "apikey";
   });
   const [prd, setPrd] = useState3(null);
-  useInput4((input, key) => {
-    if (key.escape && screen === "execute") {
-      app.exit();
-    }
+  useInput4((_input, key) => {
+    if (key.escape && screen === "execute") app.exit();
   });
   if (screen === "apikey") {
-    return /* @__PURE__ */ jsx5(
-      ApiKeyScreen,
-      {
-        onComplete: () => setScreen("plan"),
-        onQuit: () => app.exit()
-      }
-    );
+    return /* @__PURE__ */ jsx5(ApiKeyScreen, { onComplete: () => setScreen("plan"), onQuit: () => app.exit() });
   }
   if (screen === "plan") {
     return /* @__PURE__ */ jsx5(
       PlanScreen,
       {
+        plannerMode: plannerMode2,
         onPlanReady: (plan) => {
           setPrd(plan);
           setScreen("review");
@@ -727,18 +827,36 @@ function App() {
       }
     );
   }
-  return /* @__PURE__ */ jsx5(
-    ExecuteScreen,
-    {
-      prd,
-      onDone: () => app.exit()
-    }
-  );
+  return /* @__PURE__ */ jsx5(ExecuteScreen, { prd, onDone: () => app.exit() });
 }
 
 // src/cli.tsx
 import { jsx as jsx6 } from "react/jsx-runtime";
+var args = process.argv.slice(2);
+var plannerMode = "claude";
+for (let i = 0; i < args.length; i++) {
+  if (args[i] === "--planner" && args[i + 1]) {
+    const val = args[i + 1].toLowerCase();
+    if (val === "openai" || val === "gpt" || val.startsWith("gpt-")) {
+      plannerMode = "openai";
+    }
+    i++;
+  }
+  if (args[i] === "--help" || args[i] === "-h") {
+    console.log(`
+  baro - autonomous parallel coding
+
+  Usage:
+    baro                        Plan with Claude Code, execute with Claude Code
+    baro --planner openai       Plan with GPT-5.4 (needs OPENAI_API_KEY)
+
+  The default mode requires only Claude Code CLI installed.
+  No API keys needed.
+`);
+    process.exit(0);
+  }
+}
 process.stdout.write("\x1B[2J\x1B[H");
 render(
-  /* @__PURE__ */ jsx6(Box6, { width: "100%", flexDirection: "column", alignItems: "flex-start", children: /* @__PURE__ */ jsx6(App, {}) })
+  /* @__PURE__ */ jsx6(Box6, { width: "100%", flexDirection: "column", alignItems: "flex-start", children: /* @__PURE__ */ jsx6(App, { plannerMode }) })
 );

package/dist/core/executor.js

@@ -1,68 +1,12 @@
 #!/usr/bin/env node
-import "../chunk-3RG5ZIWI.js";
+import {
+  CliTask
+} from "../chunk-HWC47EK2.js";
 
 // src/core/executor.ts
 import * as path from "path";
 import * as fs from "fs";
 
-// 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);
-        }
-      });
-    });
-  }
-};
-
 // src/core/dag.ts
 function buildDag(stories) {
   const incomplete = stories.filter((s) => !s.passes);
@@ -137,7 +81,7 @@ async function main() {
           const task = new CliTask({
             id: story.id,
             command: "claude",
-            args: ["--dangerously-skip-permissions", "--output-format", "stream-json", "-p", prompt],
+            args: ["--dangerously-skip-permissions", "--output-format", "stream-json", "--verbose", "-p", prompt],
             cwd,
             onStdout: (line) => {
               try {
@@ -149,23 +93,27 @@ async function main() {
                         emit({ type: "story_log", id: story.id, line: l });
                       }
                     } else if (block.type === "tool_use") {
-                      emit({ type: "story_log", id: story.id, line: `\u2699 ${block.name}: ${JSON.stringify(block.input).slice(0, 100)}` });
-                    } else if (block.type === "tool_result") {
-                      const text = typeof block.content === "string" ? block.content : JSON.stringify(block.content);
-                      if (text.length > 0) {
-                        emit({ type: "story_log", id: story.id, line: text.slice(0, 150) });
-                      }
+                      const input = JSON.stringify(block.input ?? {});
+                      const preview = input.length > 80 ? input.slice(0, 80) + "..." : input;
+                      emit({ type: "story_log", id: story.id, line: `\u2699 ${block.name} ${preview}` });
                     }
                   }
+                } else if (ev.type === "system" && ev.subtype === "init") {
+                  emit({ type: "story_log", id: story.id, line: `Model: ${ev.model ?? "unknown"}` });
                 } else if (ev.type === "result") {
+                  if (ev.result) {
+                    for (const l of String(ev.result).split("\n").slice(0, 3)) {
+                      if (l.trim()) emit({ type: "story_log", id: story.id, line: l });
+                    }
+                  }
                 }
               } catch {
-                if (line.trim()) {
-                  emit({ type: "story_log", id: story.id, line });
-                }
+                if (line.trim()) emit({ type: "story_log", id: story.id, line });
               }
             },
-            onStderr: (line) => emit({ type: "story_log", id: story.id, line })
+            onStderr: (line) => {
+              if (line.trim()) emit({ type: "story_log", id: story.id, line });
+            }
           });
           const result = await task.execute();
           const dur = Math.round(result.durationMs / 1e3);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "baro-ai",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Autonomous parallel coding - plan and execute with AI",
   "type": "module",
   "bin": {

package/dist/chunk-3RG5ZIWI.js

@@ -1,10 +0,0 @@
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-
-export {
-  __require
-};