bonecode 1.3.0 → 1.4.1

package/src/engine/session/build_mode_helpers.ts

@@ -0,0 +1,72 @@
+/**
+ * Provider/model factory used by build_mode.ts for structured-output prompts.
+ * Mirrors the factory in prompt.ts so the build orchestrator can issue
+ * non-streaming model calls without depending on the streaming agent loop.
+ */
+
+import { createOpenAI } from "@ai-sdk/openai";
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createGoogleGenerativeAI } from "@ai-sdk/google";
+
+export function getLanguageModel(provider_id: string, model_id: string): any {
+  const pid = provider_id.toLowerCase();
+
+  const resolvedProvider = pid === "local"
+    ? (process.env.DEFAULT_PROVIDER || "openai_compatible").toLowerCase()
+    : pid;
+  const resolvedModel = pid === "local"
+    ? (process.env.DEFAULT_MODEL || model_id)
+    : model_id;
+
+  const apiKey = (
+    process.env[`${resolvedProvider.toUpperCase()}_API_KEY`] ||
+    process.env.OPENAI_API_KEY ||
+    "not-needed"
+  );
+  const baseUrl = (
+    process.env[`${resolvedProvider.toUpperCase()}_BASE_URL`] ||
+    process.env.OPENAI_BASE_URL
+  );
+
+  switch (resolvedProvider) {
+    case "anthropic":
+      return createAnthropic({ apiKey, baseURL: baseUrl })(resolvedModel);
+
+    case "google":
+      return createGoogleGenerativeAI({ apiKey })(resolvedModel);
+
+    case "groq": {
+      const { createGroq } = require("@ai-sdk/groq");
+      return createGroq({ apiKey: process.env.GROQ_API_KEY || apiKey })(resolvedModel);
+    }
+
+    case "cerebras": {
+      const { createCerebras } = require("@ai-sdk/cerebras");
+      return createCerebras({ apiKey: process.env.CEREBRAS_API_KEY || apiKey })(resolvedModel);
+    }
+
+    case "deepseek":
+      return createOpenAI({
+        apiKey: process.env.DEEPSEEK_API_KEY || apiKey,
+        baseURL: "https://api.deepseek.com/v1",
+      })(resolvedModel);
+
+    case "openrouter": {
+      const { createOpenRouter } = require("@openrouter/ai-sdk-provider");
+      return createOpenRouter({
+        apiKey: process.env.OPENROUTER_API_KEY || apiKey,
+      })(resolvedModel);
+    }
+
+    case "ollama":
+      return createOpenAI({
+        apiKey: "ollama",
+        baseURL: process.env.OLLAMA_BASE_URL || "http://localhost:11434/v1",
+      })(resolvedModel);
+
+    case "openai":
+    case "openai_compatible":
+    default:
+      return createOpenAI({ apiKey, baseURL: baseUrl })(resolvedModel);
+  }
+}

package/src/engine/session/prompt/bonescript.txt

@@ -31,6 +31,17 @@ Use plain Python/TypeScript/etc. only for:
 
 If the request is ambiguous (e.g. "a 2D market simulation"), ask the user: "Is this a self-contained simulation script (plain code) or a backend service with persistence (BoneScript)?"
 
+## Build mode
+
+When the user starts a session with a project-scoped prompt ("build me X", "create a full Y"), BoneCode runs you in **build mode**. Build mode is a state machine: clarify → plan → execute → verify → done. You will receive structured prompts at each stage. Specifically:
+
+- **Clarify stage**: you'll be asked to either propose a design document (JSON) or ask 1-3 questions. Be concrete. Don't ramble.
+- **Plan stage**: you'll be asked for a JSON todo list. Each todo must be a single concrete file action.
+- **Execute stage**: you'll receive one todo at a time. **YOU MUST CALL TOOLS** — `write`, `edit`, `bash`. Prose-only responses are detected and rejected. The system will inject a reminder if you describe edits without calling tools.
+- **Verify stage**: for each requirement, you'll be asked yes/no whether it's satisfied. Be honest. If a requirement is not yet met, say so — the orchestrator will create fix-up tasks.
+
+The user can resume a build session at any time. Build state is persisted.
+
 ## BoneScript syntax — authoritative reference
 
 ### `system` block

package/src/engine/session/prompt.ts

@@ -96,6 +96,7 @@ export async function runAgentLoop(input: PromptInput): Promise<LoopResult> {
 
   const stats = { tokens_in: 0, tokens_out: 0, cost: 0, compacted: false };
   let turn = 0;
+  let lazyReminderSent = false;
   let lastFinishReason = "unknown";
 
   try {
@@ -174,6 +175,39 @@ export async function runAgentLoop(input: PromptInput): Promise<LoopResult> {
       // 3. "content-filter" = blocked — stop
       // 4. "tool-calls" with no actual tool calls = model confused — stop
       const terminalReasons = new Set(["stop", "length", "content-filter", "end-turn"]);
+
+      // Detect "lazy assistant" — the model claims it's editing/creating files
+      // in prose but never actually called a tool. Common with non-tool-tuned
+      // local models. Once per session, push a synthetic reminder and re-run.
+      const lazyAssistant = !result.has_tool_calls &&
+        Object.keys(tools).length > 0 &&
+        !lazyReminderSent &&
+        await wasLazyResponse(session_id, assistantMsgId);
+
+      if (lazyAssistant) {
+        lazyReminderSent = true;
+        broadcastToChannel("session_events", {
+          type: "session.warning",
+          session_id,
+          message: "Model claimed it would edit files but didn't call any tools. Reminding it to actually use the tools.",
+        });
+        // Insert a synthetic user reminder so the next turn sees it
+        const reminderMsgId = uuid();
+        await pool.query(
+          `INSERT INTO messages (id, session_id, role) VALUES ($1, $2, 'user')`,
+          [reminderMsgId, session_id]
+        );
+        const reminderPartId = uuid();
+        await pool.query(
+          `INSERT INTO parts (id, message_id, session_id, part_type, data, order_index) VALUES ($1, $2, $3, 'text', $4, 0)`,
+          [reminderPartId, reminderMsgId, session_id, JSON.stringify({
+            text: "<system-reminder>You described file changes but did not actually invoke any tools. The user cannot see prose descriptions of edits — only real tool calls produce file changes. Call the `write` or `edit` tool now to perform the actions you described. Do not respond with prose; emit a tool call.</system-reminder>",
+            synthetic: true,
+          })]
+        );
+        continue; // re-run the loop with the reminder appended
+      }
+
       if (terminalReasons.has(result.finish_reason) && !result.has_tool_calls) {
         break;
       }
@@ -222,9 +256,19 @@ async function streamWithRetry(ctx: {
     try {
       return await streamOnce(currentCtx);
     } catch (e: any) {
-      // On Bad Request with tools, retry without tools
+      // On Bad Request with tools, retry without tools BUT log it visibly so
+      // the user knows their model can't do tool calls — otherwise they get
+      // pure-prose responses with no real edits.
       if (e.message?.includes("Bad Request") && Object.keys(currentCtx.tools).length > 0 && attempt === 0) {
-        // Local model doesn't support function calling — silently retry without tools
+        logger.error("model_tools_unsupported", {
+          event: "tools_stripped",
+          metadata: { model: ctx.model_id, provider: ctx.provider_id, error: e.message },
+        });
+        broadcastToChannel("session_events", {
+          type: "session.warning",
+          session_id: ctx.session_id,
+          message: `Model ${ctx.model_id} rejected tool definitions — running without tools (no file edits possible). Set MODEL_SUPPORTS_TOOLS=false to suppress this warning, or use a tool-capable model.`,
+        });
         currentCtx = { ...currentCtx, tools: {} };
         attempt++;
         continue;
@@ -519,6 +563,29 @@ async function runCompaction(
 
 // ─── Message History Builder ──────────────────────────────────────────────────
 
+// Detect a "lazy" response — assistant text says it will edit/create files
+// but no tool was actually invoked. Common with non-tool-tuned local models.
+async function wasLazyResponse(session_id: string, messageId: string): Promise<boolean> {
+  const r = await pool.query(
+    `SELECT data FROM parts WHERE message_id = $1 AND part_type = 'text' ORDER BY order_index ASC`,
+    [messageId]
+  );
+  const text = r.rows.map((row: any) => row.data?.text || "").join(" ").toLowerCase();
+  if (!text || text.length < 30) return false;
+  // Phrases that imply the model is committing to a file edit it didn't make
+  const editIntentPatterns = [
+    /\bi['']ll\s+(create|write|update|edit|modify|add|implement|generate)\b/,
+    /\bi['']m\s+(creating|writing|updating|editing|modifying|adding|implementing|generating)\b/,
+    /\b(creating|writing|updating|editing|generating)\s+(?:the\s+)?(?:file|files|spec)\b/,
+    /\bi\s+(?:will|am\s+going\s+to)\s+(create|write|update|edit|implement|generate)\b/,
+    /\blet\s+me\s+(create|write|update|edit|implement)\b/,
+    /\bhere['']s\s+(?:the\s+)?(?:updated|new)\s+(?:file|version|content)\b/,
+    /\.(bone|ts|tsx|js|jsx|py|md|json|yaml|yml|sql|sh|html|css)\b.*\b(updated|created|written|modified|added)\b/,
+    /\b(updated|created|written|modified|added)\b.*\.(bone|ts|tsx|js|jsx|py|md|json|yaml|yml|sql|sh|html|css)\b/,
+  ];
+  return editIntentPatterns.some(re => re.test(text));
+}
+
 async function loadMessageHistory(session_id: string): Promise<any[]> {
   const result = await pool.query(
     `SELECT m.id, m.role, m.model_id, m.provider_id, m.tokens_input, m.tokens_output,

package/src/tui.ts

@@ -84,6 +84,7 @@ interface Command {
 
 const COMMANDS: Command[] = [
   { name: "/new",        description: "Start a new session" },
+  { name: "/build",      description: "Start autonomous build mode",  args: "<project description>" },
   { name: "/session",    description: "Show current session ID" },
   { name: "/sessions",   description: "List recent sessions" },
   { name: "/model",      description: "Switch model",          args: "<provider/model>" },
@@ -702,6 +703,88 @@ async function streamPrompt(opts: {
             nl(`   ${BLUE}⊕ Context compacted${R}`);
             continue;
           }
+
+          // Build mode events — autonomous orchestration progress
+          if (ev.type === "session.warning") {
+            flushTextLine();
+            nl(`   ${YELLOW}⚠ ${ev.message || ""}${R}`);
+            continue;
+          }
+          if (ev.type === "build.stage") {
+            flushTextLine();
+            const stage = (ev.stage || "?").toUpperCase();
+            nl(`   ${CYAN}${BOLD}▶ Build stage: ${stage}${R}`);
+            continue;
+          }
+          if (ev.type === "build.questions") {
+            flushTextLine();
+            nl(`   ${CYAN}${BOLD}? Clarifying questions:${R}`);
+            for (const q of ev.questions || []) {
+              nl(`     ${WHITE}- ${q}${R}`);
+            }
+            nl(`   ${GRAY}Reply with your answers to continue.${R}`);
+            continue;
+          }
+          if (ev.type === "build.design") {
+            flushTextLine();
+            const d = ev.design || {};
+            nl(`   ${CYAN}${BOLD}✓ Design locked in${R}`);
+            if (d.goal) nl(`     ${GRAY}goal: ${d.goal}${R}`);
+            if (Array.isArray(d.requirements)) nl(`     ${GRAY}${d.requirements.length} requirement(s), ${d.artifacts?.length || 0} artifact(s)${R}`);
+            continue;
+          }
+          if (ev.type === "build.plan") {
+            flushTextLine();
+            const todos = ev.todos || [];
+            nl(`   ${CYAN}${BOLD}✓ Plan: ${todos.length} task(s)${R}`);
+            for (let i = 0; i < Math.min(todos.length, 10); i++) {
+              const t = todos[i];
+              nl(`     ${GRAY}${(i + 1).toString().padStart(2, " ")}. ${t.title}${R}`);
+            }
+            if (todos.length > 10) nl(`     ${GRAY}... ${todos.length - 10} more${R}`);
+            continue;
+          }
+          if (ev.type === "build.todo.start") {
+            flushTextLine();
+            const t = ev.todo || {};
+            nl(`   ${WHITE}● ${t.title || ""}${R}`);
+            continue;
+          }
+          if (ev.type === "build.todo.done") {
+            flushTextLine();
+            const t = ev.todo || {};
+            nl(`   ${GREEN}✓ ${t.title || ""}${R}${t.evidence ? ` ${GRAY}(${t.evidence})${R}` : ""}`);
+            continue;
+          }
+          if (ev.type === "build.todo.retry") {
+            flushTextLine();
+            const t = ev.todo || {};
+            nl(`   ${YELLOW}⟳ Retry ${ev.attempt || ""}: ${t.title || ""}${R}`);
+            continue;
+          }
+          if (ev.type === "build.todo.failed") {
+            flushTextLine();
+            const t = ev.todo || {};
+            nl(`   ${RED}✗ ${t.title || ""}${R}  ${GRAY}${ev.reason || ""}${R}`);
+            continue;
+          }
+          if (ev.type === "build.verify.item") {
+            flushTextLine();
+            const icon = ev.satisfied ? `${GREEN}✓${R}` : `${RED}✗${R}`;
+            nl(`   ${icon} ${WHITE}${ev.requirement || ""}${R}`);
+            if (ev.evidence) nl(`     ${GRAY}${ev.evidence}${R}`);
+            continue;
+          }
+          if (ev.type === "build.replan") {
+            flushTextLine();
+            nl(`   ${YELLOW}↻ Re-planning: ${ev.added || 0} new task(s) to address gaps${R}`);
+            continue;
+          }
+          if (ev.type === "build.done") {
+            flushTextLine();
+            nl(`   ${GREEN}${BOLD}✓✓ Build complete — all requirements satisfied${R}`);
+            continue;
+          }
         } catch {
           // Ignore malformed events
         }
@@ -856,36 +939,62 @@ export async function runTUI(opts: {
   const promptStr = () => `${CYAN}${BOLD}>${R} `;
 
   // ─── Ctrl+C handling ──────────────────────────────────────────────────────
-  // When streaming: abort the request AND notify server
-  // When idle: clear menu/input or hint to use /exit
+  // Windows quirk: rl.on("SIGINT") only fires when readline is actively
+  // reading. We pause readline during streaming, which makes Ctrl+C dead.
+  // Use process.on("SIGINT") as the always-on handler so streaming aborts work.
+
+  let interruptCount = 0;
+
   const onSigint = async () => {
     if (streaming && abort) {
       abort.abort();
-      // Also tell the server to cancel the agent loop
+      // Tell the server to cancel the agent loop too
       try {
         await fetch(`http://localhost:${port}/v2/session/${sessionId}/cancel`, {
           method: "POST",
           headers: { "Authorization": `Bearer ${token}` },
         });
       } catch { /* server may not have the endpoint, abort is enough */ }
+      out(`\n${YELLOW}interrupted${R}\n`);
       // Don't reprompt here — the streamPrompt finally block will handle UI
       return;
     }
 
-    // Idle: clear menu if visible, else hint
+    interruptCount++;
+
+    // Idle: clear menu/input first, then on second Ctrl+C, exit
     if (menu.visible) {
       clearMenu(menu.rowsRendered);
       menu.visible = false;
       menu.rowsRendered = 0;
       menu.selected = 0;
+      interruptCount = 0;
+      out(`\n${promptStr()}`);
+      return;
     }
-    out(`\n${GRAY}(Ctrl+D or /exit to quit)${R}\n`);
-    rl.setPrompt(promptStr());
-    rl.prompt();
+
+    // If user typed something, clear it
+    const lineLen = ((rl as any).line || "").length;
+    if (lineLen > 0) {
+      (rl as any).line = "";
+      (rl as any).cursor = 0;
+      out(`\r${ESC}[2K${promptStr()}`);
+      interruptCount = 0;
+      return;
+    }
+
+    // Empty prompt + Ctrl+C: first time hint, second time exit
+    if (interruptCount >= 2) {
+      out(`\n${GRAY}Goodbye.${R}\n`);
+      process.exit(0);
+    }
+    out(`\n${GRAY}(Press Ctrl+C again or Ctrl+D to exit)${R}\n${promptStr()}`);
   };
 
-  // Detach readline's default SIGINT (which closes the line buffer)
-  // and route it to our handler.
+  // Register on BOTH process and readline so it works during streaming AND
+  // during input. Process-level catches signals while rl is paused; readline
+  // catches them while the user is typing.
+  process.on("SIGINT", onSigint);
   rl.on("SIGINT", onSigint);
 
   rl.on("close", () => {
@@ -1043,6 +1152,35 @@ export async function runTUI(opts: {
           } catch (e: any) { nl(`${RED}✗ ${e.message}${R}`); }
           break;
 
+        case "build": {
+          // /build <description> — start autonomous build mode for this prompt
+          const description = args.join(" ").trim();
+          if (!description) {
+            nl(`${YELLOW}Usage:${R} /build <project description>`);
+            nl(`${GRAY}Example: /build a 2D market simulation with 1000 shops over 100 years${R}`);
+            break;
+          }
+          // Send the prompt prefixed with /build so the server enters build mode
+          rl.pause();
+          renderUserMessage(`/build ${description}`);
+          out(`   ${GRAY}entering build mode...${R}`);
+          streaming = true;
+          abort = new AbortController();
+          const result = await streamPrompt({
+            port, token, sessionId: sessionId!, model, provider,
+            message: `/build ${description}`,
+            worktree, abortSignal: abort.signal,
+          });
+          streaming = false;
+          abort = null;
+          if (!result.text && !result.error) clearLine();
+          renderTurnEnd(model, result.elapsedMs, result.interrupted);
+          if (result.error && !result.interrupted) nl(`   ${RED}✗ ${result.error}${R}`);
+          nl();
+          rl.resume();
+          break;
+        }
+
         case "session":
           nl(`${GRAY}${sessionId}${R}`);
           break;