bonecode 1.2.3 → 1.4.1

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;