bonecode 1.0.0

package/src/tui.ts

@@ -0,0 +1,637 @@
+/**
+ * BoneCode Interactive Terminal UI
+ *
+ * Split-footer terminal session:
+ *   - Scrollback output fills the top of the terminal
+ *   - A persistent prompt sits at the bottom
+ *   - Streaming LLM output appears above the prompt in real time
+ *   - Ctrl+C interrupts the current request (does not exit)
+ *   - /new starts a fresh session, /exit or Ctrl+D quits
+ *   - Up/Down arrows navigate prompt history (readline built-in)
+ *   - @<path> autocomplete for files in the current worktree
+ *
+ * Built on Node's built-in readline — no external TUI framework needed.
+ */
+
+import * as path from "path";
+import * as fs from "fs";
+import * as readline from "readline";
+import * as http from "http";
+
+// ─── ANSI helpers ─────────────────────────────────────────────────────────────
+
+const ESC = "\x1b";
+const RESET = `${ESC}[0m`;
+const BOLD = `${ESC}[1m`;
+const DIM = `${ESC}[2m`;
+const CYAN = `${ESC}[36m`;
+const GREEN = `${ESC}[32m`;
+const YELLOW = `${ESC}[33m`;
+const RED = `${ESC}[31m`;
+const CLEAR_LINE = `${ESC}[2K\r`;
+const CURSOR_UP = `${ESC}[1A`;
+
+function stripAnsi(str: string): string {
+  return str.replace(/\x1b\[[0-9;]*[mGKHF]/g, "");
+}
+
+function truncate(str: string, width: number): string {
+  const clean = stripAnsi(str);
+  if (clean.length <= width) return str;
+  return str.slice(0, width - 1) + "…";
+}
+
+// ─── Config ───────────────────────────────────────────────────────────────────
+
+const PKG_ROOT = path.resolve(__dirname, "..");
+
+function getVersion(): string {
+  try {
+    return JSON.parse(fs.readFileSync(path.join(PKG_ROOT, "package.json"), "utf-8")).version;
+  } catch {
+    return "0.0.0";
+  }
+}
+
+// ─── TUI State ────────────────────────────────────────────────────────────────
+
+interface TUIState {
+  sessionId: string | null;
+  model: string;
+  provider: string;
+  port: number;
+  token: string;
+  worktree: string;
+  promptHistory: string[];
+  streaming: boolean;
+  abortController: AbortController | null;
+  turnCount: number;
+  totalTokens: number;
+}
+
+// ─── Server health check ──────────────────────────────────────────────────────
+
+async function waitForServer(port: number, maxWaitMs = 30_000): Promise<boolean> {
+  const start = Date.now();
+  while (Date.now() - start < maxWaitMs) {
+    try {
+      const ok = await new Promise<boolean>((resolve) => {
+        const req = http.get(`http://localhost:${port}/health`, (res) => {
+          resolve(res.statusCode === 200);
+        });
+        req.on("error", () => resolve(false));
+        req.setTimeout(1000, () => { req.destroy(); resolve(false); });
+      });
+      if (ok) return true;
+    } catch {}
+    await new Promise(r => setTimeout(r, 500));
+  }
+  return false;
+}
+
+// ─── API helpers ──────────────────────────────────────────────────────────────
+
+async function apiPost(url: string, body: object, token: string): Promise<Response> {
+  return fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", "Authorization": `Bearer ${token}` },
+    body: JSON.stringify(body),
+  });
+}
+
+async function apiGetJson<T = unknown>(url: string, token: string): Promise<T> {
+  const r = await fetch(url, { headers: { "Authorization": `Bearer ${token}` } });
+  if (!r.ok) throw new Error(`API error ${r.status}: ${await r.text()}`);
+  return r.json() as Promise<T>;
+}
+
+// ─── Session management ───────────────────────────────────────────────────────
+
+async function createSession(state: TUIState, title: string): Promise<string> {
+  const r = await apiPost(
+    `http://localhost:${state.port}/v2/session`,
+    { title, directory: state.worktree },
+    state.token
+  );
+  if (!r.ok) throw new Error(`Failed to create session: ${await r.text()}`);
+  const sess = await r.json() as { id?: string };
+  if (!sess.id) throw new Error("Server returned session without ID");
+  return sess.id;
+}
+
+// ─── @file autocomplete ───────────────────────────────────────────────────────
+
+const IGNORED_DIRS = new Set([
+  "node_modules", ".git", "dist", "build", ".next", "__pycache__",
+  ".venv", "venv", "target", "vendor", ".cache", "coverage",
+]);
+
+const CODE_EXTS = new Set([
+  ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs",
+  ".py", ".go", ".rs", ".java", ".kt", ".cs", ".cpp", ".c", ".h",
+  ".rb", ".php", ".swift", ".scala",
+  ".md", ".mdx", ".json", ".yaml", ".yml", ".toml", ".env",
+  ".sql", ".sh", ".bash", ".graphql",
+]);
+
+function listFilesForAutocomplete(worktree: string, prefix: string): string[] {
+  const results: string[] = [];
+  const MAX = 50;
+
+  function walk(dir: string, depth: number) {
+    if (results.length >= MAX || depth > 4) return;
+    let entries: fs.Dirent[];
+    try { entries = fs.readdirSync(dir, { withFileTypes: true }); }
+    catch { return; }
+
+    for (const e of entries) {
+      if (results.length >= MAX) break;
+      if (IGNORED_DIRS.has(e.name) || e.name.startsWith(".")) continue;
+      const rel = path.relative(worktree, path.join(dir, e.name));
+      if (e.isDirectory()) {
+        if (!prefix || rel.startsWith(prefix) || prefix.startsWith(rel)) {
+          results.push(rel + "/");
+          walk(path.join(dir, e.name), depth + 1);
+        }
+      } else if (CODE_EXTS.has(path.extname(e.name).toLowerCase())) {
+        if (!prefix || rel.startsWith(prefix)) {
+          results.push(rel);
+        }
+      }
+    }
+  }
+
+  walk(worktree, 0);
+  return results.sort();
+}
+
+function buildCompleter(worktree: string) {
+  return function completer(line: string): [string[], string] {
+    // Only trigger on @ mentions
+    const atIdx = line.lastIndexOf("@");
+    if (atIdx === -1) return [[], line];
+
+    const prefix = line.slice(atIdx + 1);
+    const files = listFilesForAutocomplete(worktree, prefix);
+    const completions = files.map(f => line.slice(0, atIdx + 1) + f);
+    return [completions, line];
+  };
+}
+
+// ─── Streaming output ─────────────────────────────────────────────────────────
+
+async function streamPrompt(
+  state: TUIState,
+  message: string,
+  onDelta: (text: string) => void,
+  onDone: (info: { tokens?: number; error?: string }) => void
+): Promise<void> {
+  if (!state.sessionId) throw new Error("No active session");
+
+  const ctrl = new AbortController();
+  state.abortController = ctrl;
+
+  try {
+    const r = await fetch(`http://localhost:${state.port}/v2/session/${state.sessionId}/prompt`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${state.token}`,
+      },
+      body: JSON.stringify({ content: message, modelID: state.model, providerID: state.provider }),
+      signal: ctrl.signal,
+    });
+
+    if (!r.ok) {
+      onDone({ error: `HTTP ${r.status}: ${await r.text()}` });
+      return;
+    }
+
+    const reader = r.body!.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+
+      for (const line of lines) {
+        if (!line.startsWith("data: ")) continue;
+        try {
+          const event = JSON.parse(line.slice(6));
+          if (event.type === "part.delta" && event.delta?.type === "text") {
+            onDelta(event.delta.text);
+          }
+          if (event.type === "error") {
+            onDone({ error: event.properties?.message || "Unknown error" });
+            return;
+          }
+        } catch { /* non-JSON SSE line */ }
+      }
+    }
+
+    // Poll for final stored response to get token counts
+    await new Promise(r => setTimeout(r, 800));
+    try {
+      const msgs = await apiGetJson<any[]>(
+        `http://localhost:${state.port}/v2/session/${state.sessionId}/message`,
+        state.token
+      );
+      const lastAssistant = msgs.filter(m => m.role === "assistant").slice(-1)[0];
+      const tokens = (lastAssistant?.tokens?.input || 0) + (lastAssistant?.tokens?.output || 0);
+      onDone({ tokens });
+    } catch {
+      onDone({});
+    }
+  } catch (e: any) {
+    if (e.name === "AbortError") {
+      onDone({ error: "interrupted" });
+    } else {
+      onDone({ error: e.message });
+    }
+  } finally {
+    state.abortController = null;
+  }
+}
+
+// ─── Terminal rendering ───────────────────────────────────────────────────────
+
+class TUIRenderer {
+  private promptLine = "";
+  private statusLine = "";
+  private streamBuffer = "";
+  private cols: number;
+
+  constructor() {
+    this.cols = process.stdout.columns || 80;
+    process.stdout.on("resize", () => {
+      this.cols = process.stdout.columns || 80;
+    });
+  }
+
+  print(text: string, newline = true): void {
+    this.clearPromptArea();
+    process.stdout.write(text + (newline ? "\n" : ""));
+    this.redrawPromptArea();
+  }
+
+  delta(text: string): void {
+    this.clearPromptArea();
+    process.stdout.write(text);
+    this.streamBuffer += text;
+    this.redrawPromptArea();
+  }
+
+  endStream(): void {
+    if (this.streamBuffer && !this.streamBuffer.endsWith("\n")) {
+      process.stdout.write("\n");
+    }
+    this.streamBuffer = "";
+    this.redrawPromptArea();
+  }
+
+  setStatus(text: string): void {
+    this.statusLine = text;
+    this.redrawPromptArea();
+  }
+
+  setPrompt(text: string): void {
+    this.promptLine = text;
+    this.redrawPromptArea();
+  }
+
+  private clearPromptArea(): void {
+    process.stdout.write(CLEAR_LINE);
+    process.stdout.write(CURSOR_UP + CLEAR_LINE);
+  }
+
+  private redrawPromptArea(): void {
+    const statusText = truncate(this.statusLine, this.cols - 2);
+    const promptText = truncate(this.promptLine, this.cols - 2);
+    process.stdout.write(`${DIM}${statusText}${RESET}\n`);
+    process.stdout.write(promptText);
+  }
+
+  initPromptArea(): void {
+    process.stdout.write("\n\n");
+    this.clearPromptArea();
+    this.redrawPromptArea();
+  }
+
+  separator(char = "─"): void {
+    this.print(`${DIM}${char.repeat(Math.min(this.cols, 60))}${RESET}`);
+  }
+
+  banner(model: string, worktree: string): void {
+    const VERSION = getVersion();
+    const dir = path.basename(worktree) || worktree;
+    this.print(`\n${CYAN}${BOLD}BoneCode${RESET} ${DIM}v${VERSION}${RESET}`);
+    this.print(`${DIM}  model: ${RESET}${model}`);
+    this.print(`${DIM}  dir:   ${RESET}${dir}`);
+    this.print(`${DIM}  type ${RESET}${CYAN}/help${RESET}${DIM} for commands · ${RESET}${CYAN}Ctrl+C${RESET}${DIM} to interrupt · ${RESET}${CYAN}Ctrl+D${RESET}${DIM} to exit${RESET}`);
+    this.separator();
+  }
+}
+
+// ─── Input handling ───────────────────────────────────────────────────────────
+
+class TUIInput {
+  private rl: readline.Interface;
+  private sigintHandler: (() => void) | null = null;
+
+  constructor(
+    private renderer: TUIRenderer,
+    private state: TUIState,
+    private onSubmit: (text: string) => Promise<void>
+  ) {
+    this.rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      terminal: true,
+      historySize: 100,
+      completer: buildCompleter(state.worktree),
+    });
+
+    // Seed readline history from state
+    for (const h of state.promptHistory.slice().reverse()) {
+      (this.rl as any).history?.unshift(h);
+    }
+
+    this.rl.on("line", async (line) => {
+      const text = line.trim();
+      if (text) {
+        state.promptHistory.push(text);
+        if (state.promptHistory.length > 100) state.promptHistory.shift();
+      }
+      await this.onSubmit(text);
+      this.prompt();
+    });
+
+    this.rl.on("close", () => {
+      this.cleanup();
+      renderer.print(`\n${DIM}Goodbye.${RESET}`);
+      process.exit(0);
+    });
+
+    // Register SIGINT handler — stored so we can remove it on cleanup
+    this.sigintHandler = () => {
+      if (state.abortController) {
+        state.abortController.abort();
+        renderer.print(`\n${YELLOW}⟳ Interrupted${RESET}`);
+        this.prompt();
+      } else {
+        renderer.print(`\n${DIM}(Use Ctrl+D or /exit to quit)${RESET}`);
+        this.prompt();
+      }
+    };
+    process.on("SIGINT", this.sigintHandler);
+  }
+
+  prompt(): void {
+    const sessionLabel = this.state.sessionId
+      ? `${DIM}[${this.state.sessionId.slice(0, 8)}]${RESET} `
+      : "";
+    const promptStr = `${CYAN}${BOLD}>${RESET} `;
+    const full = `${sessionLabel}${promptStr}`;
+    this.renderer.setPrompt(full);
+    this.rl.setPrompt(full);
+    this.rl.prompt(true);
+  }
+
+  cleanup(): void {
+    if (this.sigintHandler) {
+      process.removeListener("SIGINT", this.sigintHandler);
+      this.sigintHandler = null;
+    }
+  }
+
+  close(): void {
+    this.cleanup();
+    this.rl.close();
+  }
+}
+
+// ─── Command handlers ─────────────────────────────────────────────────────────
+
+async function handleCommand(cmd: string, state: TUIState, renderer: TUIRenderer): Promise<void> {
+  const parts = cmd.slice(1).trim().split(/\s+/);
+  const name = parts[0]?.toLowerCase() || "";
+  const args = parts.slice(1);
+
+  switch (name) {
+    case "help":
+    case "h":
+      renderer.print(`
+${CYAN}${BOLD}BoneCode Commands${RESET}
+  ${CYAN}/new${RESET}              Start a new session
+  ${CYAN}/session${RESET}          Show current session ID
+  ${CYAN}/model <id>${RESET}       Switch model (e.g. /model gpt-4o or /model anthropic/claude-sonnet-4-5)
+  ${CYAN}/clear${RESET}            Clear the screen
+  ${CYAN}/history${RESET}          Show last 10 prompts
+  ${CYAN}/exit${RESET}, ${CYAN}/quit${RESET}      Exit BoneCode
+  ${CYAN}Ctrl+C${RESET}            Interrupt current request (stays in session)
+  ${CYAN}Ctrl+D${RESET}            Exit BoneCode
+  ${CYAN}↑ / ↓${RESET}             Navigate prompt history
+  ${CYAN}@<path>${RESET}           Attach a file — press Tab to autocomplete`);
+      break;
+
+    case "new":
+      renderer.print(`${DIM}Starting new session...${RESET}`);
+      try {
+        state.sessionId = await createSession(state, "New Session");
+        state.turnCount = 0;
+        renderer.print(`${GREEN}✓ New session: ${state.sessionId.slice(0, 8)}...${RESET}`);
+        renderer.separator();
+      } catch (e: any) {
+        renderer.print(`${RED}✗ Failed to create session: ${e.message}${RESET}`);
+      }
+      break;
+
+    case "session":
+      if (state.sessionId) {
+        renderer.print(`${DIM}Session: ${RESET}${state.sessionId}`);
+      } else {
+        renderer.print(`${YELLOW}No active session${RESET}`);
+      }
+      break;
+
+    case "model":
+      if (args[0]) {
+        if (args[0].includes("/")) {
+          const slashIdx = args[0].indexOf("/");
+          state.provider = args[0].slice(0, slashIdx);
+          state.model = args[0].slice(slashIdx + 1);
+        } else {
+          state.model = args[0];
+        }
+        renderer.print(`${GREEN}✓ Model: ${state.provider}/${state.model}${RESET}`);
+        renderer.setStatus(`${DIM}${state.provider}/${state.model}${RESET}`);
+      } else {
+        renderer.print(`${DIM}Current model: ${RESET}${state.provider}/${state.model}`);
+      }
+      break;
+
+    case "clear":
+      process.stdout.write(`${ESC}[2J${ESC}[H`);
+      renderer.banner(`${state.provider}/${state.model}`, state.worktree);
+      renderer.initPromptArea();
+      break;
+
+    case "history":
+      if (state.promptHistory.length === 0) {
+        renderer.print(`${DIM}No history yet${RESET}`);
+      } else {
+        renderer.print(`${DIM}Recent prompts:${RESET}`);
+        state.promptHistory.slice(-10).forEach((h, i) => {
+          renderer.print(`  ${DIM}${i + 1}.${RESET} ${truncate(h, 70)}`);
+        });
+      }
+      break;
+
+    case "exit":
+    case "quit":
+    case "q":
+      renderer.print(`\n${DIM}Goodbye.${RESET}`);
+      process.exit(0);
+      break;
+
+    default:
+      renderer.print(`${YELLOW}Unknown command: /${name}${RESET} — type ${CYAN}/help${RESET} for commands`);
+  }
+}
+
+// ─── Main TUI loop ────────────────────────────────────────────────────────────
+
+export async function runTUI(opts: {
+  port: number;
+  token: string;
+  model: string;
+  provider: string;
+  worktree: string;
+  sessionId?: string;
+}): Promise<void> {
+  const state: TUIState = {
+    sessionId: opts.sessionId || null,
+    model: opts.model,
+    provider: opts.provider,
+    port: opts.port,
+    token: opts.token,
+    worktree: opts.worktree,
+    promptHistory: [],
+    streaming: false,
+    abortController: null,
+    turnCount: 0,
+    totalTokens: 0,
+  };
+
+  const renderer = new TUIRenderer();
+
+  // Create initial session
+  if (!state.sessionId) {
+    try {
+      state.sessionId = await createSession(state, "BoneCode Session");
+    } catch (e: any) {
+      process.stderr.write(`${RED}Failed to create session: ${e.message}${RESET}\n`);
+      process.exit(1);
+    }
+  }
+
+  renderer.banner(`${state.provider}/${state.model}`, state.worktree);
+  renderer.setStatus(`${DIM}${state.provider}/${state.model} · session ${state.sessionId!.slice(0, 8)}${RESET}`);
+  renderer.initPromptArea();
+
+  const tuiInput = new TUIInput(renderer, state, async (text: string) => {
+    if (!text) return;
+
+    if (text.startsWith("/")) {
+      await handleCommand(text, state, renderer);
+      return;
+    }
+
+    // Ensure session exists
+    if (!state.sessionId) {
+      try {
+        state.sessionId = await createSession(state, text.slice(0, 50));
+      } catch (e: any) {
+        renderer.print(`${RED}✗ Failed to create session: ${e.message}${RESET}`);
+        return;
+      }
+    }
+
+    // Resolve @file mentions to absolute paths
+    const resolvedText = text.replace(/@([\w./\-]+)/g, (match, filePath) => {
+      const abs = path.isAbsolute(filePath)
+        ? filePath
+        : path.resolve(state.worktree, filePath);
+      return fs.existsSync(abs) ? `@${abs}` : match;
+    });
+
+    renderer.print(`\n${CYAN}${BOLD}You${RESET}`);
+    renderer.print(resolvedText !== text ? `${text} ${DIM}(files resolved)${RESET}` : text);
+    renderer.separator("·");
+    renderer.print(`${GREEN}${BOLD}BoneCode${RESET} ${DIM}(${state.model})${RESET}`);
+
+    state.streaming = true;
+    const startMs = Date.now();
+    renderer.setStatus(`${YELLOW}⟳ thinking...${RESET}`);
+
+    await streamPrompt(
+      state,
+      resolvedText,
+      (delta) => {
+        // Strip markdown fences — they don't render well in terminals
+        const clean = delta.replace(/^```\w*\n?/gm, "").replace(/^```\n?/gm, "");
+        if (clean) renderer.delta(clean);
+      },
+      (info) => {
+        renderer.endStream();
+        state.streaming = false;
+        state.turnCount++;
+
+        const elapsed = ((Date.now() - startMs) / 1000).toFixed(1);
+        if (info.tokens) state.totalTokens += info.tokens;
+
+        if (info.error && info.error !== "interrupted") {
+          renderer.print(`${RED}✗ ${info.error}${RESET}`);
+        }
+
+        renderer.separator();
+
+        const tokenStr = info.tokens ? ` · ${info.tokens} tok` : "";
+        const statusStr = info.error === "interrupted"
+          ? `${YELLOW}interrupted${RESET}`
+          : `${DIM}${elapsed}s${tokenStr}${RESET}`;
+        renderer.setStatus(
+          `${DIM}${state.provider}/${state.model} · turn ${state.turnCount}${RESET} · ${statusStr}`
+        );
+      }
+    );
+  });
+
+  tuiInput.prompt();
+
+  // Keep process alive until readline closes
+  await new Promise<void>(() => {});
+}
+
+// ─── Entry point ──────────────────────────────────────────────────────────────
+
+export async function startInteractiveTUI(opts: {
+  port: number;
+  token: string;
+  model: string;
+  provider: string;
+  worktree: string;
+}): Promise<void> {
+  const serverReady = await waitForServer(opts.port, 30_000);
+  if (!serverReady) {
+    process.stderr.write(`${RED}Error: BoneCode server not responding on port ${opts.port}${RESET}\n`);
+    process.stderr.write(`${DIM}Start it with: bonecode serve${RESET}\n`);
+    process.exit(1);
+  }
+  await runTUI(opts);
+}

package/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": ["ES2020", "DOM"],
+    "outDir": "./dist",
+    "rootDir": ".",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "sourceMap": true,
+    "resolveJsonModule": true,
+    "paths": {
+      "@bone/session/*": ["./bone/output/session/src/*"],
+      "@bone/agent/*": ["./bone/output/agent/src/*"],
+      "@bone/rag/*": ["./bone/output/rag/src/*"],
+      "@bone/workspace/*": ["./bone/output/workspace/src/*"]
+    }
+  },
+  "include": ["src/**/*", "extensions/**/*", "compat/**/*"],
+  "exclude": ["node_modules", "dist", "bone/output", "src/engine"]
+}