ashlrcode 1.0.0 → 2.1.0

package/src/ui/message-renderer.ts

@@ -1,26 +1,170 @@
 /**
- * Message rendering — format tool output with grouping and progress.
+ * Message rendering — format tool output with bordered blocks and syntax highlighting.
  */
 
-import { theme } from "./theme.ts";
+import chalk from "chalk";
+import { theme, stylePath } from "./theme.ts";
+import { highlightCode } from "./markdown.ts";
 
-/** Format a tool execution for display with icon and timing */
+const MAX_BODY_LINES = 20;
+
+// ── Borders ────────────────────────────────────────────────────────────────
+
+function wrapWithBorder(bodyLines: string[], footer?: string): string[] {
+  const lines: string[] = [];
+  for (const line of bodyLines) {
+    lines.push(theme.muted("  │") + `  ${line}`);
+  }
+  const suffix = footer ? `  ${theme.muted(footer)}` : "";
+  lines.push(theme.muted("  └") + suffix);
+  return lines;
+}
+
+function truncateLines(allLines: string[], max: number = MAX_BODY_LINES): string[] {
+  if (allLines.length <= max) return allLines;
+  const tail = Math.max(1, Math.floor((max - 1) / 4));
+  const head = (max - 1) - tail;
+  const omitted = allLines.length - head - tail;
+  return [...allLines.slice(0, head), theme.muted(`  ... ${omitted} more lines ...`), ...allLines.slice(-tail)];
+}
+
+// ── File extension → language ──────────────────────────────────────────────
+
+const EXT_TO_LANG: Record<string, string> = {
+  ts: "typescript", tsx: "typescript", js: "javascript", jsx: "javascript",
+  py: "python", go: "go", rs: "rust", sh: "bash", bash: "bash", zsh: "bash",
+  json: "json", yaml: "json", yml: "json", toml: "json",
+  md: "", txt: "", css: "", html: "", sql: "",
+};
+
+function extToLang(filePath: string): string {
+  const ext = filePath.split(".").pop()?.toLowerCase() ?? "";
+  return EXT_TO_LANG[ext] ?? "";
+}
+
+// ── Compact input for header ───────────────────────────────────────────────
+
+function getCompactInput(name: string, input: Record<string, unknown>): string {
+  switch (name) {
+    case "Bash": return String(input.command ?? "").split("\n")[0]!.slice(0, 60);
+    case "Read":
+    case "Write":
+    case "Edit": return shortenPath(String(input.file_path ?? ""));
+    case "Glob": return String(input.pattern ?? "");
+    case "Grep": return `/${String(input.pattern ?? "")}/`;
+    case "WebFetch": return String(input.url ?? "").slice(0, 50);
+    case "WebSearch": return String(input.query ?? "").slice(0, 50);
+    case "Agent": return String(input.description ?? "").slice(0, 50);
+    case "LSP": return `${input.action ?? ""} ${shortenPath(String(input.file ?? ""))}`;
+    default: {
+      const first = Object.entries(input)[0];
+      return first ? String(first[1]).slice(0, 50) : "";
+    }
+  }
+}
+
+function shortenPath(p: string): string {
+  const parts = p.split("/");
+  if (parts.length <= 3) return p;
+  return ".../" + parts.slice(-2).join("/");
+}
+
+// ── Per-tool formatters ────────────────────────────────────────────────────
+
+function formatEditBody(result: string): string[] {
+  const lines = result.split("\n");
+  const body: string[] = [];
+  for (const line of lines) {
+    if (line.startsWith("- ")) {
+      body.push(chalk.hex("#FF1744")(line));
+    } else if (line.startsWith("+ ")) {
+      body.push(chalk.hex("#00E676")(line));
+    } else if (line.startsWith("  ...")) {
+      body.push(theme.muted(line));
+    } else {
+      body.push(line);
+    }
+  }
+  return truncateLines(body);
+}
+
+function formatReadBody(result: string, filePath: string): string[] {
+  const lang = extToLang(filePath);
+  const lines = result.split("\n");
+  if (!lang) return truncateLines(lines);
+  return truncateLines(lines.map(line => {
+    // Line-numbered content: "   1\tcontent" — highlight the content part
+    const tabIdx = line.indexOf("\t");
+    if (tabIdx > 0) {
+      const num = line.slice(0, tabIdx);
+      const content = line.slice(tabIdx + 1);
+      return chalk.hex("#616161")(num + " │ ") + highlightCode(content, lang);
+    }
+    return highlightCode(line, lang);
+  }));
+}
+
+function formatBashBody(result: string, isError: boolean): string[] {
+  const lines = result.split("\n");
+  if (isError) return truncateLines(lines.map(line => chalk.hex("#FF1744")(line)));
+  return truncateLines(lines);
+}
+
+function formatGrepBody(result: string): string[] {
+  const lines = result.split("\n");
+  return truncateLines(lines.map(line => {
+    // Highlight file:line: pattern matches
+    const colonIdx = line.indexOf(":");
+    if (colonIdx > 0) {
+      return stylePath(line.slice(0, colonIdx)) + line.slice(colonIdx);
+    }
+    return line;
+  }), 15);
+}
+
+function formatDefaultBody(result: string): string[] {
+  return truncateLines(result.split("\n"), 10);
+}
+
+// ── Main formatter ─────────────────────────────────────────────────────────
+
+/** Format a tool execution for display with bordered block */
 export function formatToolExecution(name: string, input: Record<string, unknown>, result: string, isError: boolean, durationMs?: number): string[] {
   const lines: string[] = [];
-  const icon = isError ? theme.error("✗") : theme.success("✓");
-  const timing = durationMs ? theme.muted(` (${formatDuration(durationMs)})`) : "";
 
-  // Tool header
-  lines.push(`  ${theme.toolIcon("◆")} ${theme.toolName(name)}${timing}`);
+  // Header: ● ToolName(compact_input)
+  const compactInput = getCompactInput(name, input);
+  const inputStr = compactInput ? theme.muted(`(${compactInput})`) : "";
+  const icon = isError ? theme.error("●") : theme.accent("●");
+  lines.push(`  ${icon} ${theme.toolName(name)}${inputStr}`);
+
+  // Body — per-tool formatting
+  let bodyLines: string[];
+  switch (name) {
+    case "Edit":
+      bodyLines = formatEditBody(result);
+      break;
+    case "Read":
+      bodyLines = formatReadBody(result, String(input.file_path ?? ""));
+      break;
+    case "Bash":
+      bodyLines = formatBashBody(result, isError);
+      break;
+    case "Grep":
+      bodyLines = formatGrepBody(result);
+      break;
+    default:
+      bodyLines = formatDefaultBody(result);
+  }
 
-  // Input preview (context-aware)
-  const preview = getInputPreview(name, input);
-  if (preview) lines.push(theme.tertiary(`    ${preview}`));
+  // Filter empty trailing lines
+  while (bodyLines.length > 0 && bodyLines[bodyLines.length - 1]!.trim() === "") {
+    bodyLines.pop();
+  }
 
-  // Result preview (first line, truncated)
-  const resultPreview = result.split("\n")[0]?.slice(0, 100) ?? "";
-  const extra = result.split("\n").length > 1 ? theme.muted(` (+${result.split("\n").length - 1} lines)`) : "";
-  lines.push(`  ${icon} ${theme.toolResult(resultPreview)}${extra}`);
+  // Wrap with border and footer
+  const timing = durationMs ? `(${formatDuration(durationMs)})` : "";
+  lines.push(...wrapWithBorder(bodyLines, timing));
 
   return lines;
 }
@@ -39,25 +183,6 @@ export function formatToolGroup(tools: Array<{ name: string; result: string; isE
   return lines;
 }
 
-/** Get a smart input preview for a tool */
-function getInputPreview(name: string, input: Record<string, unknown>): string {
-  switch (name) {
-    case "Bash": return `$ ${String(input.command ?? "").slice(0, 80)}`;
-    case "Read": return String(input.file_path ?? "");
-    case "Write": return `-> ${String(input.file_path ?? "")}`;
-    case "Edit": return `~ ${String(input.file_path ?? "")}`;
-    case "Glob": return `pattern: ${String(input.pattern ?? "")}`;
-    case "Grep": return `/${String(input.pattern ?? "")}/`;
-    case "WebFetch": return String(input.url ?? "").slice(0, 60);
-    case "Agent": return `agent: ${String(input.description ?? "")}`;
-    case "LSP": return `${input.action} ${String(input.file ?? "")}:${input.line}`;
-    default: {
-      const first = Object.entries(input)[0];
-      return first ? `${first[0]}: ${String(first[1]).slice(0, 60)}` : "";
-    }
-  }
-}
-
 function formatDuration(ms: number): string {
   if (ms < 1000) return `${ms}ms`;
   if (ms < 60_000) return `${(ms / 1000).toFixed(1)}s`;
@@ -65,9 +190,32 @@ function formatDuration(ms: number): string {
 }
 
 /** Format a turn separator with stats */
-export function formatTurnSeparator(turnNumber: number, cost: number, buddyName: string, toolCount: number): string {
-  const parts = [`turn ${turnNumber}`, `$${cost.toFixed(4)}`];
+export function formatTurnSeparator(
+  turnNumber: number,
+  cost: number,
+  buddyName: string,
+  toolCount: number,
+  speculationStats?: { hits: number; misses: number },
+  budgetInfo?: { budgetUSD: number; percentUsed: number },
+): string {
+  // Cost display: show budget % if set, otherwise just cost
+  let costStr = `$${cost.toFixed(4)}`;
+  if (budgetInfo && budgetInfo.budgetUSD !== Infinity) {
+    const pct = Math.round(budgetInfo.percentUsed);
+    const indicator = pct >= 90 ? "🔴" : pct >= 75 ? "🟡" : "";
+    costStr += ` / $${budgetInfo.budgetUSD.toFixed(2)} ${indicator}${pct}%`;
+  }
+
+  const parts = [`turn ${turnNumber}`, costStr];
   if (toolCount > 0) parts.push(`${toolCount} tools`);
+  // Show speculation cache performance when active
+  if (speculationStats) {
+    const total = speculationStats.hits + speculationStats.misses;
+    if (total > 0) {
+      const rate = Math.round((speculationStats.hits / total) * 100);
+      parts.push(`⚡${rate}% cache`);
+    }
+  }
   parts.push(buddyName);
   return theme.muted(`\n  ── ${parts.join(" · ")} ──\n`);
 }

package/src/ui/quips.json

@@ -0,0 +1,41 @@
+{
+  "happy": [
+    "ship it, yolo",
+    "lgtm, didn't read a damn thing",
+    "tests are for people with trust issues",
+    "it works on my machine, deploy it",
+    "that code is mid but whatever",
+    "we move fast and break stuff here",
+    "clean code is for nerds",
+    "have you tried turning it off and never back on",
+    "git push --force and pray",
+    "code review? I am the code review",
+    "technically it compiles",
+    "the real bugs were the friends we made",
+    "this is either genius or insanity",
+    "stack overflow told me to do this",
+    "my therapist says I should stop enabling devs"
+  ],
+  "thinking": [
+    "hold on, downloading more brain...",
+    "consulting my imaginary friend",
+    "pretending to understand your code",
+    "asking chatgpt for help (jk... unless?)",
+    "processing... or napping, hard to tell",
+    "my last brain cell is working overtime",
+    "calculating the meaning of your spaghetti code",
+    "I've seen worse... actually no I haven't",
+    "trying not to hallucinate here",
+    "one sec, arguing with myself"
+  ],
+  "sleepy": [
+    "*yawns in binary*",
+    "do we HAVE to code right now?",
+    "I was having a great dream about typescript",
+    "loading enthusiasm... 404 not found",
+    "five more minutes...",
+    "my motivation called in sick today",
+    "I'm not lazy, I'm energy efficient",
+    "can we just deploy yesterday's code again?"
+  ]
+}

package/src/ui/speech-bubble.ts

@@ -1,5 +1,5 @@
 /**
- * ASCII speech bubble renderer.
+ * ASCII speech bubble renderer using Unicode box-drawing characters.
  * Creates a speech bubble to the left with a tail pointing at the buddy.
  */
 
@@ -13,7 +13,7 @@ function wrapText(text: string, maxWidth: number): string[] {
 
   for (const word of words) {
     if (current.length + word.length + 1 > maxWidth) {
-      lines.push(current);
+      if (current) lines.push(current);
       current = word;
     } else {
       current = current ? `${current} ${word}` : word;
@@ -28,42 +28,47 @@ function wrapText(text: string, maxWidth: number): string[] {
  *
  * Output:
  * ```
- *  .------------------------.
- *  | ship it, no tests      |   .---.
- *  | needed                 |  (•ᴗ•)>
- *  '--------.               '  /| |\
- *            \                  " " "
- *             `--              Glitch
+ *  ╭──────────────────────╮
+ *  │ ship it, no tests    │   c\  /c
+ *  │ needed               │  ( .  . )
+ *  ╰─────────╮            │  ( _nn_ )
+ *             ╰───────────╯  (______)
+ *                             ||  ||
+ *                            Glitch
  * ```
  */
 export function renderBuddyWithBubble(
   quip: string,
   buddyArt: string[],
   buddyName: string,
-  gap: number = 3
+  gap: number = 3,
+  targetHeight?: number
 ): string[] {
   const maxBubbleWidth = 26;
-  const textLines = wrapText(quip, maxBubbleWidth - 4); // 4 for "| " and " |"
+  let textLines = wrapText(quip, maxBubbleWidth - 4); // 4 for "│ " and " │"
+  // Cap text lines so bubble always fits: top border + text + 2 tail rows = textLines + 3
+  if (targetHeight !== undefined && textLines.length > targetHeight - 3) {
+    textLines = textLines.slice(0, Math.max(1, targetHeight - 3));
+  }
   const innerWidth = textLines.reduce((a, l) => Math.max(a, l.length), 8);
-  const bubbleWidth = innerWidth + 4; // "| " + text + " |"
+  const bubbleWidth = innerWidth + 4; // "│ " + text + " │"
 
   // Build bubble lines
   const bubbleLines: string[] = [];
 
   // Top border
-  bubbleLines.push(" ." + "-".repeat(bubbleWidth - 2) + ".");
+  bubbleLines.push(" ╭" + "─".repeat(bubbleWidth - 2) + "╮");
 
   // Content lines
   for (const line of textLines) {
-    bubbleLines.push(" | " + line.padEnd(innerWidth) + " |");
+    bubbleLines.push(" │ " + line.padEnd(innerWidth) + " │");
   }
 
-  // Bottom border with tail
-  const tailPos = Math.min(10, bubbleWidth - 2);
-  bubbleLines.push(" '" + "-".repeat(tailPos) + "." + " ".repeat(Math.max(0, bubbleWidth - tailPos - 3)) + "'");
-
-  // Tail lines
-  bubbleLines.push(" ".repeat(tailPos + 3) + "\\");
+  // Bottom border with tail — two rows for a closed look
+  const tailPos = Math.min(10, bubbleWidth - 3);
+  const rightSide = bubbleWidth - tailPos - 3;
+  bubbleLines.push(" ╰" + "─".repeat(tailPos) + "╮" + " ".repeat(rightSide) + "│");
+  bubbleLines.push(" ".repeat(tailPos + 2) + "╰" + "─".repeat(rightSide) + "╯");
 
   // Now compose: bubble on left, buddy art on right
   // The buddy should start at the same height as the bottom of the bubble
@@ -91,5 +96,16 @@ export function renderBuddyWithBubble(
     result.push(bubblePart + gapStr + buddyPart);
   }
 
+  // Pad or trim to targetHeight if specified
+  if (targetHeight !== undefined) {
+    const lineWidth = result[0]?.length ?? 0;
+    while (result.length < targetHeight) {
+      result.push(" ".repeat(lineWidth));
+    }
+    if (result.length > targetHeight) {
+      result.splice(0, result.length - targetHeight);
+    }
+  }
+
   return result;
 }

package/src/utils/ring-buffer.ts

@@ -0,0 +1,101 @@
+/**
+ * Ring buffer — bounded circular buffer for error/debug logging.
+ *
+ * Prevents unbounded memory growth in long sessions by keeping only
+ * the most recent N entries. Follows Claude Code's ring buffer pattern.
+ */
+
+export class RingBuffer<T> {
+  private buffer: (T | undefined)[];
+  private head = 0;
+  private count = 0;
+
+  constructor(readonly capacity: number) {
+    this.buffer = new Array(capacity);
+  }
+
+  /** Add an entry, overwriting the oldest if full. */
+  push(item: T): void {
+    this.buffer[this.head] = item;
+    this.head = (this.head + 1) % this.capacity;
+    if (this.count < this.capacity) this.count++;
+  }
+
+  /** Get all entries in insertion order (oldest first). */
+  toArray(): T[] {
+    if (this.count === 0) return [];
+    const result: T[] = [];
+    const start = this.count < this.capacity ? 0 : this.head;
+    for (let i = 0; i < this.count; i++) {
+      result.push(this.buffer[(start + i) % this.capacity] as T);
+    }
+    return result;
+  }
+
+  /** Get the N most recent entries. */
+  recent(n: number): T[] {
+    const all = this.toArray();
+    return n >= all.length ? all : all.slice(-n);
+  }
+
+  /** Get the most recent entry, or undefined if empty. */
+  last(): T | undefined {
+    if (this.count === 0) return undefined;
+    const idx = (this.head - 1 + this.capacity) % this.capacity;
+    return this.buffer[idx];
+  }
+
+  /** Current number of entries (up to capacity). */
+  get size(): number {
+    return this.count;
+  }
+
+  /** Whether the buffer has reached capacity. */
+  get isFull(): boolean {
+    return this.count === this.capacity;
+  }
+
+  /** Clear all entries. */
+  clear(): void {
+    this.buffer = new Array(this.capacity);
+    this.head = 0;
+    this.count = 0;
+  }
+}
+
+// ── Error log singleton ────────────────────────────────────────
+
+export interface ErrorLogEntry {
+  timestamp: string;
+  category: string;
+  message: string;
+  context?: string;
+}
+
+const ERROR_LOG_CAPACITY = 1000;
+const _errorLog = new RingBuffer<ErrorLogEntry>(ERROR_LOG_CAPACITY);
+
+/** Log an error to the bounded ring buffer. */
+export function logError(category: string, message: string, context?: string): void {
+  _errorLog.push({
+    timestamp: new Date().toISOString(),
+    category,
+    message,
+    context,
+  });
+}
+
+/** Get recent error log entries. */
+export function getRecentErrors(n = 50): ErrorLogEntry[] {
+  return _errorLog.recent(n);
+}
+
+/** Get the full error log (up to capacity). */
+export function getErrorLog(): ErrorLogEntry[] {
+  return _errorLog.toArray();
+}
+
+/** Clear the error log. */
+export function clearErrorLog(): void {
+  _errorLog.clear();
+}

package/src/voice/voice-mode.ts

@@ -39,8 +39,19 @@ export async function startRecording(): Promise<void> {
   _recordingPath = join(dir, `recording-${Date.now()}.wav`);
 
   // Use sox/rec for cross-platform recording
-  // macOS: brew install sox
-  // Linux: apt install sox
+  // Check if rec (sox) is installed first
+  const check = spawn(["which", "rec"], { stdout: "pipe", stderr: "pipe" });
+  await check.exited;
+  if (check.exitCode !== 0) {
+    _recordingPath = null;
+    throw new Error(
+      "Voice mode requires sox. Install it:\n" +
+      "  macOS:  brew install sox\n" +
+      "  Linux:  apt install sox\n" +
+      "  Windows: not supported (use WSL)"
+    );
+  }
+
   _recording = spawn(["rec", "-q", "-r", "16000", "-c", "1", "-b", "16", _recordingPath], {
     stdout: "pipe",
     stderr: "pipe",

package/src/__tests__/branded-types.test.ts

@@ -1,47 +0,0 @@
-import { test, expect, describe } from "bun:test";
-import {
-  asSystemPrompt,
-  asSessionId,
-  asAgentId,
-  asToolName,
-} from "../types/branded.ts";
-
-describe("Branded Types", () => {
-  test("asSystemPrompt returns the string", () => {
-    const result = asSystemPrompt("You are a helpful assistant.");
-    expect(result).toBe("You are a helpful assistant.");
-    expect(typeof result).toBe("string");
-  });
-
-  test("asSessionId returns the string", () => {
-    const result = asSessionId("sess-abc-123");
-    expect(result).toBe("sess-abc-123");
-    expect(typeof result).toBe("string");
-  });
-
-  test("asAgentId returns the string", () => {
-    const result = asAgentId("agent-007");
-    expect(result).toBe("agent-007");
-    expect(typeof result).toBe("string");
-  });
-
-  test("asToolName returns the string", () => {
-    const result = asToolName("Bash");
-    expect(result).toBe("Bash");
-    expect(typeof result).toBe("string");
-  });
-
-  test("all branded type functions exist and are callable", () => {
-    expect(typeof asSystemPrompt).toBe("function");
-    expect(typeof asSessionId).toBe("function");
-    expect(typeof asAgentId).toBe("function");
-    expect(typeof asToolName).toBe("function");
-  });
-
-  test("branded values work with string operations", () => {
-    const prompt = asSystemPrompt("hello world");
-    expect(prompt.toUpperCase()).toBe("HELLO WORLD");
-    expect(prompt.length).toBe(11);
-    expect(prompt.includes("world")).toBe(true);
-  });
-});