bonecode 1.3.0 → 1.4.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);
+}

package/src/db_adapter.ts

@@ -164,6 +164,7 @@ CREATE TABLE IF NOT EXISTS sessions (
   summary_deletions INTEGER,
   share_url TEXT,
   workspace_id TEXT,
+  build_state TEXT,
   created_at TEXT DEFAULT (datetime('now')),
   updated_at TEXT DEFAULT (datetime('now'))
 );
@@ -309,6 +310,7 @@ export async function initDatabase(silent = false): Promise<{
           process.stderr.write(`[DB] Pool error: ${err.message}\n`);
         }
       });
+      await ensurePostgresColumns(pgPool);
       return { pool: pgPool, mode: "postgres", pgAvailable: true };
     }
     log(`\x1b[33m[BoneCode] Postgres not reachable at ${dbUrl.replace(/:[^:@]+@/, ":***@")} — trying Docker...\x1b[0m`);
@@ -330,6 +332,7 @@ export async function initDatabase(silent = false): Promise<{
         }
       });
       log(`\x1b[32m[BoneCode] PostgreSQL ready (Docker) — full RAG enabled\x1b[0m`);
+      await ensurePostgresColumns(pgPool);
       return { pool: pgPool, mode: "postgres", pgAvailable: true };
     }
   }
@@ -348,7 +351,33 @@ export async function initDatabase(silent = false): Promise<{
   const Database = require("better-sqlite3");
   const db = new Database(dbPath);
   db.exec(SQLITE_SCHEMA);
+  // Idempotent migrations for older databases — add new columns if missing.
+  // SQLite has no IF NOT EXISTS for columns, so we swallow the duplicate-column error.
+  const safeAlter = (sql: string) => { try { db.exec(sql); } catch { /* column exists */ } };
+  safeAlter(`ALTER TABLE sessions ADD COLUMN build_state TEXT`);
   db.close();
 
   return { pool: sqlitePool, mode: "sqlite", pgAvailable: false };
 }
+
+
+// ─── Postgres column migrations ───────────────────────────────────────────────
+
+/**
+ * Idempotently add columns the BoneScript-generated schema doesn't include.
+ * Each ALTER is run with IF NOT EXISTS / pg_class probing so it's safe to run
+ * on every server startup.
+ */
+async function ensurePostgresColumns(pool: any): Promise<void> {
+  const migrations: Array<{ table: string; column: string; type: string }> = [
+    { table: "sessions", column: "build_state", type: "JSONB" },
+  ];
+  for (const m of migrations) {
+    try {
+      await pool.query(`ALTER TABLE ${m.table} ADD COLUMN IF NOT EXISTS ${m.column} ${m.type}`);
+    } catch {
+      // Either the table doesn't exist yet (first run) or the user has
+      // restricted permissions. Build mode falls back to permission_ruleset.build.
+    }
+  }
+}