bravecode-cli 0.1.8 → 0.1.10

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "bravecode-cli",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "Agentic AI vibe coding CLI with free model support",
   "type": "module",
   "main": "dist/index.js",
   "bin": {
-    "bravecode": "./dist/cli.cjs"
+    "bravecode": "./dist/cli.mjs"
   },
   "files": [
     "dist/**/*",

package/scripts/build.js

@@ -1,14 +1,30 @@
 import { build } from "esbuild";
+import { readFileSync } from "fs";
+
+// Keep the user-facing version in src/version.ts in sync with package.json.
+const pkg = JSON.parse(readFileSync("package.json", "utf-8"));
+const versionTs = readFileSync("src/version.ts", "utf-8");
+const declared = versionTs.match(/APP_VERSION\s*=\s*"([^"]+)"/)?.[1];
+if (declared !== pkg.version) {
+  console.error(
+    `Version mismatch: package.json is ${pkg.version} but src/version.ts declares ${declared}. Update src/version.ts.`
+  );
+  process.exit(1);
+}
 
 await build({
   entryPoints: ["src/cli.ts"],
   bundle: true,
   platform: "node",
   target: "node18",
-  outfile: "dist/cli.cjs",
-  format: "cjs",
+  outfile: "dist/cli.mjs",
+  format: "esm",
   banner: {
-    js: '#!/usr/bin/env node',
+    js: [
+      "#!/usr/bin/env node",
+      "import { createRequire as __braveCreateRequire } from 'module';",
+      "const require = __braveCreateRequire(import.meta.url);",
+    ].join("\n"),
   },
   sourcemap: true,
   minify: false,

package/scripts/smoke-tool-calling.ts

@@ -0,0 +1,181 @@
+/**
+ * End-to-end smoke test for tool-calling wiring.
+ *
+ * Spins up a local HTTP server that mimics the Codero endpoint's wire format
+ * (JSON lines of {"delta": "..."} / {"done": true}) and drives the full agent
+ * loop against it via BRAVECODE_BASE_URL. No external network calls are made.
+ *
+ * Run with: npx tsx scripts/smoke-tool-calling.ts
+ */
+import { createServer, type Server } from "http";
+import assert from "assert";
+import { LLMProviderManager } from "../src/provider";
+import { ToolRegistry } from "../src/core/tool";
+import { Agent, defaultAgents } from "../src/core/agent";
+
+type Frag = string; // one JSON line of the mock stream
+
+interface MockTurn {
+  frags: (parsedRequest: any) => Frag[];
+}
+
+function delta(text: string): Frag {
+  return JSON.stringify({ delta: text });
+}
+
+function done(): Frag {
+  return JSON.stringify({ done: true });
+}
+
+const requests: any[] = [];
+
+// Scenario: turn 1 emits a tool call split across stream chunks (tests the
+// partial-tag buffering); turn 2 answers using the tool result; turn 3 is a
+// plain-text reply (no tool call); turn 4 emits an unparseable tool_call block
+// (must pass through as text, not crash).
+const turns: MockTurn[] = [
+  {
+    frags: () => [
+      delta("Let me run that command.\n"),
+      delta("<tool"),
+      delta(
+        `_call>\n{"name": "bash", "arguments": {"command": "echo wiring-ok"}}\n</tool_call>`
+      ),
+      delta("\n"),
+      done(),
+    ],
+  },
+  {
+    frags: (req) => {
+      const last = req.messages[req.messages.length - 1];
+      assert.strictEqual(last.role, "user", "tool result must arrive as a user message");
+      assert.ok(
+        last.content.includes("[Tool result for bash]") && last.content.includes("wiring-ok"),
+        `tool result not fed back correctly, got: ${JSON.stringify(last.content)}`
+      );
+      const assistantCall = (req.messages as any[]).find(
+        (m) => m.role === "assistant" && m.content.includes("<tool_call>")
+      );
+      assert.ok(
+        assistantCall && assistantCall.content.includes('"name":"bash"'),
+        "assistant tool call must be preserved in conversation history"
+      );
+      return [delta("The command output was: wiring-ok"), done()];
+    },
+  },
+  {
+    frags: () => [delta("hi there"), done()],
+  },
+  {
+    frags: () => [delta("Attempting: <tool_call>\n{not valid json}\n</tool_call>"), done()],
+  },
+  {
+    // Parent delegates to the plan subagent via the task tool.
+    frags: () => [
+      delta(
+        `<tool_call>\n{"name": "task", "arguments": {"agentId": "plan", "prompt": "analyze the code", "description": "architecture review"}}\n</tool_call>`
+      ),
+      done(),
+    ],
+  },
+  {
+    // Subagent (non-streaming path) answers without tools.
+    frags: () => [delta("plan says: looks good"), done()],
+  },
+  {
+    // Parent incorporates the subagent result.
+    frags: (req) => {
+      const last = req.messages[req.messages.length - 1];
+      assert.ok(
+        last.role === "user" && last.content.includes("[Tool result for task]") && last.content.includes("plan says: looks good"),
+        `subagent result not fed back to parent, got: ${JSON.stringify(last.content)}`
+      );
+      return [delta("Delegation complete: looks good"), done()];
+    },
+  },
+];
+
+const server: Server = createServer((req, res) => {
+  let body = "";
+  req.on("data", (c) => (body += c));
+  req.on("end", () => {
+    const parsed = JSON.parse(body);
+    const turn = turns[requests.length];
+    requests.push(parsed);
+    res.setHeader("Content-Type", "application/x-ndjson");
+    if (!turn) {
+      res.write(JSON.stringify({ delta: "unexpected extra request" }) + "\n");
+      res.write(done() + "\n");
+      res.end();
+      return;
+    }
+    for (const frag of turn.frags(parsed)) {
+      res.write(frag + "\n");
+    }
+    res.end();
+  });
+});
+
+async function main() {
+  await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
+  const port = (server.address() as any).port;
+  process.env.BRAVECODE_BASE_URL = `http://127.0.0.1:${port}/api/chat`;
+
+  const provider = new LLMProviderManager();
+  const tools = new ToolRegistry();
+
+  // --- Scenario 1: tool call -> execute -> result fed back -> final answer ---
+  const agent = new Agent(provider, tools, defaultAgents[0]);
+  let streamed = "";
+  const final = await agent.run("Run the echo command", (c) => (streamed += c));
+
+  assert.strictEqual(requests.length, 2, `expected 2 requests, got ${requests.length}`);
+  const req1 = requests[0];
+  assert.ok(
+    req1.system.includes("<tool_call>") && req1.system.includes("bash:"),
+    "system prompt must contain the tool protocol instructions and tool list"
+  );
+  assert.ok(
+    req1.messages.every((m: any) => ["user", "assistant"].includes(m.role)),
+    "codero payload must only contain user/assistant roles"
+  );
+  assert.ok(
+    streamed.includes("[bash result]: wiring-ok"),
+    "streamed output must include the bash tool result"
+  );
+  assert.ok(
+    final.includes("wiring-ok"),
+    `final answer should reference tool output, got: ${final}`
+  );
+
+  // --- Scenario 2: plain text response, no tool call -> single-turn return ---
+  const final2 = await agent.run("just say hi");
+  assert.strictEqual(requests.length, 3, "plain text reply must not loop");
+  assert.strictEqual(final2, "hi there");
+
+  // --- Scenario 3: malformed tool_call block passes through as text ---
+  const final3 = await agent.run("do the broken thing");
+  assert.strictEqual(requests.length, 4);
+  assert.ok(
+    final3.includes("{not valid json}"),
+    "unparseable tool_call block must pass through as text"
+  );
+
+  // --- Scenario 4: task tool delegates to a subagent and returns its result ---
+  const final4 = await agent.run("delegate an architecture review to the plan agent");
+  assert.strictEqual(requests.length, 7, `expected 7 requests (3 agent turns + subagent), got ${requests.length}`);
+  assert.ok(
+    final4.includes("looks good"),
+    `parent should incorporate subagent result, got: ${final4}`
+  );
+
+  console.log("\nAll tool-calling smoke tests passed.");
+  server.close();
+  process.exit(0);
+}
+
+main().catch((err) => {
+  console.error("\nSMOKE TEST FAILED:", err.message);
+  server.close();
+  process.exit(1);
+});

package/scripts/test-snapshot.ts

@@ -0,0 +1,99 @@
+/**
+ * Unit tests for SnapshotManager: targeted staging and safe revert.
+ * Each test runs against a throwaway git repo in a temp directory.
+ *
+ * Run with: npx tsx scripts/test-snapshot.ts
+ */
+import { mkdtempSync, rmSync, writeFileSync, readFileSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+import { execFileSync } from "child_process";
+import assert from "assert";
+import { SnapshotManager } from "../src/core/snapshot";
+
+function git(dir: string, args: string[]): string {
+  return execFileSync("git", args, { cwd: dir, encoding: "utf-8" });
+}
+
+function makeRepo(): string {
+  const dir = mkdtempSync(join(tmpdir(), "bravecode-snap-test-"));
+  git(dir, ["init", "-q"]);
+  git(dir, ["config", "user.email", "test@test.local"]);
+  git(dir, ["config", "user.name", "Test"]);
+  writeFileSync(join(dir, "a.txt"), "user v1\n");
+  git(dir, ["add", "-A"]);
+  git(dir, ["commit", "-q", "-m", "user init"]);
+  return dir;
+}
+
+function status(dir: string): string {
+  return git(dir, ["status", "--porcelain"]);
+}
+
+async function main() {
+  let dir = makeRepo();
+  try {
+    // --- Test 1: snapshot stages only the named file ---
+    const sm1 = new SnapshotManager(dir);
+    writeFileSync(join(dir, "b.txt"), "agent draft v1\n"); // agent's new file
+    writeFileSync(join(dir, "a.txt"), "user v2 uncommitted\n"); // user's concurrent edit
+
+    const snap = await sm1.createSnapshot("before edit", [join(dir, "b.txt")]);
+
+    assert.ok(snap.commitHash !== "no-changes" && !snap.commitHash.startsWith("fallback-"), "snapshot should create a commit");
+    const committed = git(dir, ["show", "--name-only", "--format=", "HEAD"]);
+    assert.ok(committed.includes("b.txt"), "snapshot commit should include b.txt");
+    assert.ok(!committed.includes("a.txt"), "snapshot commit must NOT include a.txt");
+    assert.ok(status(dir).includes("M a.txt"), "user's uncommitted a.txt change must remain uncommitted");
+    assert.deepStrictEqual(snap.files, ["b.txt"], "snapshot should record the changed file");
+    console.log("Test 1 passed: targeted staging commits only the named file");
+
+    // --- Test 2: revert restores the captured file state, touches nothing else ---
+    writeFileSync(join(dir, "b.txt"), "agent draft v2\n"); // agent's post-snapshot change
+
+    const result = await sm1.revert();
+    assert.ok(result.success, `revert should succeed: ${result.message}`);
+    assert.strictEqual(readFileSync(join(dir, "b.txt"), "utf-8"), "agent draft v1\n", "b.txt restored to captured state");
+    assert.strictEqual(readFileSync(join(dir, "a.txt"), "utf-8"), "user v2 uncommitted\n", "user's a.txt change untouched");
+    assert.ok(status(dir).includes("M a.txt"), "user's a.txt change still uncommitted after revert");
+    const logAfter = git(dir, ["log", "--oneline"]);
+    assert.ok(logAfter.includes("user init"), "history preserved (no reset)");
+    console.log("Test 2 passed: revert restores only the snapshot's file");
+
+    // --- Test 3: revert refuses when the user has committed on top ---
+    const sm2 = new SnapshotManager(dir);
+    writeFileSync(join(dir, "c.txt"), "agent new file\n");
+    await sm2.createSnapshot("before write", [join(dir, "c.txt")]);
+    git(dir, ["add", "-A"]);
+    git(dir, ["commit", "-q", "-m", "user follow-up commit"]); // HEAD moves past snapshot
+
+    const result3 = await sm2.revert();
+    assert.ok(!result3.success, "revert must refuse when HEAD moved past the snapshot");
+    assert.ok(result3.message.includes("Cannot revert"), `unexpected message: ${result3.message}`);
+    assert.strictEqual(git(dir, ["rev-parse", "HEAD"]), git(dir, ["rev-parse", "HEAD"]), "HEAD unchanged");
+    console.log("Test 3 passed: revert refuses when HEAD has moved");
+
+    // --- Test 4: snapshot of a nonexistent file is a no-op, not a crash ---
+    const sm3 = new SnapshotManager(dir);
+    const snap4 = await sm3.createSnapshot("before write", [join(dir, "does-not-exist.txt")]);
+    assert.strictEqual(snap4.commitHash, "no-changes", "missing file should yield no-changes snapshot");
+    console.log("Test 4 passed: nonexistent target file handled gracefully");
+
+    // --- Test 5: revert with no snapshots reports failure ---
+    dir = makeRepo();
+    const sm4 = new SnapshotManager(dir);
+    const result5 = await sm4.revert();
+    assert.ok(!result5.success, "revert without snapshots should fail gracefully");
+    console.log("Test 5 passed: revert without snapshots fails gracefully");
+
+    console.log("\nAll snapshot tests passed.");
+    process.exit(0);
+  } catch (err: any) {
+    console.error("\nSNAPSHOT TEST FAILED:", err.message);
+    process.exit(1);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+main();