brownian-code 2026.2.10

package/src/commands/builtin.test.ts

@@ -0,0 +1,271 @@
+import { describe, test, expect, beforeAll, afterAll } from 'bun:test';
+import React from 'react';
+import { existsSync, rmSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { registerBuiltinCommands } from './builtin.js';
+import { commandRegistry, executeCommand } from './registry.js';
+import type { CommandContext } from './types.js';
+import type { HistoryItem } from '../components/HistoryItemView.js';
+
+// Register commands once
+registerBuiltinCommands();
+
+// ---------------------------------------------------------------------------
+// Test helpers
+// ---------------------------------------------------------------------------
+
+function makeContext(overrides: Partial<CommandContext> = {}): CommandContext {
+  return {
+    provider: 'anthropic',
+    model: 'claude-sonnet-4-5',
+    history: [],
+    inMemoryChatHistoryRef: { current: null } as any,
+    setError: () => {},
+    clearHistory: () => {},
+    startSelection: () => {},
+    toggleDebug: () => {},
+    showDebug: false,
+    cumulativeTokens: 0,
+    cumulativeCost: 0,
+    turnCount: 0,
+    ...overrides,
+  };
+}
+
+function makeHistoryItem(query: string, answer: string): HistoryItem {
+  return {
+    id: Date.now().toString(),
+    query,
+    events: [],
+    answer,
+    status: 'complete',
+    tokenUsage: { inputTokens: 100, outputTokens: 50, totalTokens: 150 },
+    duration: 1500,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Command registration
+// ---------------------------------------------------------------------------
+
+describe('builtin command registration', () => {
+  test('all expected commands are registered', () => {
+    const expectedCommands = ['help', 'clear', 'model', 'debug', 'cost', 'compact', 'history', 'export', 'verbose', 'shortcuts'];
+    for (const name of expectedCommands) {
+      expect(commandRegistry.get(name)).toBeDefined();
+    }
+  });
+
+  test('aliases are registered (new → clear)', () => {
+    const newCmd = commandRegistry.get('new');
+    expect(newCmd).toBeDefined();
+  });
+
+  test('visible commands exclude hidden ones', () => {
+    const visible = commandRegistry.getVisible();
+    const names = visible.map(c => c.name);
+    // 'new' is hidden (alias for clear)
+    // The hidden 'new' in builtin has isHidden: true
+    // But note that 'clear' has aliases: ['new'], so 'new' maps to the 'clear' command object
+    // which is NOT hidden. The separate hidden 'new' command definition is also registered.
+    // The visible list should contain 'clear' but not the standalone hidden 'new'.
+    expect(names).toContain('clear');
+    expect(names).toContain('help');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// /clear command
+// ---------------------------------------------------------------------------
+
+describe('/clear command', () => {
+  test('calls clearHistory and returns confirmation', async () => {
+    let cleared = false;
+    const ctx = makeContext({ clearHistory: () => { cleared = true; } });
+    const result = await executeCommand('clear', [], ctx);
+    expect(cleared).toBe(true);
+    expect(result).toBe('Conversation cleared.');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// /model command
+// ---------------------------------------------------------------------------
+
+describe('/model command', () => {
+  test('calls startSelection', async () => {
+    let started = false;
+    const ctx = makeContext({ startSelection: () => { started = true; } });
+    await executeCommand('model', [], ctx);
+    expect(started).toBe(true);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// /debug command
+// ---------------------------------------------------------------------------
+
+describe('/debug command', () => {
+  test('calls toggleDebug and returns message when debug was off', async () => {
+    let toggled = false;
+    const ctx = makeContext({
+      showDebug: false,
+      toggleDebug: () => { toggled = true; },
+    });
+    const result = await executeCommand('debug', [], ctx);
+    expect(toggled).toBe(true);
+    // showDebug is false → message says "Debug panel visible." (will become visible)
+    expect(result).toBe('Debug panel visible.');
+  });
+
+  test('returns "hidden" message when debug was on', async () => {
+    const ctx = makeContext({ showDebug: true, toggleDebug: () => {} });
+    const result = await executeCommand('debug', [], ctx);
+    expect(result).toBe('Debug panel hidden.');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// /cost command
+// ---------------------------------------------------------------------------
+
+describe('/cost command', () => {
+  test('returns "no queries" when turnCount is 0', async () => {
+    const ctx = makeContext({ turnCount: 0 });
+    const result = await executeCommand('cost', [], ctx);
+    expect(result).toBe('No queries yet this session.');
+  });
+
+  test('returns session stats when there are turns', async () => {
+    const ctx = makeContext({
+      turnCount: 3,
+      cumulativeTokens: 15000,
+      cumulativeCost: 0.045,
+      model: 'claude-sonnet-4-5',
+    });
+    const result = await executeCommand('cost', [], ctx) as string;
+    expect(result).toContain('Turns: 3');
+    expect(result).toContain('15,000');
+    expect(result).toContain('claude-sonnet-4-5');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// /verbose command
+// ---------------------------------------------------------------------------
+
+describe('/verbose command', () => {
+  test('toggles verbose setting and returns message', async () => {
+    const ctx = makeContext();
+    const result = await executeCommand('verbose', [], ctx) as string;
+    // First toggle: was false → now true
+    expect(typeof result).toBe('string');
+    expect(result).toMatch(/verbose mode/i);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// /help command
+// ---------------------------------------------------------------------------
+
+describe('/help command', () => {
+  test('returns a React element', async () => {
+    const ctx = makeContext();
+    const result = await executeCommand('help', [], ctx);
+    expect(React.isValidElement(result)).toBe(true);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// /shortcuts command
+// ---------------------------------------------------------------------------
+
+describe('/shortcuts command', () => {
+  test('returns a React element', async () => {
+    const ctx = makeContext();
+    const result = await executeCommand('shortcuts', [], ctx);
+    expect(React.isValidElement(result)).toBe(true);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// /export command
+// ---------------------------------------------------------------------------
+
+describe('/export command', () => {
+  const exportDir = join('.brownian', 'exports');
+
+  afterAll(() => {
+    // Clean up export files
+    if (existsSync(exportDir)) {
+      rmSync(exportDir, { recursive: true });
+    }
+  });
+
+  test('exports markdown by default', async () => {
+    const historyItems = [makeHistoryItem('What is Bitcoin?', 'Bitcoin is a cryptocurrency.')];
+    const ctx = makeContext({ history: historyItems, model: 'claude-sonnet-4-5' });
+    const result = await executeCommand('export', [], ctx) as string;
+
+    expect(result).toContain('Exported 1 messages to');
+    expect(result).toContain('.md');
+  });
+
+  test('exports json when arg is "json"', async () => {
+    const historyItems = [makeHistoryItem('What is ETH?', 'Ethereum is a blockchain platform.')];
+    const ctx = makeContext({ history: historyItems });
+    const result = await executeCommand('export', ['json'], ctx) as string;
+
+    expect(result).toContain('Exported 1 messages to');
+    expect(result).toContain('.json');
+  });
+
+  test('handles empty history', async () => {
+    const ctx = makeContext({ history: [] });
+    const result = await executeCommand('export', [], ctx) as string;
+
+    expect(result).toContain('Exported 0 messages to');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Unknown command
+// ---------------------------------------------------------------------------
+
+describe('unknown command', () => {
+  test('executeCommand returns undefined for unregistered command', async () => {
+    const ctx = makeContext();
+    const result = await executeCommand('nonexistent_xyz', [], ctx);
+    expect(result).toBeUndefined();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// /compact command
+// ---------------------------------------------------------------------------
+
+describe('/compact command', () => {
+  test('returns "not available" when runCompactQuery is not provided', async () => {
+    const ctx = makeContext();
+    const result = await executeCommand('compact', [], ctx);
+    expect(result).toBe('Compact not available.');
+  });
+
+  test('calls runCompactQuery with instructions when provided', async () => {
+    let receivedInstructions: string | undefined;
+    const ctx = makeContext({
+      runCompactQuery: async (instructions) => { receivedInstructions = instructions; },
+    });
+    await executeCommand('compact', ['focus', 'on', 'DeFi'], ctx);
+    expect(receivedInstructions).toBe('focus on DeFi');
+  });
+
+  test('calls runCompactQuery with undefined when no instructions', async () => {
+    let receivedInstructions: string | undefined = 'should-be-overwritten';
+    const ctx = makeContext({
+      runCompactQuery: async (instructions) => { receivedInstructions = instructions; },
+    });
+    await executeCommand('compact', [], ctx);
+    expect(receivedInstructions).toBeUndefined();
+  });
+});

package/src/commands/builtin.ts

@@ -0,0 +1,200 @@
+import React from 'react';
+import { writeFile, mkdir } from 'fs/promises';
+import { existsSync } from 'fs';
+import { join } from 'path';
+import type { CommandDef, CommandContext } from './types.js';
+import { commandRegistry } from './registry.js';
+import { HelpView, ShortcutsView } from '../components/HelpView.js';
+import { formatCost } from '../utils/cost-calculator.js';
+import { LongTermChatHistory } from '../utils/long-term-chat-history.js';
+import { getSetting, setSetting } from '../utils/config.js';
+
+const builtinCommands: CommandDef[] = [
+  {
+    name: 'help',
+    description: 'Show commands & keyboard shortcuts',
+    type: 'local-jsx',
+    execute: () => React.createElement(HelpView),
+  },
+  {
+    name: 'clear',
+    description: 'Clear conversation history',
+    aliases: ['new'],
+    type: 'local',
+    execute: (_args, ctx) => {
+      ctx.clearHistory();
+      return 'Conversation cleared.';
+    },
+  },
+  {
+    name: 'model',
+    description: 'Switch model/provider',
+    type: 'local',
+    execute: (_args, ctx) => {
+      ctx.startSelection();
+    },
+  },
+  {
+    name: 'debug',
+    description: 'Toggle debug panel',
+    type: 'local',
+    execute: (_args, ctx) => {
+      ctx.toggleDebug();
+      return ctx.showDebug ? 'Debug panel hidden.' : 'Debug panel visible.';
+    },
+  },
+  {
+    name: 'cost',
+    description: 'Show session token/cost stats',
+    type: 'local',
+    execute: (_args, ctx) => {
+      if (ctx.turnCount === 0) {
+        return 'No queries yet this session.';
+      }
+      const lines = [
+        `Session Stats:`,
+        `  Turns: ${ctx.turnCount}`,
+        `  Tokens: ${ctx.cumulativeTokens.toLocaleString()}`,
+        `  Cost: ${formatCost(ctx.cumulativeCost)}`,
+        `  Model: ${ctx.model}`,
+      ];
+      return lines.join('\n');
+    },
+  },
+  {
+    name: 'compact',
+    description: 'Summarize & clear old context',
+    argHint: '[instructions]',
+    type: 'local',
+    execute: async (args, ctx) => {
+      if (ctx.runCompactQuery) {
+        const instructions = args.join(' ') || undefined;
+        await ctx.runCompactQuery(instructions);
+        return; // runCompactQuery handles the message
+      }
+      return 'Compact not available.';
+    },
+  },
+  {
+    name: 'history',
+    description: 'Show past queries',
+    argHint: '[search term]',
+    type: 'local',
+    execute: async (args) => {
+      const longTermHistory = new LongTermChatHistory();
+      await longTermHistory.load();
+      const entries = longTermHistory.getMessages();
+
+      if (entries.length === 0) {
+        return 'No history found.';
+      }
+
+      const searchTerm = args.join(' ').toLowerCase();
+      const filtered = searchTerm
+        ? entries.filter(e => e.userMessage.toLowerCase().includes(searchTerm))
+        : entries.slice(0, 10);
+
+      if (filtered.length === 0) {
+        return `No history matching "${searchTerm}".`;
+      }
+
+      const lines = filtered.map(e => {
+        const date = new Date(e.timestamp).toLocaleDateString('en-US', {
+          month: 'short', day: 'numeric', hour: '2-digit', minute: '2-digit',
+        });
+        const msg = e.userMessage.length > 60
+          ? e.userMessage.slice(0, 57) + '...'
+          : e.userMessage;
+        return `  ${date}  ${msg}`;
+      });
+
+      const header = searchTerm
+        ? `History matching "${searchTerm}" (${filtered.length}):`
+        : `Recent queries (${filtered.length}):`;
+
+      return [header, ...lines].join('\n');
+    },
+  },
+  {
+    name: 'export',
+    description: 'Export conversation to file',
+    argHint: '[json]',
+    type: 'local',
+    execute: async (args, ctx) => {
+      const format = args[0]?.toLowerCase() === 'json' ? 'json' : 'md';
+      const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+      const dir = join('.brownian', 'exports');
+      const filename = `${timestamp}.${format}`;
+      const filepath = join(dir, filename);
+
+      if (!existsSync(dir)) {
+        await mkdir(dir, { recursive: true });
+      }
+
+      let content: string;
+      if (format === 'json') {
+        content = JSON.stringify(ctx.history.map(h => ({
+          query: h.query,
+          answer: h.answer,
+          status: h.status,
+          tokenUsage: h.tokenUsage,
+          duration: h.duration,
+        })), null, 2);
+      } else {
+        const sections = ctx.history.map(h => {
+          const lines = [`## ${h.query}\n`];
+          if (h.events.length > 0) {
+            const toolCalls = h.events.filter(e => e.event.type === 'tool_start');
+            if (toolCalls.length > 0) {
+              lines.push('**Tools used:** ' + toolCalls.map(e =>
+                (e.event as { tool: string }).tool
+              ).join(', ') + '\n');
+            }
+          }
+          if (h.answer) {
+            lines.push(h.answer + '\n');
+          }
+          return lines.join('\n');
+        });
+        content = `# Brownian Code Export\n\nDate: ${new Date().toISOString()}\nModel: ${ctx.model}\n\n---\n\n${sections.join('\n---\n\n')}`;
+      }
+
+      await writeFile(filepath, content, 'utf-8');
+      return `Exported ${ctx.history.length} messages to ${filepath}`;
+    },
+  },
+  {
+    name: 'verbose',
+    description: 'Toggle verbose tool output',
+    type: 'local',
+    execute: () => {
+      const current = getSetting('verbose', false);
+      setSetting('verbose', !current);
+      return current ? 'Verbose mode off.' : 'Verbose mode on.';
+    },
+  },
+  {
+    name: 'shortcuts',
+    description: 'Show keyboard shortcuts',
+    type: 'local-jsx',
+    execute: () => React.createElement(ShortcutsView),
+  },
+  // Hidden aliases
+  {
+    name: 'new',
+    description: 'Start new conversation',
+    type: 'local',
+    isHidden: true,
+    execute: (_args, ctx) => {
+      ctx.clearHistory();
+      return 'Conversation cleared.';
+    },
+  },
+];
+
+/**
+ * Register all builtin commands with the global registry.
+ */
+export function registerBuiltinCommands(): void {
+  commandRegistry.registerAll(builtinCommands);
+}

package/src/commands/registry.test.ts

@@ -0,0 +1,188 @@
+import { describe, test, expect, beforeEach } from 'bun:test';
+import { parseCommand, commandRegistry } from './registry.js';
+import type { CommandDef } from './types.js';
+
+// ---------------------------------------------------------------------------
+// parseCommand
+// ---------------------------------------------------------------------------
+
+describe('parseCommand', () => {
+  test('parses simple command', () => {
+    const result = parseCommand('/help');
+    expect(result).toEqual({ name: 'help', args: [] });
+  });
+
+  test('parses command with single arg', () => {
+    const result = parseCommand('/history search');
+    expect(result).toEqual({ name: 'history', args: ['search'] });
+  });
+
+  test('parses command with multiple args', () => {
+    const result = parseCommand('/history search bitcoin defi');
+    expect(result).toEqual({ name: 'history', args: ['search', 'bitcoin', 'defi'] });
+  });
+
+  test('normalizes command name to lowercase', () => {
+    const result = parseCommand('/HELP');
+    expect(result).toEqual({ name: 'help', args: [] });
+  });
+
+  test('handles leading/trailing whitespace', () => {
+    const result = parseCommand('  /help  ');
+    expect(result).toEqual({ name: 'help', args: [] });
+  });
+
+  test('returns null for non-command input', () => {
+    expect(parseCommand('hello world')).toBeNull();
+    expect(parseCommand('what is bitcoin')).toBeNull();
+  });
+
+  test('returns null for empty string', () => {
+    expect(parseCommand('')).toBeNull();
+  });
+
+  test('returns null for just a slash', () => {
+    expect(parseCommand('/')).toBeNull();
+  });
+
+  test('returns null for whitespace-only string', () => {
+    expect(parseCommand('   ')).toBeNull();
+  });
+
+  test('handles extra spaces between args', () => {
+    const result = parseCommand('/export   json');
+    expect(result).toEqual({ name: 'export', args: ['json'] });
+  });
+});
+
+// ---------------------------------------------------------------------------
+// CommandRegistry
+// ---------------------------------------------------------------------------
+
+describe('CommandRegistry', () => {
+  // Register test commands before each test
+  const testCmd: CommandDef = {
+    name: 'testcmd',
+    description: 'A test command',
+    type: 'local',
+    execute: () => 'test result',
+  };
+
+  const aliasedCmd: CommandDef = {
+    name: 'aliased',
+    description: 'A command with aliases',
+    aliases: ['al', 'als'],
+    type: 'local',
+    execute: () => 'aliased result',
+  };
+
+  const hiddenCmd: CommandDef = {
+    name: 'hiddencmd',
+    description: 'A hidden command',
+    type: 'local',
+    isHidden: true,
+    execute: () => 'hidden result',
+  };
+
+  // -------------------------------------------------------------------------
+  // get
+  // -------------------------------------------------------------------------
+  describe('get', () => {
+    test('retrieves a registered command by name', () => {
+      commandRegistry.register(testCmd);
+      expect(commandRegistry.get('testcmd')).toBe(testCmd);
+    });
+
+    test('retrieves a command by alias', () => {
+      commandRegistry.register(aliasedCmd);
+      expect(commandRegistry.get('al')).toBe(aliasedCmd);
+      expect(commandRegistry.get('als')).toBe(aliasedCmd);
+    });
+
+    test('returns undefined for unregistered command', () => {
+      expect(commandRegistry.get('nonexistent')).toBeUndefined();
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // getVisible
+  // -------------------------------------------------------------------------
+  describe('getVisible', () => {
+    test('excludes hidden commands', () => {
+      commandRegistry.register(hiddenCmd);
+      const visible = commandRegistry.getVisible();
+      const names = visible.map(c => c.name);
+      expect(names).not.toContain('hiddencmd');
+    });
+
+    test('returns unique commands (no duplicates from aliases)', () => {
+      commandRegistry.register(aliasedCmd);
+      const visible = commandRegistry.getVisible();
+      const aliasedCount = visible.filter(c => c.name === 'aliased').length;
+      expect(aliasedCount).toBe(1);
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // getAll
+  // -------------------------------------------------------------------------
+  describe('getAll', () => {
+    test('includes hidden commands', () => {
+      commandRegistry.register(hiddenCmd);
+      const all = commandRegistry.getAll();
+      const names = all.map(c => c.name);
+      expect(names).toContain('hiddencmd');
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // search
+  // -------------------------------------------------------------------------
+  describe('search', () => {
+    test('returns all visible commands for empty prefix', () => {
+      const results = commandRegistry.search('');
+      expect(results.length).toBeGreaterThan(0);
+      // Should not include hidden commands
+      const names = results.map(c => c.name);
+      expect(names).not.toContain('hiddencmd');
+    });
+
+    test('returns matching commands by prefix', () => {
+      // 'help' should be registered from builtin commands
+      const results = commandRegistry.search('hel');
+      const names = results.map(c => c.name);
+      expect(names).toContain('help');
+    });
+
+    test('returns matching commands by substring', () => {
+      const results = commandRegistry.search('port');
+      const names = results.map(c => c.name);
+      expect(names).toContain('export');
+    });
+
+    test('prioritizes prefix matches over substring matches', () => {
+      // 'he' should put 'help' before anything with 'he' only as substring
+      const results = commandRegistry.search('he');
+      expect(results.length).toBeGreaterThan(0);
+      expect(results[0].name).toBe('help');
+    });
+
+    test('matches against aliases', () => {
+      commandRegistry.register(aliasedCmd);
+      const results = commandRegistry.search('al');
+      const names = results.map(c => c.name);
+      expect(names).toContain('aliased');
+    });
+
+    test('is case-insensitive', () => {
+      const results = commandRegistry.search('HELP');
+      const names = results.map(c => c.name);
+      expect(names).toContain('help');
+    });
+
+    test('returns empty array for no matches', () => {
+      const results = commandRegistry.search('zzzzz');
+      expect(results).toEqual([]);
+    });
+  });
+});