baro-ai 0.1.0

package/dist/chunk-3RG5ZIWI.js

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

package/dist/cli.js

@@ -0,0 +1,744 @@
+#!/usr/bin/env node
+import {
+  __require
+} from "./chunk-3RG5ZIWI.js";
+
+// src/cli.tsx
+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";
+
+// src/screens/ApiKeyScreen.tsx
+import { useState } from "react";
+import { Box, Text, useInput } from "ink";
+import * as fs from "fs";
+import * as path from "path";
+import { jsx, jsxs } from "react/jsx-runtime";
+function ApiKeyScreen({ onComplete, onQuit }) {
+  const [input, setInput] = useState("");
+  const [error, setError] = useState("");
+  useInput((ch, key) => {
+    if (key.escape) return onQuit();
+    if (key.return) {
+      if (!input.trim()) {
+        setError("API key is required");
+        return;
+      }
+      saveKey(input.trim());
+      onComplete();
+      return;
+    }
+    if (key.backspace || key.delete) {
+      setInput((v) => v.slice(0, -1));
+      return;
+    }
+    if (ch && !key.ctrl) {
+      setInput((v) => v + ch);
+      setError("");
+    }
+  });
+  const masked = input.length <= 8 ? input : input.slice(0, 4) + "\u2022".repeat(Math.min(input.length - 8, 30)) + input.slice(-4);
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingX: 2, paddingY: 1, children: [
+    /* @__PURE__ */ jsx(Text, { bold: true, color: "cyan", children: "\u25B8 baro" }),
+    /* @__PURE__ */ jsx(Text, { dimColor: true, children: "Autonomous parallel coding" }),
+    /* @__PURE__ */ jsx(Box, { marginTop: 1 }),
+    /* @__PURE__ */ jsx(Text, { children: "Paste your API key to get started:" }),
+    /* @__PURE__ */ jsxs(Box, { marginTop: 1, children: [
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u276F " }),
+      /* @__PURE__ */ jsx(Text, { color: "cyan", children: masked || /* @__PURE__ */ jsx(Text, { dimColor: true, children: "sk-..." }) }),
+      /* @__PURE__ */ jsx(Text, { color: "cyan", children: "\u2588" })
+    ] }),
+    error ? /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { color: "red", children: error }) }) : null,
+    /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: "Enter to save \xB7 Esc to quit \xB7 Saved to ~/.baro/.env" }) })
+  ] });
+}
+function saveKey(key) {
+  const home = process.env.HOME ?? "";
+  const dir = path.join(home, ".baro");
+  fs.mkdirSync(dir, { recursive: true });
+  const envPath = path.join(dir, ".env");
+  const isAnthropic = key.startsWith("sk-ant-");
+  const varName = isAnthropic ? "ANTHROPIC_API_KEY" : "OPENAI_API_KEY";
+  fs.writeFileSync(envPath, `${varName}=${key}
+`, { mode: 384 });
+  process.env[varName] = key;
+}
+
+// src/screens/PlanScreen.tsx
+import { useState as useState2, useCallback } from "react";
+import { Box as Box2, Text as Text2, useInput as useInput2 } from "ink";
+import Spinner from "ink-spinner";
+
+// 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 fs2 from "fs";
+import * as path2 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(cwd) {
+  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(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}`;
+        const results = [];
+        function walk(dir, prefix, depth) {
+          if (results.length >= 200 || depth > 4) return;
+          for (const entry of fs2.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 (args.recursive) walk(path2.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(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.`;
+        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) {
+          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(args) {
+        const searchDir = safePath(cwd, args.path || ".");
+        if (!searchDir || !fs2.existsSync(searchDir)) return `Directory not found: ${args.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 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
+          );
+          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 = [path2.basename(cwd) + "/"];
+        function walk(dir, prefix, depth) {
+          if (lines.length >= 150 || depth > 3) return;
+          let entries;
+          try {
+            entries = fs2.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(path2.join(dir, entries[i].name), prefix + childPrefix, depth + 1);
+            } else {
+              lines.push(`${prefix}${connector}${entries[i].name}`);
+            }
+          }
+        }
+        walk(cwd, "", 0);
+        return lines.join("\n");
+      }
+    }
+  ];
+}
+function safePath(cwd, filePath) {
+  const resolved = path2.resolve(cwd, filePath);
+  if (!resolved.startsWith(path2.resolve(cwd))) 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/screens/PlanScreen.tsx
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function PlanScreen({ 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 submit = useCallback(async () => {
+    const goal = input.trim();
+    if (!goal) return;
+    setLoading(true);
+    setTokenCount(0);
+    setToolCalls([]);
+    setError("");
+    try {
+      const prd = await planner.send(goal);
+      onPlanReady(prd);
+    } catch (err) {
+      setError(err.message ?? String(err));
+      setLoading(false);
+    }
+  }, [input, planner, onPlanReady]);
+  useInput2((ch, key) => {
+    if (key.escape) return onQuit();
+    if (loading) return;
+    if (key.return) {
+      submit();
+      return;
+    }
+    if (key.backspace || key.delete) {
+      setInput((v) => v.slice(0, -1));
+      return;
+    }
+    if (ch && !key.ctrl) {
+      setInput((v) => v + ch);
+      setError("");
+    }
+  });
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", paddingX: 2, paddingY: 1, children: [
+    /* @__PURE__ */ jsx2(Text2, { bold: true, color: "cyan", children: "\u25B8 baro plan" }),
+    /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "Describe what you want to build" }),
+    /* @__PURE__ */ jsx2(Box2, { marginTop: 1 }),
+    loading ? /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs2(Box2, { children: [
+        /* @__PURE__ */ jsx2(Text2, { color: "cyan", children: /* @__PURE__ */ jsx2(Spinner, { type: "dots" }) }),
+        /* @__PURE__ */ jsxs2(Text2, { children: [
+          " ",
+          toolCalls.length > 0 && tokenCount === 0 ? "Exploring codebase..." : "Generating plan...",
+          " "
+        ] }),
+        /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+          "(",
+          tokenCount,
+          " tokens)"
+        ] })
+      ] }),
+      toolCalls.map((tc, i) => /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+        "  \u2699 ",
+        tc
+      ] }, i))
+    ] }) : /* @__PURE__ */ jsxs2(Box2, { children: [
+      /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "\u276F " }),
+      /* @__PURE__ */ jsx2(Text2, { children: input }),
+      /* @__PURE__ */ jsx2(Text2, { color: "cyan", children: "\u2588" })
+    ] }),
+    error ? /* @__PURE__ */ jsx2(Box2, { marginTop: 1, children: /* @__PURE__ */ jsx2(Text2, { color: "red", children: error }) }) : null,
+    /* @__PURE__ */ jsx2(Box2, { marginTop: 1, children: /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "Enter to generate \xB7 Esc to quit" }) })
+  ] });
+}
+
+// src/screens/ReviewScreen.tsx
+import { Box as Box3, Text as Text3, useInput as useInput3 } from "ink";
+import * as fs3 from "fs";
+import * as path3 from "path";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function ReviewScreen({ prd, onAccept, onRefine, onQuit }) {
+  useInput3((ch, key) => {
+    if (key.escape) return onQuit();
+    if (key.return || ch === "y") {
+      const prdPath = path3.join(process.cwd(), "prd.json");
+      fs3.writeFileSync(prdPath, JSON.stringify(prd, null, 2) + "\n");
+      onAccept();
+      return;
+    }
+    if (ch === "r") return onRefine();
+    if (ch === "q") return onQuit();
+  });
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", paddingX: 2, paddingY: 1, children: [
+    /* @__PURE__ */ jsx3(Text3, { bold: true, color: "cyan", children: "\u25B8 baro plan" }),
+    /* @__PURE__ */ jsx3(Box3, { marginTop: 1 }),
+    /* @__PURE__ */ jsxs3(Box3, { children: [
+      /* @__PURE__ */ jsx3(Text3, { bold: true, color: "white", children: prd.project }),
+      /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+        " (",
+        prd.branchName,
+        ")"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: prd.description }),
+    /* @__PURE__ */ jsx3(Box3, { marginTop: 1 }),
+    prd.userStories.map((story) => {
+      const deps = story.dependsOn.length > 0 ? ` \u2190 ${story.dependsOn.join(", ")}` : "";
+      return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", marginBottom: 1, children: [
+        /* @__PURE__ */ jsxs3(Box3, { children: [
+          /* @__PURE__ */ jsx3(Text3, { color: "yellow", children: story.id }),
+          /* @__PURE__ */ jsxs3(Text3, { children: [
+            " ",
+            story.title
+          ] }),
+          /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: deps })
+        ] }),
+        story.acceptance.map((ac, i) => /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+          "  \u2713 ",
+          ac
+        ] }, i))
+      ] }, story.id);
+    }),
+    /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+      prd.userStories.length,
+      " stories \xB7 ",
+      new Set(prd.userStories.map((s) => s.priority)).size,
+      " priority levels"
+    ] }),
+    /* @__PURE__ */ jsx3(Box3, { marginTop: 1, children: /* @__PURE__ */ jsxs3(Text3, { children: [
+      /* @__PURE__ */ jsx3(Text3, { bold: true, color: "green", children: "Enter" }),
+      /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: " accept \xB7 " }),
+      /* @__PURE__ */ jsx3(Text3, { bold: true, children: "r" }),
+      /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: " refine \xB7 " }),
+      /* @__PURE__ */ jsx3(Text3, { bold: true, children: "q" }),
+      /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: " quit" })
+    ] }) })
+  ] });
+}
+
+// src/screens/ExecuteScreen.tsx
+import { useEffect } from "react";
+import { Box as Box4, Text as Text4, useApp } from "ink";
+import { spawn, execSync as execSync2 } from "child_process";
+import * as fs4 from "fs";
+import * as path4 from "path";
+import { fileURLToPath } from "url";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+function findBinary(name, searchFrom) {
+  const pkgBin = path4.resolve(searchFrom, "..", "bin", name);
+  if (existsExec(pkgBin)) return pkgBin;
+  let dir = searchFrom;
+  for (let i = 0; i < 10; i++) {
+    const cargoTarget = path4.join(dir, "target", "release", name);
+    if (existsExec(cargoTarget)) return cargoTarget;
+    const parent = path4.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  try {
+    const which = execSync2(`which ${name}`, { encoding: "utf-8" }).trim();
+    if (which) return which;
+  } catch {
+  }
+  return null;
+}
+function existsExec(p) {
+  try {
+    fs4.accessSync(p, fs4.constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function ExecuteScreen({ prd, onDone }) {
+  const app = useApp();
+  useEffect(() => {
+    setTimeout(() => {
+      app.exit();
+      const thisDir = path4.dirname(fileURLToPath(import.meta.url));
+      const executorPath = path4.join(thisDir, "core", "executor.js");
+      const tuiBinary = findBinary("baro-tui", thisDir);
+      if (!tuiBinary) {
+        console.error("\nError: baro-tui binary not found.");
+        console.error("Build it: cd <baro-repo> && cargo build --release");
+        console.error("Or install: npm install -g @baro-ai/cli\n");
+        process.exit(1);
+      }
+      const executor = spawn("node", [executorPath], {
+        cwd: process.cwd(),
+        stdio: ["ignore", "pipe", "inherit"],
+        env: { ...process.env }
+      });
+      const tui = spawn(tuiBinary, [], {
+        cwd: process.cwd(),
+        stdio: [executor.stdout, "inherit", "inherit"]
+      });
+      tui.on("error", (err) => {
+        console.error("\nFailed to start baro-tui:", err.message);
+        process.exit(1);
+      });
+      tui.on("close", () => process.exit(0));
+    }, 100);
+  }, [app]);
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", paddingX: 2, paddingY: 1, children: [
+    /* @__PURE__ */ jsx4(Text4, { bold: true, color: "cyan", children: "\u25B8 baro" }),
+    /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "Starting execution dashboard..." })
+  ] });
+}
+
+// src/App.tsx
+import { jsx as jsx5 } from "react/jsx-runtime";
+function App() {
+  const app = useApp2();
+  const [screen, setScreen] = useState3(() => {
+    if (process.env.OPENAI_API_KEY || process.env.ANTHROPIC_API_KEY) {
+      return "plan";
+    }
+    try {
+      const fs5 = __require("fs");
+      const home = process.env.HOME ?? "";
+      const envPath = `${home}/.baro/.env`;
+      if (fs5.existsSync(envPath)) {
+        const content = fs5.readFileSync(envPath, "utf-8");
+        for (const line of content.split("\n")) {
+          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";
+        }
+      }
+    } catch {
+    }
+    return "apikey";
+  });
+  const [prd, setPrd] = useState3(null);
+  useInput4((input, key) => {
+    if (key.escape && screen === "execute") {
+      app.exit();
+    }
+  });
+  if (screen === "apikey") {
+    return /* @__PURE__ */ jsx5(
+      ApiKeyScreen,
+      {
+        onComplete: () => setScreen("plan"),
+        onQuit: () => app.exit()
+      }
+    );
+  }
+  if (screen === "plan") {
+    return /* @__PURE__ */ jsx5(
+      PlanScreen,
+      {
+        onPlanReady: (plan) => {
+          setPrd(plan);
+          setScreen("review");
+        },
+        onQuit: () => app.exit()
+      }
+    );
+  }
+  if (screen === "review") {
+    return /* @__PURE__ */ jsx5(
+      ReviewScreen,
+      {
+        prd,
+        onAccept: () => setScreen("execute"),
+        onRefine: () => setScreen("plan"),
+        onQuit: () => app.exit()
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx5(
+    ExecuteScreen,
+    {
+      prd,
+      onDone: () => app.exit()
+    }
+  );
+}
+
+// src/cli.tsx
+import { jsx as jsx6 } from "react/jsx-runtime";
+process.stdout.write("\x1B[2J\x1B[H");
+render(
+  /* @__PURE__ */ jsx6(Box6, { width: "100%", flexDirection: "column", alignItems: "flex-start", children: /* @__PURE__ */ jsx6(App, {}) })
+);

package/dist/core/executor.js

@@ -0,0 +1,222 @@
+#!/usr/bin/env node
+import "../chunk-3RG5ZIWI.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);
+  const completedIds = new Set(stories.filter((s) => s.passes).map((s) => s.id));
+  const storyMap = new Map(incomplete.map((s) => [s.id, s]));
+  const inDegree = /* @__PURE__ */ new Map();
+  const dependents = /* @__PURE__ */ new Map();
+  for (const s of incomplete) {
+    const activeDeps = s.dependsOn.filter(
+      (depId) => storyMap.has(depId) && !completedIds.has(depId)
+    );
+    inDegree.set(s.id, activeDeps.length);
+    for (const dep of activeDeps) {
+      if (!dependents.has(dep)) dependents.set(dep, []);
+      dependents.get(dep).push(s.id);
+    }
+  }
+  const levels = [];
+  let queue = incomplete.filter((s) => (inDegree.get(s.id) ?? 0) === 0);
+  while (queue.length > 0) {
+    queue.sort((a, b) => a.priority - b.priority);
+    levels.push({ stories: [...queue] });
+    const nextQueue = [];
+    for (const s of queue) {
+      for (const depId of dependents.get(s.id) ?? []) {
+        const newDegree = (inDegree.get(depId) ?? 1) - 1;
+        inDegree.set(depId, newDegree);
+        if (newDegree === 0) {
+          const story = storyMap.get(depId);
+          if (story) nextQueue.push(story);
+        }
+      }
+    }
+    queue = nextQueue;
+  }
+  const totalInLevels = levels.reduce((sum, l) => sum + l.stories.length, 0);
+  if (totalInLevels !== incomplete.length) {
+    const placed = new Set(levels.flatMap((l) => l.stories.map((s) => s.id)));
+    const cycled = incomplete.filter((s) => !placed.has(s.id)).map((s) => s.id);
+    throw new Error(`Dependency cycle detected involving: ${cycled.join(", ")}`);
+  }
+  return levels;
+}
+
+// src/core/executor.ts
+function emit(event) {
+  process.stdout.write(JSON.stringify(event) + "\n");
+}
+async function main() {
+  const cwd = process.cwd();
+  const prdPath = path.join(cwd, "prd.json");
+  const prd = JSON.parse(fs.readFileSync(prdPath, "utf-8"));
+  const incomplete = prd.userStories.filter((s) => !s.passes);
+  if (incomplete.length === 0) {
+    emit({ type: "done", total_time_secs: 0, stats: { stories_completed: prd.userStories.length, stories_skipped: 0, total_commits: 0, files_created: 0, files_modified: 0 } });
+    return;
+  }
+  emit({ type: "init", project: prd.project, stories: prd.userStories.map((s) => ({ id: s.id, title: s.title, depends_on: s.dependsOn })) });
+  const levels = buildDag(prd.userStories);
+  emit({ type: "dag", levels: levels.map((l) => l.stories.map((s) => ({ id: s.id, title: s.title }))) });
+  const startTime = Date.now();
+  let completed = 0;
+  let skipped = 0;
+  const total = incomplete.length;
+  for (const level of levels) {
+    await Promise.allSettled(level.stories.map(async (story) => {
+      const maxAttempts = story.retries + 1;
+      for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        emit({ type: "story_start", id: story.id, title: story.title });
+        try {
+          const prompt = buildPrompt(story, cwd);
+          const task = new CliTask({
+            id: story.id,
+            command: "claude",
+            args: ["--dangerously-skip-permissions", "--output-format", "stream-json", "-p", prompt],
+            cwd,
+            onStdout: (line) => {
+              try {
+                const ev = JSON.parse(line);
+                if (ev.type === "assistant" && ev.message?.content) {
+                  for (const block of ev.message.content) {
+                    if (block.type === "text" && block.text) {
+                      for (const l of block.text.split("\n").filter(Boolean)) {
+                        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) });
+                      }
+                    }
+                  }
+                } else if (ev.type === "result") {
+                }
+              } catch {
+                if (line.trim()) {
+                  emit({ type: "story_log", id: story.id, line });
+                }
+              }
+            },
+            onStderr: (line) => emit({ type: "story_log", id: story.id, line })
+          });
+          const result = await task.execute();
+          const dur = Math.round(result.durationMs / 1e3);
+          completed++;
+          const raw = JSON.parse(fs.readFileSync(prdPath, "utf-8"));
+          for (const s of raw.userStories) {
+            if (s.id === story.id) {
+              s.passes = true;
+              s.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+              s.durationSecs = dur;
+            }
+          }
+          fs.writeFileSync(prdPath, JSON.stringify(raw, null, 2) + "\n");
+          emit({ type: "story_complete", id: story.id, duration_secs: dur, files_created: 0, files_modified: 0 });
+          emit({ type: "progress", completed, total, percentage: Math.round(completed / total * 100) });
+          return;
+        } catch (err) {
+          emit({ type: "story_error", id: story.id, error: err.message, attempt, max_retries: maxAttempts });
+          if (attempt < maxAttempts) {
+            emit({ type: "story_retry", id: story.id, attempt: attempt + 1 });
+          } else {
+            skipped++;
+            emit({ type: "progress", completed, total, percentage: Math.round(completed / total * 100) });
+          }
+        }
+      }
+    }));
+  }
+  emit({ type: "done", total_time_secs: Math.round((Date.now() - startTime) / 1e3), stats: { stories_completed: completed, stories_skipped: skipped, total_commits: completed, files_created: 0, files_modified: 0 } });
+}
+function buildPrompt(story, cwd) {
+  const templatePath = path.join(cwd, "prompt.md");
+  let template;
+  if (fs.existsSync(templatePath)) {
+    template = fs.readFileSync(templatePath, "utf-8");
+  } else {
+    template = [
+      "You are working on story STORY_ID: STORY_TITLE",
+      "",
+      "STORY_DESCRIPTION",
+      "",
+      "ACCEPTANCE CRITERIA:",
+      "ACCEPTANCE_CRITERIA",
+      "",
+      "Run tests: TEST_COMMANDS",
+      'If tests pass, commit: git add . && git commit -m "feat(STORY_ID): STORY_TITLE"'
+    ].join("\n");
+  }
+  return template.replace(/STORY_ID/g, story.id).replace(/STORY_TITLE/g, story.title).replace(/STORY_DESCRIPTION/g, story.description).replace(/ACCEPTANCE_CRITERIA/g, story.acceptance.map((a) => "- " + a).join("\n")).replace(/TEST_COMMANDS/g, story.tests.join(" && "));
+}
+main().catch((err) => {
+  process.stderr.write("Fatal: " + err + "\n");
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "baro-ai",
+  "version": "0.1.0",
+  "description": "Autonomous parallel coding - plan and execute with AI",
+  "type": "module",
+  "bin": {
+    "baro": "./dist/cli.js"
+  },
+  "files": [
+    "dist/",
+    "bin/",
+    "scripts/postinstall.js"
+  ],
+  "scripts": {
+    "build": "tsup src/cli.tsx src/core/executor.ts --format esm --external ink --external react --external ink-spinner",
+    "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"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Lotus015/baro"
+  },
+  "keywords": ["ai", "coding", "cli", "parallel", "autonomous", "claude"],
+  "license": "MIT"
+}

package/scripts/postinstall.js

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+/**
+ * Postinstall script - downloads the baro-tui 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"
+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 REPO = "Lotus015/baro"
+
+function getPlatformKey() {
+    const platform = process.platform   // darwin, linux, win32
+    const arch = process.arch           // arm64, x64
+
+    const map = {
+        "darwin-arm64": "darwin-arm64",
+        "darwin-x64": "darwin-x64",
+        "linux-x64": "linux-x64",
+        "linux-arm64": "linux-arm64",
+    }
+
+    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
+    }
+    return map[key]
+}
+
+function getVersion() {
+    const pkg = JSON.parse(fs.readFileSync(path.join(PACKAGE_ROOT, "package.json"), "utf-8"))
+    return pkg.version
+}
+
+async function download(url, dest) {
+    return new Promise((resolve, reject) => {
+        const follow = (url) => {
+            https.get(url, { headers: { "User-Agent": "baro-cli" } }, (res) => {
+                if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+                    follow(res.headers.location)
+                    return
+                }
+                if (res.statusCode !== 200) {
+                    reject(new Error(`Download failed: ${res.statusCode} from ${url}`))
+                    return
+                }
+                const file = fs.createWriteStream(dest)
+                res.pipe(file)
+                file.on("finish", () => { file.close(); resolve() })
+                file.on("error", reject)
+            }).on("error", reject)
+        }
+        follow(url)
+    })
+}
+
+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
+    }
+
+    const platformKey = getPlatformKey()
+    const version = getVersion()
+
+    const url = `https://github.com/${REPO}/releases/download/v${version}/${BINARY_NAME}-${platformKey}`
+
+    console.log(`Downloading baro-tui for ${platformKey}...`)
+
+    fs.mkdirSync(BIN_DIR, { recursive: true })
+
+    try {
+        await download(url, binaryPath)
+        fs.chmodSync(binaryPath, 0o755)
+        console.log(`✓ baro-tui installed`)
+    } 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
+    }
+}
+
+main()