bonecode 1.2.1 → 1.2.3

package/src/stats.ts

@@ -1,10 +1,49 @@
 /**
  * Token usage and cost statistics
  * Ported from opencode's cli/cmd/stats.ts — adapted for BoneCode's Postgres schema.
+ *
+ * Works on both Postgres (full schema with token columns on sessions) and
+ * SQLite fallback (sessions has only id/title/etc; token data lives on messages).
  */
 
 import { Pool } from "pg"
 
+interface CostColumns {
+  cost: boolean
+  tokensInput: boolean
+  tokensOutput: boolean
+  tokensReasoning: boolean
+  tokensCacheRead: boolean
+  tokensCacheWrite: boolean
+}
+
+let _columnsCache: CostColumns | null = null
+
+async function detectSessionCostColumns(pool: Pool): Promise<CostColumns> {
+  if (_columnsCache) return _columnsCache
+
+  const probe = async (col: string): Promise<boolean> => {
+    try {
+      // SELECT col FROM sessions LIMIT 0 — fails if column doesn't exist, succeeds otherwise.
+      // Works identically on Postgres and SQLite.
+      await pool.query(`SELECT ${col} FROM sessions LIMIT 0`)
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  _columnsCache = {
+    cost: await probe("cost_usd"),
+    tokensInput: await probe("tokens_input"),
+    tokensOutput: await probe("tokens_output"),
+    tokensReasoning: await probe("tokens_reasoning"),
+    tokensCacheRead: await probe("tokens_cache_read"),
+    tokensCacheWrite: await probe("tokens_cache_write"),
+  }
+  return _columnsCache
+}
+
 export interface SessionStats {
   totalSessions: number
   totalMessages: number
@@ -50,10 +89,23 @@ export async function aggregateStats(
     return opts.days
   })()
 
+  // Detect available columns by introspection — works on both Postgres and SQLite
+  const hasCol = await detectSessionCostColumns(pool)
+  const sessionSelect = [
+    "id",
+    "project_id",
+    "created_at",
+    "updated_at",
+    hasCol.cost ? "cost_usd" : "0 AS cost_usd",
+    hasCol.tokensInput ? "tokens_input" : "0 AS tokens_input",
+    hasCol.tokensOutput ? "tokens_output" : "0 AS tokens_output",
+    hasCol.tokensReasoning ? "tokens_reasoning" : "0 AS tokens_reasoning",
+    hasCol.tokensCacheRead ? "tokens_cache_read" : "0 AS tokens_cache_read",
+    hasCol.tokensCacheWrite ? "tokens_cache_write" : "0 AS tokens_cache_write",
+  ].join(", ")
+
   // Load sessions
-  let sessionQuery = `SELECT id, project_id, cost_usd, tokens_input, tokens_output, tokens_reasoning,
-    tokens_cache_read, tokens_cache_write, created_at, updated_at
-    FROM sessions WHERE state != 'deleted'`
+  let sessionQuery = `SELECT ${sessionSelect} FROM sessions WHERE state != 'deleted'`
   const params: unknown[] = []
   let idx = 1
 

package/src/tui.ts

@@ -393,19 +393,78 @@ interface ToolTrack {
  *   "text"  — pass deltas through verbatim (with partial-fence detection)
  *   "fence" — buffer everything; emit marker on close fence
  */
+/**
+ * Apply lightweight inline markdown styling to a streamed chunk.
+ *
+ * - `# `, `## `, `### ` at line-start become bold colored headers
+ * - `**text**` becomes bold
+ * - `` `code` `` becomes inverted gray
+ * - `- ` and `* ` at line-start become a bullet
+ *
+ * Operates per-line on the chunk. Cross-chunk markdown (a `**` opening in one
+ * delta and closing in another) is not handled — we just leave those raw.
+ * That's acceptable because it's rare and the model's output is still readable.
+ */
+function applyInlineMarkdown(text: string): string {
+  if (!text) return text;
+  // Split on newlines so we can match line-anchored patterns (headers, bullets)
+  const lines = text.split("\n");
+  const styled = lines.map((line) => {
+    // Headers
+    let m = line.match(/^(#{1,6})\s+(.*)$/);
+    if (m) {
+      const level = m[1].length;
+      const content = m[2];
+      if (level === 1) return `${CYAN}${BOLD}${content}${R}`;
+      if (level === 2) return `${CYAN}${BOLD}${content}${R}`;
+      if (level === 3) return `${WHITE}${BOLD}${content}${R}`;
+      return `${WHITE}${content}${R}`;
+    }
+    // Bullets at line start
+    m = line.match(/^(\s*)[-*]\s+(.*)$/);
+    if (m) {
+      line = `${m[1]}${GRAY}•${R} ${m[2]}`;
+    }
+    // Numbered lists
+    m = line.match(/^(\s*)(\d+\.)\s+(.*)$/);
+    if (m) {
+      line = `${m[1]}${GRAY}${m[2]}${R} ${m[3]}`;
+    }
+    // Bold (**text**)
+    line = line.replace(/\*\*([^*]+)\*\*/g, `${BOLD}$1${R}`);
+    // Inline code (`code`)
+    line = line.replace(/`([^`]+)`/g, `${GRAY}$1${R}`);
+    return line;
+  });
+  return styled.join("\n");
+}
+
+/**
+ * Stateful code-fence collapser.
+ *
+ * Replaces ```lang ... ``` blocks with a one-line marker
+ * "  ┃ code: lang, N lines" so streaming code blocks don't flood the TUI.
+ *
+ * State:
+ *   "text"  — pass through verbatim (with partial-fence buffering)
+ *   "fence" — silently buffer body; emit final marker on close
+ *
+ * Newline handling:
+ *   We strip up to one trailing newline before the opening fence and one
+ *   leading newline after the closing fence so the marker sits on its own
+ *   line without doubling blank lines around it.
+ */
 function makeCodeFenceCollapser() {
   let mode: "text" | "fence" = "text";
   let lang = "";
-  let buffered = ""; // bytes accumulated inside a fence
-  let pending = "";  // partial-fence buffer (when we see backticks but don't know yet)
-
-  const lines = (s: string) => s.split("\n").length;
+  let buffered = "";
+  let pending = "";
 
-  function flushPending(): string {
-    const out = pending;
-    pending = "";
-    return out;
-  }
+  const countLines = (s: string) => {
+    if (!s) return 0;
+    const trimmed = s.replace(/^\n+/, "").replace(/\n+$/, "");
+    return trimmed ? trimmed.split("\n").length : 0;
+  };
 
   return {
     feed(chunk: string): string {
@@ -416,23 +475,26 @@ function makeCodeFenceCollapser() {
 
       while (i < buf.length) {
         if (mode === "text") {
-          // Look for ``` to enter fence mode
           const fenceIdx = buf.indexOf("```", i);
           if (fenceIdx === -1) {
-            // No fence in remaining text — emit it all, but hold the last 2 chars
-            // in case they're part of an upcoming fence.
+            // No fence in remaining text. Hold last 2 chars in case they're
+            // the start of an upcoming fence.
             const safeEnd = Math.max(i, buf.length - 2);
             result += buf.slice(i, safeEnd);
             pending = buf.slice(safeEnd);
             i = buf.length;
             break;
           }
-          // Emit text up to the fence
-          result += buf.slice(i, fenceIdx);
-          // Read the language (everything until newline)
+          // Emit text up to the fence, but trim a single trailing newline so
+          // the marker sits on its own line without extra blank space.
+          let preFence = buf.slice(i, fenceIdx);
+          if (preFence.endsWith("\n")) preFence = preFence.slice(0, -1);
+          result += preFence;
+
+          // Read the language declaration (everything up to the next newline).
           const nlIdx = buf.indexOf("\n", fenceIdx + 3);
           if (nlIdx === -1) {
-            // Don't have the full opening line yet — buffer
+            // Opening line not complete yet — buffer for next feed.
             pending = buf.slice(fenceIdx);
             i = buf.length;
             break;
@@ -441,31 +503,36 @@ function makeCodeFenceCollapser() {
           i = nlIdx + 1;
           mode = "fence";
           buffered = "";
-          // Print a leading marker (will be amended when we close)
-          result += `${GRAY}┃ code: ${lang}…${R}`;
+          // Don't emit anything yet — the final marker is written when we
+          // see the closing fence so we have the line count.
           continue;
         }
 
         // mode === "fence" — look for closing ```
         const closeIdx = buf.indexOf("```", i);
         if (closeIdx === -1) {
+          // No close fence yet — buffer the body.
           buffered += buf.slice(i);
-          // Hold last 2 chars in case they're part of an upcoming close fence
+          // Hold last 2 chars in case they're part of an upcoming close fence.
           const safeEnd = Math.max(i, buf.length - 2);
           buffered = buffered.slice(0, buffered.length - (buf.length - safeEnd));
           pending = buf.slice(safeEnd);
           i = buf.length;
           break;
         }
-        // Closing fence found
+
+        // Closing fence found.
         buffered += buf.slice(i, closeIdx);
-        const lineCount = lines(buffered.replace(/\n+$/, ""));
-        // Replace the placeholder we already wrote with the final marker.
-        // Carriage return + clear line + reprint marker.
-        result += `\r${ESC}[2K   ${GRAY}┃ code: ${lang}, ${lineCount} line${lineCount === 1 ? "" : "s"}${R}\n`;
+        const lineCount = countLines(buffered);
+        // Emit the marker on its own line with leading and trailing newlines.
+        // The outer indenter will prepend "   " to each line break.
+        result += `\n${GRAY}┃ code: ${lang}, ${lineCount} line${lineCount === 1 ? "" : "s"}${R}`;
         i = closeIdx + 3;
-        // Skip optional newline after closing fence
+        // Skip a single newline immediately after the close fence to avoid
+        // doubling blank lines.
         if (buf[i] === "\n") i++;
+        // Add a trailing newline so the next text starts on a fresh line.
+        result += "\n";
         mode = "text";
         lang = "";
         buffered = "";
@@ -474,12 +541,12 @@ function makeCodeFenceCollapser() {
       return result;
     },
     flush(): string {
-      const tail = flushPending();
+      const tail = pending;
+      pending = "";
       if (mode === "fence") {
-        // Stream ended mid-fence — close it with an approximate count
-        const lineCount = lines(buffered.replace(/\n+$/, ""));
+        const lineCount = countLines(buffered);
         mode = "text";
-        return tail + `\r${ESC}[2K   ${GRAY}┃ code: ${lang}, ${lineCount}+ lines${R}\n`;
+        return tail + `\n${GRAY}┃ code: ${lang}, ${lineCount}+ lines${R}\n`;
       }
       return tail;
     },
@@ -563,8 +630,10 @@ async function streamPrompt(opts: {
             // code blocks appear as "[code: lang]" placeholders instead of
             // dumping raw source.
             const piece = collapseCodeFences(text);
+            // Apply lightweight markdown styling (headers, bold, inline code)
+            const styled = applyInlineMarkdown(piece);
             // Print with leading-newline indenting (so each new line gets the 3-space prefix)
-            const indented = piece.replace(/\n/g, `\n   `);
+            const indented = styled.replace(/\n/g, `\n   `);
             out(indented);
             fullText += text;
             continue;
@@ -727,6 +796,22 @@ export async function runTUI(opts: {
   port: number; token: string; model: string;
   provider: string; worktree: string; sessionId?: string;
 }): Promise<void> {
+  // Force UTF-8 output on Windows so emoji and box-drawing chars render
+  // correctly. Without this, console code page 437/850 corrupts multi-byte
+  // sequences into "??" or mojibake.
+  if (process.platform === "win32") {
+    try {
+      // Set output encoding for stdout/stderr
+      (process.stdout as any).setEncoding?.("utf-8");
+      (process.stderr as any).setEncoding?.("utf-8");
+      // Switch the console to UTF-8 (code page 65001)
+      const { execSync } = require("child_process");
+      execSync("chcp 65001", { stdio: "ignore" });
+    } catch {
+      // chcp not available — that's fine, we tried
+    }
+  }
+
   let { model, provider } = opts;
   const { port, token, worktree } = opts;
   let sessionId = opts.sessionId || null;