bonecode 1.3.0 → 1.4.2

package/scripts/test_build_fallback.js

@@ -0,0 +1,221 @@
+#!/usr/bin/env node
+/**
+ * Tests for the JSON-manifest fallback applier.
+ *
+ * The model-call portion is mocked — we feed in synthetic manifests and verify
+ * the on-disk result matches. The path-safety checks are critical to test
+ * because a buggy fallback could let a model write outside the worktree.
+ */
+
+"use strict";
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+const G = "\x1b[32m"; const R = "\x1b[31m"; const C = "\x1b[36m";
+const B = "\x1b[1m"; const D = "\x1b[2m"; const N = "\x1b[0m";
+
+let passed = 0;
+let failed = 0;
+const failures = [];
+
+function ok(name, info = "") {
+  passed++;
+  console.log(`  ${G}✓${N} ${name}${info ? `  ${D}${info}${N}` : ""}`);
+}
+function fail(name, msg) {
+  failed++;
+  failures.push(`${name}: ${msg}`);
+  console.log(`  ${R}✗${N} ${name}  ${R}${msg}${N}`);
+}
+function header(s) { console.log(`\n${C}${B}${s}${N}`); }
+
+// We re-implement the path-safety logic from executeFallback as a pure function
+// so we can test it without spinning up the DB.
+function applyManifest(manifest, worktree) {
+  const errors = [];
+  const written = [];
+
+  for (const f of manifest.files || []) {
+    if (!f || typeof f.path !== "string" || typeof f.content !== "string") continue;
+    if (f.path.includes("..") || path.isAbsolute(f.path)) {
+      errors.push(`refused unsafe path: ${f.path}`);
+      continue;
+    }
+    const target = path.resolve(worktree, f.path);
+    if (!target.startsWith(path.resolve(worktree))) {
+      errors.push(`refused path outside worktree: ${f.path}`);
+      continue;
+    }
+    try {
+      fs.mkdirSync(path.dirname(target), { recursive: true });
+      fs.writeFileSync(target, f.content, "utf-8");
+      written.push(target);
+    } catch (e) {
+      errors.push(`${f.path}: ${e.message}`);
+    }
+  }
+  return { written, errors };
+}
+
+// ─── Test setup ──────────────────────────────────────────────────────────────
+
+const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), "bonecode-fallback-test-"));
+
+function cleanup() {
+  try {
+    fs.rmSync(tmpRoot, { recursive: true, force: true });
+  } catch {}
+}
+process.on("exit", cleanup);
+process.on("SIGINT", () => { cleanup(); process.exit(130); });
+
+// ─── Tests ───────────────────────────────────────────────────────────────────
+
+header("[1] Manifest applies files correctly");
+
+(() => {
+  const wt = fs.mkdtempSync(path.join(tmpRoot, "wt-"));
+  const r = applyManifest({
+    files: [
+      { path: "hello.txt", content: "hello world" },
+      { path: "src/main.ts", content: "export const x = 42;\n" },
+    ],
+  }, wt);
+
+  if (r.written.length === 2 && r.errors.length === 0) {
+    ok("two files written");
+  } else {
+    fail("two files", `written=${r.written.length} errors=${r.errors.join(", ")}`);
+  }
+
+  if (fs.readFileSync(path.join(wt, "hello.txt"), "utf-8") === "hello world") ok("file content correct (root)");
+  else fail("root content", "mismatch");
+
+  if (fs.readFileSync(path.join(wt, "src/main.ts"), "utf-8") === "export const x = 42;\n") ok("file content correct (nested)");
+  else fail("nested content", "mismatch");
+
+  if (fs.statSync(path.join(wt, "src")).isDirectory()) ok("nested directory created");
+  else fail("nested dir", "missing");
+})();
+
+header("[2] Path-traversal rejected");
+
+(() => {
+  const wt = fs.mkdtempSync(path.join(tmpRoot, "wt-"));
+  const r = applyManifest({
+    files: [
+      { path: "../escape.txt", content: "should not write" },
+      { path: "ok.txt", content: "fine" },
+    ],
+  }, wt);
+
+  if (r.written.length === 1 && r.errors.length === 1 && /unsafe/.test(r.errors[0])) {
+    ok("traversal rejected, safe file written");
+  } else {
+    fail("traversal", `written=${r.written.length} errors=${r.errors.join(", ")}`);
+  }
+
+  // Verify the parent dir was NOT touched
+  const parent = path.dirname(wt);
+  if (!fs.existsSync(path.join(parent, "escape.txt"))) ok("no file written outside worktree");
+  else fail("escape", "file leaked outside worktree");
+})();
+
+header("[3] Absolute path rejected");
+
+(() => {
+  const wt = fs.mkdtempSync(path.join(tmpRoot, "wt-"));
+  const absolute = process.platform === "win32" ? "C:\\evil.txt" : "/tmp/evil.txt";
+  const r = applyManifest({
+    files: [{ path: absolute, content: "should not write" }],
+  }, wt);
+
+  if (r.written.length === 0 && r.errors.length === 1 && /unsafe/.test(r.errors[0])) {
+    ok("absolute path rejected");
+  } else {
+    fail("absolute", `written=${r.written.length} errors=${r.errors.join(", ")}`);
+  }
+})();
+
+header("[4] Malformed entries skipped silently");
+
+(() => {
+  const wt = fs.mkdtempSync(path.join(tmpRoot, "wt-"));
+  const r = applyManifest({
+    files: [
+      null,
+      undefined,
+      {},
+      { path: "ok.txt", content: "fine" },
+      { path: 123, content: "not a string" },
+      { path: "no-content.txt" },
+    ],
+  }, wt);
+
+  if (r.written.length === 1) ok("only well-formed entry processed");
+  else fail("malformed", `wrote ${r.written.length} files (expected 1)`);
+})();
+
+header("[5] Empty manifest is a no-op");
+
+(() => {
+  const wt = fs.mkdtempSync(path.join(tmpRoot, "wt-"));
+  const r1 = applyManifest({}, wt);
+  const r2 = applyManifest({ files: [] }, wt);
+  const r3 = applyManifest({ files: [], commands: [] }, wt);
+
+  if (r1.written.length === 0 && r2.written.length === 0 && r3.written.length === 0) {
+    ok("all empty shapes produce zero writes");
+  } else {
+    fail("empty", "writes happened on empty manifest");
+  }
+})();
+
+header("[6] Overwriting existing files works");
+
+(() => {
+  const wt = fs.mkdtempSync(path.join(tmpRoot, "wt-"));
+  const target = path.join(wt, "f.txt");
+  fs.writeFileSync(target, "old content");
+
+  const r = applyManifest({
+    files: [{ path: "f.txt", content: "new content" }],
+  }, wt);
+
+  if (r.written.length === 1 && fs.readFileSync(target, "utf-8") === "new content") {
+    ok("overwrite works");
+  } else {
+    fail("overwrite", `written=${r.written.length} content="${fs.readFileSync(target, "utf-8")}"`);
+  }
+})();
+
+header("[7] BuildState includes tool_capable field");
+
+(() => {
+  const src = fs.readFileSync(path.resolve(__dirname, "..", "src", "engine", "session", "build_mode.ts"), "utf-8");
+  if (/tool_capable\??\s*:\s*boolean/.test(src)) ok("BuildState declares tool_capable: boolean");
+  else fail("interface", "tool_capable not declared on BuildState");
+
+  if (/probeToolCapability/.test(src)) ok("probeToolCapability function exists");
+  else fail("probe", "function missing");
+
+  if (/executeFallback/.test(src)) ok("executeFallback function exists");
+  else fail("fallback", "function missing");
+
+  if (/MODEL_SUPPORTS_TOOLS/.test(src)) ok("respects MODEL_SUPPORTS_TOOLS env override");
+  else fail("env override", "not honored");
+
+  if (/ABORT_AFTER_CONSECUTIVE_ZERO/.test(src)) ok("early-bailout threshold present");
+  else fail("bailout", "no early bailout logic");
+})();
+
+console.log();
+if (failed === 0) {
+  console.log(`${G}${B}✓ All ${passed} tests passed${N}`);
+  process.exit(0);
+} else {
+  console.log(`${R}${B}✗ ${failed} failed, ${passed} passed${N}`);
+  for (const f of failures) console.log(`  ${R}- ${f}${N}`);
+  process.exit(1);
+}

package/scripts/test_build_mode.js

@@ -0,0 +1,301 @@
+#!/usr/bin/env node
+/**
+ * Unit tests for build_mode.ts pure logic:
+ *   - parseJsonLoose handles fenced/unfenced/think-tagged/balanced JSON
+ *   - isBuildPrompt identifies project-scoped vs ad-hoc prompts
+ *   - state transitions are persistable / restorable
+ *
+ * Skips anything that requires the live language model (askJson, runBuildMode).
+ */
+
+"use strict";
+const fs = require("fs");
+const path = require("path");
+
+const G = "\x1b[32m"; const R = "\x1b[31m"; const C = "\x1b[36m";
+const B = "\x1b[1m"; const D = "\x1b[2m"; const N = "\x1b[0m";
+
+let passed = 0;
+let failed = 0;
+const failures = [];
+
+function ok(name, info = "") {
+  passed++;
+  console.log(`  ${G}✓${N} ${name}${info ? `  ${D}${info}${N}` : ""}`);
+}
+function fail(name, msg) {
+  failed++;
+  failures.push(`${name}: ${msg}`);
+  console.log(`  ${R}✗${N} ${name}  ${R}${msg}${N}`);
+}
+function header(s) { console.log(`\n${C}${B}${s}${N}`); }
+
+// Extract pure functions from build_mode.ts source (so we don't trigger imports
+// that need a live DB pool / network)
+const ROOT = path.resolve(__dirname, "..");
+const src = fs.readFileSync(path.join(ROOT, "src", "engine", "session", "build_mode.ts"), "utf-8");
+
+function extractFunc(name) {
+  // Match `function name(`, `export function name(`, or with generic params <T>
+  const re = new RegExp(`(?:export\\s+)?function ${name}(?:<[^>]+>)?\\s*\\(`);
+  const m = src.match(re);
+  if (!m) return null;
+  // Strip the leading "export " if present so the eval'd source defines a local function
+  const start = m.index + (m[0].startsWith("export") ? "export ".length : 0);
+  let depth = 0;
+  let inStr = false;
+  let strChar = "";
+  let inTpl = false;
+  let inLineComment = false;
+  let inBlockComment = false;
+  let escape = false;
+  let i = src.indexOf("{", start);
+  for (; i < src.length; i++) {
+    const ch = src[i];
+    const next = src[i + 1];
+    if (escape) { escape = false; continue; }
+    if (ch === "\\") { escape = true; continue; }
+    if (inLineComment) {
+      if (ch === "\n") inLineComment = false;
+      continue;
+    }
+    if (inBlockComment) {
+      if (ch === "*" && next === "/") { inBlockComment = false; i++; }
+      continue;
+    }
+    if (inStr) {
+      if (ch === strChar) inStr = false;
+      continue;
+    }
+    if (inTpl) {
+      if (ch === "`") inTpl = false;
+      continue;
+    }
+    if (ch === "/" && next === "/") { inLineComment = true; i++; continue; }
+    if (ch === "/" && next === "*") { inBlockComment = true; i++; continue; }
+    if (ch === '"' || ch === "'") { inStr = true; strChar = ch; continue; }
+    if (ch === "`") { inTpl = true; continue; }
+    if (ch === "{") depth++;
+    else if (ch === "}") { depth--; if (depth === 0) return src.slice(start, i + 1); }
+  }
+  return null;
+}
+
+const parseJsonLooseSrc = extractFunc("parseJsonLoose");
+const extractBalancedSrc = extractFunc("extractBalanced");
+const tryParseSrc = extractFunc("tryParse");
+const isBuildPromptSrc = extractFunc("isBuildPrompt");
+
+if (!parseJsonLooseSrc || !extractBalancedSrc || !tryParseSrc || !isBuildPromptSrc) {
+  console.error("Could not extract helpers from build_mode.ts");
+  process.exit(1);
+}
+
+// Strip TypeScript annotations for plain Node eval
+function stripTs(s) {
+  return s
+    // Remove generic type parameters on function declarations: `function foo<T>(`
+    .replace(/function\s+(\w+)\s*<[^>]+>/g, "function $1")
+    // Remove generic type args at call sites: `foo<Bar>(...)` → `foo(...)`
+    // Only strip when followed by `(` so we don't break comparisons.
+    .replace(/(\b[a-zA-Z_$][\w$]*)<[^<>=]+>(?=\s*\()/g, "$1")
+    // Remove return-type annotations like `): T | null {` or `): string {`
+    .replace(/\)\s*:\s*[^=({}]+\s*\{/g, ") {")
+    // Remove parameter type annotations: `name: type`
+    .replace(/(\(|,\s*)([a-zA-Z_$][\w$]*)\s*:\s*[a-zA-Z_$][\w$<>|&,\s\[\]'"]*?(?=[,)])/g, "$1$2")
+    // Remove "as Type" assertions
+    .replace(/\bas\s+\w+(?:\s*\|\s*\w+)*/g, "")
+    // Drop "export " on declarations
+    .replace(/^export\s+/gm, "");
+}
+
+const sandboxSrc = `
+  ${stripTs(extractBalancedSrc)}
+  ${stripTs(tryParseSrc)}
+  ${stripTs(parseJsonLooseSrc)}
+  ${stripTs(isBuildPromptSrc)}
+  return { parseJsonLoose, extractBalanced, tryParse, isBuildPrompt };
+`;
+
+let helpers;
+try {
+  helpers = new Function(sandboxSrc)();
+} catch (e) {
+  console.error("Failed to evaluate helpers:", e.message);
+  console.error(sandboxSrc.slice(0, 500));
+  process.exit(1);
+}
+
+const { parseJsonLoose, isBuildPrompt } = helpers;
+
+// ─── parseJsonLoose ───────────────────────────────────────────────────────────
+
+header("[1] parseJsonLoose — JSON extraction");
+
+(() => {
+  const r = parseJsonLoose('{"a": 1, "b": "two"}');
+  if (r && r.a === 1 && r.b === "two") ok("plain JSON object");
+  else fail("plain JSON", JSON.stringify(r));
+})();
+
+(() => {
+  const r = parseJsonLoose('```json\n{"x": 42}\n```');
+  if (r && r.x === 42) ok("fenced JSON");
+  else fail("fenced JSON", JSON.stringify(r));
+})();
+
+(() => {
+  const r = parseJsonLoose("```\n{\"x\": 42}\n```");
+  if (r && r.x === 42) ok("fenced JSON without language");
+  else fail("fenced no-lang", JSON.stringify(r));
+})();
+
+(() => {
+  const r = parseJsonLoose('Here is the answer: {"ok": true} done.');
+  if (r && r.ok === true) ok("JSON with surrounding prose");
+  else fail("prose+json", JSON.stringify(r));
+})();
+
+(() => {
+  const r = parseJsonLoose('<think>let me think</think>\n{"ready": true}');
+  if (r && r.ready === true) ok("JSON after <think> block");
+  else fail("think+json", JSON.stringify(r));
+})();
+
+(() => {
+  // Nested objects
+  const r = parseJsonLoose('{"design": {"goal": "build a thing", "requirements": ["a", "b"]}}');
+  if (r && r.design && r.design.goal === "build a thing" && r.design.requirements.length === 2) {
+    ok("nested object with array");
+  } else {
+    fail("nested object", JSON.stringify(r));
+  }
+})();
+
+(() => {
+  const r = parseJsonLoose("not json at all");
+  if (r === null) ok("non-JSON returns null");
+  else fail("non-JSON", JSON.stringify(r));
+})();
+
+(() => {
+  // String containing braces
+  const r = parseJsonLoose('{"q": "what about { this }?"}');
+  if (r && r.q === "what about { this }?") ok("string with braces inside");
+  else fail("string with braces", JSON.stringify(r));
+})();
+
+(() => {
+  // JSON array at top level
+  const r = parseJsonLoose("[1, 2, 3]");
+  if (Array.isArray(r) && r.length === 3) ok("top-level array");
+  else fail("array", JSON.stringify(r));
+})();
+
+(() => {
+  // Truncated JSON returns null
+  const r = parseJsonLoose('{"a": 1, "b":');
+  if (r === null) ok("truncated JSON returns null");
+  else fail("truncated", JSON.stringify(r));
+})();
+
+// ─── isBuildPrompt ────────────────────────────────────────────────────────────
+
+header("[2] isBuildPrompt — trigger detection");
+
+const buildPrompts = [
+  "build me a 2D market simulation",
+  "create a full e-commerce backend",
+  "design and implement a chat application",
+  "make a complete authentication system",
+  "implement a full GraphQL API",
+  "build a backend for a todo app",
+  "create a marketplace from scratch",
+  "build me an end-to-end notification service",
+];
+for (const p of buildPrompts) {
+  if (isBuildPrompt(p)) ok(`"${p.slice(0, 50)}..."`, "→ build");
+  else fail(`build prompt missed`, p);
+}
+
+const adhocPrompts = [
+  "what does this function do",
+  "fix the typo in line 5",
+  "explain this error",
+  "rename foo to bar",
+  "show me the file",
+  "hi",
+  "how do I run this",
+];
+for (const p of adhocPrompts) {
+  if (!isBuildPrompt(p)) ok(`"${p}" → not build`);
+  else fail(`adhoc prompt over-matched`, p);
+}
+
+// ─── State persistence shape ──────────────────────────────────────────────────
+
+header("[3] BuildState shape — JSON round-trip");
+
+(() => {
+  const state = {
+    stage: "execute",
+    original_prompt: "build a thing",
+    design: {
+      goal: "thing",
+      requirements: ["does X", "does Y"],
+      constraints: ["fast", "simple"],
+      artifacts: ["src/thing.ts"],
+    },
+    todos: [
+      { id: "abc", title: "Write src/thing.ts", description: "create the thing", status: "completed", failure_count: 0, evidence: "1 tool call" },
+      { id: "def", title: "Test it", description: "run tests", status: "pending", failure_count: 1 },
+    ],
+    iteration: 5,
+    max_iterations: 30,
+  };
+  const round = JSON.parse(JSON.stringify(state));
+  const equal = JSON.stringify(round) === JSON.stringify(state);
+  if (equal) ok("BuildState round-trips through JSON");
+  else fail("round-trip", "objects differ");
+})();
+
+// ─── extractBalanced edge cases ───────────────────────────────────────────────
+
+header("[4] extractBalanced — bracket matching");
+
+const { extractBalanced } = helpers;
+
+(() => {
+  const r = extractBalanced("xx{a: 1}xx", 2, "{", "}");
+  if (r === "{a: 1}") ok("simple braces");
+  else fail("simple braces", `got "${r}"`);
+})();
+
+(() => {
+  const r = extractBalanced('{"q": "with { brace"}', 0, "{", "}");
+  if (r === '{"q": "with { brace"}') ok("braces inside string ignored");
+  else fail("string brace", `got "${r}"`);
+})();
+
+(() => {
+  const r = extractBalanced("{a:{b:{c:1}}}", 0, "{", "}");
+  if (r === "{a:{b:{c:1}}}") ok("nested braces");
+  else fail("nested", `got "${r}"`);
+})();
+
+(() => {
+  // Unbalanced — returns what we have
+  const r = extractBalanced("{a:1", 0, "{", "}");
+  if (r === "{a:1") ok("unbalanced returns partial");
+  else fail("unbalanced", `got "${r}"`);
+})();
+
+console.log();
+if (failed === 0) {
+  console.log(`${G}${B}✓ All ${passed} tests passed${N}`);
+  process.exit(0);
+} else {
+  console.log(`${R}${B}✗ ${failed} failed, ${passed} passed${N}`);
+  for (const f of failures) console.log(`  ${R}- ${f}${N}`);
+  process.exit(1);
+}