brownian-code 2026.2.10

package/src/utils/input-key-handlers.ts

@@ -0,0 +1,64 @@
+import {
+  findPrevWordStart,
+  findNextWordEnd,
+  getLineAndColumn,
+  getCursorPosition,
+  getLineStart,
+  getLineEnd,
+  getLineCount,
+} from './text-navigation.js';
+
+/**
+ * Context needed for cursor position calculations
+ */
+export interface CursorContext {
+  text: string;
+  cursorPosition: number;
+}
+
+/**
+ * Pure functions for computing new cursor positions.
+ * Each function takes the current context and returns the new cursor position.
+ * For vertical movement (moveUp/moveDown), returns null if at boundary to signal
+ * that the caller should handle it (e.g., history navigation).
+ */
+export const cursorHandlers = {
+  /** Move cursor one character left */
+  moveLeft: (ctx: CursorContext): number =>
+    Math.max(0, ctx.cursorPosition - 1),
+
+  /** Move cursor one character right */
+  moveRight: (ctx: CursorContext): number =>
+    Math.min(ctx.text.length, ctx.cursorPosition + 1),
+
+  /** Move cursor to start of current line */
+  moveToLineStart: (ctx: CursorContext): number =>
+    getLineStart(ctx.text, ctx.cursorPosition),
+
+  /** Move cursor to end of current line */
+  moveToLineEnd: (ctx: CursorContext): number =>
+    getLineEnd(ctx.text, ctx.cursorPosition),
+
+  /** Move cursor up one line, maintaining column position. Returns null if on first line. */
+  moveUp: (ctx: CursorContext): number | null => {
+    const { line, column } = getLineAndColumn(ctx.text, ctx.cursorPosition);
+    if (line === 0) return null; // At first line, signal to caller
+    return getCursorPosition(ctx.text, line - 1, column);
+  },
+
+  /** Move cursor down one line, maintaining column position. Returns null if on last line. */
+  moveDown: (ctx: CursorContext): number | null => {
+    const { line, column } = getLineAndColumn(ctx.text, ctx.cursorPosition);
+    const lineCount = getLineCount(ctx.text);
+    if (line >= lineCount - 1) return null; // At last line, signal to caller
+    return getCursorPosition(ctx.text, line + 1, column);
+  },
+
+  /** Move cursor to start of previous word */
+  moveWordBackward: (ctx: CursorContext): number =>
+    findPrevWordStart(ctx.text, ctx.cursorPosition),
+
+  /** Move cursor to end of next word */
+  moveWordForward: (ctx: CursorContext): number =>
+    findNextWordEnd(ctx.text, ctx.cursorPosition),
+};

package/src/utils/logger.ts

@@ -0,0 +1,67 @@
+type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+
+interface LogEntry {
+  id: string;
+  level: LogLevel;
+  message: string;
+  timestamp: Date;
+  data?: unknown;
+}
+
+type LogSubscriber = (logs: LogEntry[]) => void;
+
+class DebugLogger {
+  private logs: LogEntry[] = [];
+  private subscribers: Set<LogSubscriber> = new Set();
+  private maxLogs = 50;
+
+  private emit() {
+    this.subscribers.forEach(fn => fn([...this.logs]));
+  }
+
+  private add(level: LogLevel, message: string, data?: unknown) {
+    const entry: LogEntry = {
+      id: `${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
+      level,
+      message,
+      timestamp: new Date(),
+      data,
+    };
+    this.logs.push(entry);
+    if (this.logs.length > this.maxLogs) {
+      this.logs = this.logs.slice(-this.maxLogs);
+    }
+    this.emit();
+  }
+
+  debug(message: string, data?: unknown) {
+    this.add('debug', message, data);
+  }
+
+  info(message: string, data?: unknown) {
+    this.add('info', message, data);
+  }
+
+  warn(message: string, data?: unknown) {
+    this.add('warn', message, data);
+  }
+
+  error(message: string, data?: unknown) {
+    this.add('error', message, data);
+  }
+
+  subscribe(fn: LogSubscriber): () => void {
+    this.subscribers.add(fn);
+    fn([...this.logs]); // Send current logs immediately
+    return () => this.subscribers.delete(fn);
+  }
+
+  clear() {
+    this.logs = [];
+    this.emit();
+  }
+}
+
+// Singleton instance
+export const logger = new DebugLogger();
+export type { LogEntry, LogLevel };

package/src/utils/long-term-chat-history.ts

@@ -0,0 +1,138 @@
+import { readFile, writeFile, mkdir } from 'fs/promises';
+import { existsSync } from 'fs';
+import { join, dirname } from 'path';
+
+/**
+ * Represents a conversation entry (user message + agent response pair)
+ * Uses stack ordering: most recent at index 0
+ */
+export interface ConversationEntry {
+  id: string;
+  timestamp: string;
+  userMessage: string;
+  agentResponse: string | null;
+}
+
+interface MessagesFile {
+  messages: ConversationEntry[];
+}
+
+const BROWNIAN_DIR = '.brownian';
+const MESSAGES_DIR = 'messages';
+const MESSAGES_FILE = 'chat_history.json';
+
+/**
+ * Manages persistent storage of conversation history for input history navigation.
+ * Uses stack ordering (most recent first) for O(1) access to latest entries.
+ * Stores messages in .brownian/messages/chat_history.json
+ */
+export class LongTermChatHistory {
+  private filePath: string;
+  private messages: ConversationEntry[] = [];
+  private loaded = false;
+
+  constructor(baseDir: string = process.cwd()) {
+    this.filePath = join(baseDir, BROWNIAN_DIR, MESSAGES_DIR, MESSAGES_FILE);
+  }
+
+  /**
+   * Loads messages from the JSON file.
+   * Creates the file and directories if they don't exist.
+   */
+  async load(): Promise<void> {
+    if (this.loaded) return;
+
+    try {
+      if (existsSync(this.filePath)) {
+        const content = await readFile(this.filePath, 'utf-8');
+        const data: MessagesFile = JSON.parse(content);
+        this.messages = data.messages || [];
+      } else {
+        // File doesn't exist, initialize with empty messages
+        this.messages = [];
+        await this.save();
+      }
+    } catch {
+      // If there's any error reading/parsing, start fresh
+      this.messages = [];
+    }
+
+    this.loaded = true;
+  }
+
+  /**
+   * Saves the current messages to the JSON file.
+   * Creates directories if they don't exist.
+   */
+  private async save(): Promise<void> {
+    const dir = dirname(this.filePath);
+    
+    if (!existsSync(dir)) {
+      await mkdir(dir, { recursive: true });
+    }
+
+    const data: MessagesFile = { messages: this.messages };
+    await writeFile(this.filePath, JSON.stringify(data, null, 2), 'utf-8');
+  }
+
+  /**
+   * Adds a new user message to the history (prepends to stack).
+   * Agent response is null until updateAgentResponse is called.
+   */
+  async addUserMessage(message: string): Promise<void> {
+    if (!this.loaded) {
+      await this.load();
+    }
+
+    const entry: ConversationEntry = {
+      id: Date.now().toString(),
+      timestamp: new Date().toISOString(),
+      userMessage: message,
+      agentResponse: null,
+    };
+
+    // Prepend to stack (most recent first)
+    this.messages.unshift(entry);
+    await this.save();
+  }
+
+  /**
+   * Updates the agent response for the most recent conversation entry.
+   * O(1) lookup since most recent is at index 0.
+   */
+  async updateAgentResponse(response: string): Promise<void> {
+    if (!this.loaded) {
+      await this.load();
+    }
+
+    if (this.messages.length > 0) {
+      this.messages[0].agentResponse = response;
+      await this.save();
+    }
+  }
+
+  /**
+   * Returns all conversation entries in stack order (newest first).
+   */
+  getMessages(): ConversationEntry[] {
+    return [...this.messages];
+  }
+
+  /**
+   * Returns user message strings in stack order (newest first).
+   * Deduplicates consecutive duplicates only (like shell HISTCONTROL=ignoredups).
+   * Used for input history navigation.
+   */
+  getMessageStrings(): string[] {
+    const result: string[] = [];
+
+    for (const m of this.messages) {
+      const lastMessage = result[result.length - 1];
+      if (lastMessage !== m.userMessage) {
+        result.push(m.userMessage);
+      }
+    }
+
+    return result;
+  }
+}

package/src/utils/markdown-table.ts

@@ -0,0 +1,227 @@
+/**
+ * Markdown table parsing and box-drawing rendering utilities.
+ * 
+ * Converts markdown tables to properly-aligned Unicode box-drawing tables.
+ * Also handles bold text formatting.
+ */
+
+import chalk from 'chalk';
+
+// Box-drawing characters
+const BOX = {
+  topLeft: '┌',
+  topRight: '┐',
+  bottomLeft: '└',
+  bottomRight: '┘',
+  horizontal: '─',
+  vertical: '│',
+  topT: '┬',
+  bottomT: '┴',
+  leftT: '├',
+  rightT: '┤',
+  cross: '┼',
+};
+
+/**
+ * Check if a string looks like a number (for right-alignment).
+ */
+function isNumeric(value: string): boolean {
+  const trimmed = value.trim();
+  // Match numbers with optional $, %, B/M/K suffixes
+  return /^[$]?[-+]?[\d,]+\.?\d*[%BMK]?$/.test(trimmed);
+}
+
+/**
+ * Parse a markdown table into headers and rows.
+ */
+export function parseMarkdownTable(tableText: string): { headers: string[]; rows: string[][] } | null {
+  const lines = tableText.trim().split('\n').map(line => line.trim());
+  
+  if (lines.length < 2) return null;
+  
+  // Parse header line
+  const headerLine = lines[0];
+  if (!headerLine.includes('|')) return null;
+  
+  const headers = headerLine
+    .split('|')
+    .map(cell => cell.trim())
+    .filter((_, i, arr) => i > 0 && i < arr.length - 1 || arr.length === 1);
+  
+  // Handle edge case where there's no leading/trailing pipe
+  if (headers.length === 0) {
+    const rawHeaders = headerLine.split('|').map(cell => cell.trim());
+    if (rawHeaders.length > 0) {
+      headers.push(...rawHeaders);
+    }
+  }
+  
+  if (headers.length === 0) return null;
+  
+  // Check for separator line (---|---|---)
+  const separatorLine = lines[1];
+  if (!separatorLine || !/^[\s|:-]+$/.test(separatorLine)) return null;
+  
+  // Parse data rows
+  const rows: string[][] = [];
+  for (let i = 2; i < lines.length; i++) {
+    const line = lines[i];
+    if (!line.includes('|')) continue;
+    
+    const cells = line
+      .split('|')
+      .map(cell => cell.trim());
+    
+    // Remove empty first/last cells from pipes at start/end
+    if (cells[0] === '') cells.shift();
+    if (cells[cells.length - 1] === '') cells.pop();
+    
+    if (cells.length > 0) {
+      rows.push(cells);
+    }
+  }
+  
+  return { headers, rows };
+}
+
+/**
+ * Render a parsed table as a Unicode box-drawing table.
+ */
+export function renderBoxTable(headers: string[], rows: string[][]): string {
+  // Calculate column widths
+  const colWidths: number[] = headers.map(h => h.length);
+  
+  for (const row of rows) {
+    for (let i = 0; i < row.length; i++) {
+      if (i < colWidths.length) {
+        colWidths[i] = Math.max(colWidths[i], row[i].length);
+      }
+    }
+  }
+  
+  // Determine alignment for each column (right for numeric, left for text)
+  const alignRight: boolean[] = headers.map((_, colIndex) => {
+    // Check if most values in this column are numeric
+    let numericCount = 0;
+    for (const row of rows) {
+      if (row[colIndex] && isNumeric(row[colIndex])) {
+        numericCount++;
+      }
+    }
+    return numericCount > rows.length / 2;
+  });
+  
+  // Helper to pad a cell
+  const padCell = (value: string, width: number, rightAlign: boolean): string => {
+    if (rightAlign) {
+      return value.padStart(width);
+    }
+    return value.padEnd(width);
+  };
+  
+  // Build the table
+  const lines: string[] = [];
+  
+  // Top border
+  const topBorder = BOX.topLeft + 
+    colWidths.map(w => BOX.horizontal.repeat(w + 2)).join(BOX.topT) + 
+    BOX.topRight;
+  lines.push(topBorder);
+  
+  // Header row
+  const headerRow = BOX.vertical + 
+    headers.map((h, i) => ` ${padCell(h, colWidths[i], false)} `).join(BOX.vertical) + 
+    BOX.vertical;
+  lines.push(headerRow);
+  
+  // Header separator
+  const headerSep = BOX.leftT + 
+    colWidths.map(w => BOX.horizontal.repeat(w + 2)).join(BOX.cross) + 
+    BOX.rightT;
+  lines.push(headerSep);
+  
+  // Data rows
+  for (const row of rows) {
+    const dataRow = BOX.vertical + 
+      colWidths.map((w, i) => {
+        const value = row[i] || '';
+        return ` ${padCell(value, w, alignRight[i])} `;
+      }).join(BOX.vertical) + 
+      BOX.vertical;
+    lines.push(dataRow);
+  }
+  
+  // Bottom border
+  const bottomBorder = BOX.bottomLeft + 
+    colWidths.map(w => BOX.horizontal.repeat(w + 2)).join(BOX.bottomT) + 
+    BOX.bottomRight;
+  lines.push(bottomBorder);
+  
+  return lines.join('\n');
+}
+
+/**
+ * Find and transform all markdown tables in content to box-drawing tables.
+ */
+export function transformMarkdownTables(content: string): string {
+  // Normalize line endings: convert \r\n to \n, then trim trailing whitespace from each line
+  const normalized = content
+    .replace(/\r\n/g, '\n')
+    .split('\n')
+    .map(line => line.trimEnd())
+    .join('\n');
+  
+  // Regex to match markdown tables:
+  // - Starts with a line containing pipes
+  // - Followed by a separator line (---|---|---)
+  // - Followed by zero or more data rows with pipes
+  // IMPORTANT: Use [ \t] instead of \s in separator to avoid matching newlines
+  const tableRegex = /^(\|[^\n]+\|\n\|[-:| \t]+\|(?:\n\|[^\n]+\|)*)/gm;
+  
+  // Also match tables without leading/trailing pipes on each line
+  const tableRegex2 = /^([^\n|]*\|[^\n]+\n[-:| \t]+(?:\n[^\n|]*\|[^\n]+)*)/gm;
+  
+  let result = normalized;
+  
+  // Process tables with pipes at start/end
+  result = result.replace(tableRegex, (match) => {
+    const parsed = parseMarkdownTable(match);
+    if (parsed && parsed.headers.length > 0 && parsed.rows.length > 0) {
+      return renderBoxTable(parsed.headers, parsed.rows);
+    }
+    return match;
+  });
+  
+  // Process tables that might not have leading pipes
+  result = result.replace(tableRegex2, (match) => {
+    // Skip if already transformed (contains box-drawing chars)
+    if (match.includes(BOX.topLeft)) return match;
+    
+    const parsed = parseMarkdownTable(match);
+    if (parsed && parsed.headers.length > 0 && parsed.rows.length > 0) {
+      return renderBoxTable(parsed.headers, parsed.rows);
+    }
+    return match;
+  });
+  
+  return result;
+}
+
+/**
+ * Transform markdown bold (**text**) to ANSI bold.
+ */
+export function transformBold(content: string): string {
+  return content.replace(/\*\*([^*]+)\*\*/g, (_, text) => chalk.bold(text));
+}
+
+/**
+ * Apply all pre-render formatting to response content.
+ * - Converts markdown tables to unicode box-drawing tables
+ * - Converts **bold** to ANSI bold
+ */
+export function formatResponse(content: string): string {
+  let result = content;
+  result = transformMarkdownTables(result);
+  result = transformBold(result);
+  return result;
+}

package/src/utils/ollama.ts

@@ -0,0 +1,37 @@
+/**
+ * Ollama API utilities
+ */
+
+interface OllamaModel {
+  name: string;
+  modified_at: string;
+  size: number;
+}
+
+interface OllamaTagsResponse {
+  models: OllamaModel[];
+}
+
+/**
+ * Fetches locally downloaded models from the Ollama API
+ */
+export async function getOllamaModels(): Promise<string[]> {
+  const baseUrl = process.env.OLLAMA_BASE_URL || 'http://localhost:11434';
+  
+  try {
+    const response = await fetch(`${baseUrl}/api/tags`);
+
+    if (!response.ok) {
+      return [];
+    }
+
+    const data = (await response.json()) as OllamaTagsResponse;
+    return (data?.models ?? [])
+      .map((m) => m?.name)
+      .filter((n): n is string => typeof n === 'string');
+  } catch {
+    // Ollama not running or unreachable
+    return [];
+  }
+}
+

package/src/utils/progress-channel.ts

@@ -0,0 +1,84 @@
+/**
+ * Lightweight async-iterable queue for streaming progress messages
+ * from subagent tools back to the agent event loop in real-time.
+ *
+ * Tools call `emit()` to push messages; the agent drains the channel
+ * via `for await...of` and yields ToolProgressEvents to the UI.
+ */
+export interface ProgressChannel {
+  /** Push a progress message into the channel */
+  emit: (message: string) => void;
+  /** Signal that no more messages will be emitted */
+  close: () => void;
+  /** Async iterable interface for draining messages */
+  [Symbol.asyncIterator](): AsyncIterator<string>;
+}
+
+/**
+ * Create a progress channel that bridges synchronous `emit()` calls
+ * from inside a tool to the async generator that the agent drains.
+ *
+ * Uses a simple buffer + pending-resolver pattern:
+ * - If the consumer is waiting (no buffered items), `emit()` resolves
+ *   the pending promise immediately.
+ * - If the consumer is busy, messages buffer until the next `next()` call.
+ * - `close()` marks the channel as done; the iterator terminates after
+ *   draining any remaining buffered items.
+ */
+export function createProgressChannel(): ProgressChannel {
+  const buffer: string[] = [];
+  let closed = false;
+  let pendingResolve: ((value: IteratorResult<string>) => void) | null = null;
+
+  const emit = (message: string) => {
+    if (closed) return;
+
+    if (pendingResolve) {
+      // Consumer is waiting -- deliver immediately
+      const resolve = pendingResolve;
+      pendingResolve = null;
+      resolve({ value: message, done: false });
+    } else {
+      // Consumer is busy -- buffer for later
+      buffer.push(message);
+    }
+  };
+
+  const close = () => {
+    closed = true;
+
+    // If the consumer is waiting and nothing is buffered, signal done
+    if (pendingResolve && buffer.length === 0) {
+      const resolve = pendingResolve;
+      pendingResolve = null;
+      resolve({ value: undefined as unknown as string, done: true });
+    }
+  };
+
+  const asyncIterator: AsyncIterator<string> = {
+    next(): Promise<IteratorResult<string>> {
+      // Drain buffered items first
+      if (buffer.length > 0) {
+        return Promise.resolve({ value: buffer.shift()!, done: false });
+      }
+
+      // Nothing buffered and channel is closed -- we're done
+      if (closed) {
+        return Promise.resolve({ value: undefined as unknown as string, done: true });
+      }
+
+      // Nothing buffered, channel still open -- wait for next emit or close
+      return new Promise<IteratorResult<string>>((resolve) => {
+        pendingResolve = resolve;
+      });
+    },
+  };
+
+  return {
+    emit,
+    close,
+    [Symbol.asyncIterator]() {
+      return asyncIterator;
+    },
+  };
+}