brownian-code 2026.2.10

package/src/hooks/useModelSelection.ts

@@ -0,0 +1,249 @@
+import { useState, useCallback, useRef } from 'react';
+import { getSetting, setSetting } from '../utils/config.js';
+import { getProviderDisplayName, checkApiKeyExistsForProvider, saveApiKeyForProvider } from '../utils/env.js';
+import { getModelsForProvider, getDefaultModelForProvider, type Model } from '../components/ModelSelector.js';
+import { getOllamaModels } from '../utils/ollama.js';
+import { DEFAULT_MODEL, DEFAULT_PROVIDER } from '../model/llm.js';
+import { InMemoryChatHistory } from '../utils/in-memory-chat-history.js';
+
+// ============================================================================
+// Types
+// ============================================================================
+
+const SELECTION_STATES = ['provider_select', 'model_select', 'model_input', 'api_key_confirm', 'api_key_input'] as const;
+type SelectionState = typeof SELECTION_STATES[number];
+type AppState = 'idle' | SelectionState;
+
+export interface ModelSelectionState {
+  appState: AppState;
+  pendingProvider: string | null;
+  pendingModels: Model[];
+}
+
+export interface UseModelSelectionResult {
+  // Current state
+  selectionState: ModelSelectionState;
+  provider: string;
+  model: string;
+  inMemoryChatHistoryRef: React.RefObject<InMemoryChatHistory>;
+  
+  // Actions
+  startSelection: () => void;
+  cancelSelection: () => void;
+  handleProviderSelect: (providerId: string | null) => Promise<void>;
+  handleModelSelect: (modelId: string | null) => void;
+  handleModelInputSubmit: (modelName: string | null) => void;
+  handleApiKeyConfirm: (wantsToSet: boolean) => void;
+  handleApiKeySubmit: (apiKey: string | null) => void;
+  
+  // Helpers
+  isInSelectionFlow: () => boolean;
+}
+
+// ============================================================================
+// Helper
+// ============================================================================
+
+function isSelectionState(state: AppState): state is SelectionState {
+  return (SELECTION_STATES as readonly string[]).includes(state);
+}
+
+// ============================================================================
+// Hook
+// ============================================================================
+
+export function useModelSelection(
+  onError: (message: string) => void
+): UseModelSelectionResult {
+  // Provider and model state (persisted)
+  const [provider, setProvider] = useState(() => getSetting('provider', DEFAULT_PROVIDER));
+  const [model, setModel] = useState(() => {
+    const savedModel = getSetting('modelId', null) as string | null;
+    const savedProvider = getSetting('provider', DEFAULT_PROVIDER) as string;
+    if (savedModel) {
+      return savedModel;
+    }
+    return getDefaultModelForProvider(savedProvider) || DEFAULT_MODEL;
+  });
+  
+  // Selection flow state
+  const [appState, setAppState] = useState<AppState>('idle');
+  const [pendingProvider, setPendingProvider] = useState<string | null>(null);
+  const [pendingModels, setPendingModels] = useState<Model[]>([]);
+  const [pendingSelectedModelId, setPendingSelectedModelId] = useState<string | null>(null);
+  
+  // Message history ref - shared with agent runner
+  const inMemoryChatHistoryRef = useRef<InMemoryChatHistory>(new InMemoryChatHistory(model));
+  
+  // Helper to complete a model switch (DRY pattern)
+  const completeModelSwitch = useCallback((newProvider: string, newModelId: string) => {
+    setProvider(newProvider);
+    setModel(newModelId);
+    setSetting('provider', newProvider);
+    setSetting('modelId', newModelId);
+    inMemoryChatHistoryRef.current.setModel(newModelId);
+    setPendingProvider(null);
+    setPendingModels([]);
+    setPendingSelectedModelId(null);
+    setAppState('idle');
+  }, []);
+  
+  // Reset pending state
+  const resetPendingState = useCallback(() => {
+    setPendingProvider(null);
+    setPendingModels([]);
+    setPendingSelectedModelId(null);
+    setAppState('idle');
+  }, []);
+  
+  // Start selection flow
+  const startSelection = useCallback(() => {
+    setAppState('provider_select');
+  }, []);
+  
+  // Cancel selection flow
+  const cancelSelection = useCallback(() => {
+    resetPendingState();
+  }, [resetPendingState]);
+  
+  // Check if in selection flow
+  const isInSelectionFlow = useCallback(() => {
+    return isSelectionState(appState);
+  }, [appState]);
+  
+  // Provider selection handler
+  const handleProviderSelect = useCallback(async (providerId: string | null) => {
+    if (providerId) {
+      setPendingProvider(providerId);
+      
+      // OpenRouter uses free-text model input instead of a list
+      if (providerId === 'openrouter') {
+        setPendingModels([]);
+        setAppState('model_input');
+      } else if (providerId === 'ollama') {
+        // Fetch models from local Ollama API and convert to Model objects
+        const ollamaModelIds = await getOllamaModels();
+        const ollamaModels: Model[] = ollamaModelIds.map((id) => ({ id, displayName: id }));
+        setPendingModels(ollamaModels);
+        setAppState('model_select');
+      } else {
+        setPendingModels(getModelsForProvider(providerId));
+        setAppState('model_select');
+      }
+    } else {
+      setAppState('idle');
+    }
+  }, []);
+  
+  // Model selection handler (for list-based selection)
+  const handleModelSelect = useCallback((modelId: string | null) => {
+    if (!modelId || !pendingProvider) {
+      // User cancelled - go back to provider select
+      setPendingProvider(null);
+      setPendingModels([]);
+      setPendingSelectedModelId(null);
+      setAppState('provider_select');
+      return;
+    }
+    
+    // For Ollama, skip API key flow entirely
+    if (pendingProvider === 'ollama') {
+      const fullModelId = `ollama:${modelId}`;
+      completeModelSwitch(pendingProvider, fullModelId);
+      return;
+    }
+    
+    // For cloud providers, check API key
+    if (checkApiKeyExistsForProvider(pendingProvider)) {
+      completeModelSwitch(pendingProvider, modelId);
+    } else {
+      // Need to get API key - store the selected model temporarily
+      setPendingSelectedModelId(modelId);
+      setAppState('api_key_confirm');
+    }
+  }, [pendingProvider, completeModelSwitch]);
+  
+  // Model input handler (for free-text input like OpenRouter)
+  const handleModelInputSubmit = useCallback((modelName: string | null) => {
+    if (!modelName || !pendingProvider) {
+      // User cancelled - go back to provider select
+      setPendingProvider(null);
+      setPendingModels([]);
+      setPendingSelectedModelId(null);
+      setAppState('provider_select');
+      return;
+    }
+    
+    // Store with provider prefix (e.g., openrouter:anthropic/claude-3.5-sonnet)
+    const fullModelId = `${pendingProvider}:${modelName}`;
+    
+    // Check API key for the provider
+    if (checkApiKeyExistsForProvider(pendingProvider)) {
+      completeModelSwitch(pendingProvider, fullModelId);
+    } else {
+      // Need to get API key - store the selected model temporarily
+      setPendingSelectedModelId(fullModelId);
+      setAppState('api_key_confirm');
+    }
+  }, [pendingProvider, completeModelSwitch]);
+  
+  // API key confirmation handler
+  const handleApiKeyConfirm = useCallback((wantsToSet: boolean) => {
+    if (wantsToSet) {
+      setAppState('api_key_input');
+    } else {
+      // Check if existing key is available
+      if (pendingProvider && pendingSelectedModelId && checkApiKeyExistsForProvider(pendingProvider)) {
+        completeModelSwitch(pendingProvider, pendingSelectedModelId);
+      } else {
+        onError(`Cannot use ${pendingProvider ? getProviderDisplayName(pendingProvider) : 'provider'} without an API key.`);
+        resetPendingState();
+      }
+    }
+  }, [pendingProvider, pendingSelectedModelId, completeModelSwitch, resetPendingState, onError]);
+  
+  // API key submit handler
+  const handleApiKeySubmit = useCallback((apiKey: string | null) => {
+    // Guard: ensure we have a selected model
+    if (!pendingSelectedModelId) {
+      onError('No model selected.');
+      resetPendingState();
+      return;
+    }
+    
+    if (apiKey && pendingProvider) {
+      const saved = saveApiKeyForProvider(pendingProvider, apiKey);
+      if (saved) {
+        completeModelSwitch(pendingProvider, pendingSelectedModelId);
+      } else {
+        onError('Failed to save API key.');
+        resetPendingState();
+      }
+    } else if (!apiKey && pendingProvider && checkApiKeyExistsForProvider(pendingProvider)) {
+      // Cancelled but existing key available
+      completeModelSwitch(pendingProvider, pendingSelectedModelId);
+    } else {
+      onError('API key not set. Provider unchanged.');
+      resetPendingState();
+    }
+  }, [pendingProvider, pendingSelectedModelId, completeModelSwitch, resetPendingState, onError]);
+  
+  return {
+    selectionState: {
+      appState,
+      pendingProvider,
+      pendingModels,
+    },
+    provider,
+    model,
+    inMemoryChatHistoryRef,
+    startSelection,
+    cancelSelection,
+    handleProviderSelect,
+    handleModelSelect,
+    handleModelInputSubmit,
+    handleApiKeyConfirm,
+    handleApiKeySubmit,
+    isInSelectionFlow,
+  };
+}

package/src/hooks/useTextBuffer.test.ts

@@ -0,0 +1,121 @@
+import { describe, test, expect, afterEach } from 'bun:test';
+import React, { useState, useCallback } from 'react';
+import { Box, Text } from 'ink';
+import { render, cleanup } from 'ink-testing-library';
+import { useTextBuffer } from './useTextBuffer.js';
+
+afterEach(cleanup);
+
+/**
+ * Test component that drives useTextBuffer through stdin keypresses.
+ * Instead of calling actions directly (which don't trigger re-renders in test),
+ * we test via the same mechanism the real Input uses: useInput-like patterns.
+ *
+ * For unit testing of ref-based hook, we use a command-driven approach:
+ * The component reads a "command" prop and executes it on mount/update.
+ */
+function TestBuffer({ command }: { command: string }) {
+  const { text, cursorPosition, actions } = useTextBuffer();
+
+  // Execute command on each render with a new command value
+  const [lastCmd, setLastCmd] = React.useState('');
+  if (command !== lastCmd) {
+    setLastCmd(command);
+    const parts = command.split(':');
+    const op = parts[0];
+    const arg = parts.slice(1).join(':');
+
+    switch (op) {
+      case 'insert': actions.insert(arg); break;
+      case 'delete': actions.deleteBackward(); break;
+      case 'deleteWord': actions.deleteWordBackward(); break;
+      case 'move': actions.moveCursor(parseInt(arg)); break;
+      case 'clear': actions.clear(); break;
+      case 'set': actions.setValue(arg); break;
+      case 'setStart': actions.setValue(arg, false); break;
+    }
+  }
+
+  return React.createElement(Text, null, `[${text}|${cursorPosition}]`);
+}
+
+// Since useTextBuffer uses refs + forceRender, we need to give each test
+// a unique command string to trigger the state-in-render pattern.
+// We'll use rerender() to drive state changes.
+
+describe('useTextBuffer - insert', () => {
+  test('inserts text', () => {
+    const { lastFrame, rerender } = render(
+      React.createElement(TestBuffer, { command: '' })
+    );
+    rerender(React.createElement(TestBuffer, { command: 'insert:hello' }));
+    expect(lastFrame()).toBe('[hello|5]');
+  });
+
+  test('inserts multi-character text', () => {
+    const { lastFrame, rerender } = render(
+      React.createElement(TestBuffer, { command: '' })
+    );
+    rerender(React.createElement(TestBuffer, { command: 'insert:abc' }));
+    expect(lastFrame()).toBe('[abc|3]');
+  });
+});
+
+describe('useTextBuffer - setValue', () => {
+  test('sets value with cursor at end', () => {
+    const { lastFrame, rerender } = render(
+      React.createElement(TestBuffer, { command: '' })
+    );
+    rerender(React.createElement(TestBuffer, { command: 'set:hello world' }));
+    expect(lastFrame()).toBe('[hello world|11]');
+  });
+
+  test('sets value with cursor at start', () => {
+    const { lastFrame, rerender } = render(
+      React.createElement(TestBuffer, { command: '' })
+    );
+    rerender(React.createElement(TestBuffer, { command: 'setStart:hello world' }));
+    expect(lastFrame()).toBe('[hello world|0]');
+  });
+});
+
+describe('useTextBuffer - clear', () => {
+  test('clears text and resets cursor', () => {
+    const { lastFrame, rerender } = render(
+      React.createElement(TestBuffer, { command: '' })
+    );
+    rerender(React.createElement(TestBuffer, { command: 'set:hello' }));
+    expect(lastFrame()).toBe('[hello|5]');
+    rerender(React.createElement(TestBuffer, { command: 'clear' }));
+    expect(lastFrame()).toBe('[|0]');
+  });
+});
+
+describe('useTextBuffer - moveCursor', () => {
+  test('moves to valid position', () => {
+    const { lastFrame, rerender } = render(
+      React.createElement(TestBuffer, { command: '' })
+    );
+    rerender(React.createElement(TestBuffer, { command: 'set:hello' }));
+    rerender(React.createElement(TestBuffer, { command: 'move:2' }));
+    expect(lastFrame()).toBe('[hello|2]');
+  });
+
+  test('clamps below 0', () => {
+    const { lastFrame, rerender } = render(
+      React.createElement(TestBuffer, { command: '' })
+    );
+    rerender(React.createElement(TestBuffer, { command: 'set:hello' }));
+    rerender(React.createElement(TestBuffer, { command: 'move:-5' }));
+    expect(lastFrame()).toBe('[hello|0]');
+  });
+
+  test('clamps above text length', () => {
+    const { lastFrame, rerender } = render(
+      React.createElement(TestBuffer, { command: '' })
+    );
+    rerender(React.createElement(TestBuffer, { command: 'set:hello' }));
+    rerender(React.createElement(TestBuffer, { command: 'move:100' }));
+    expect(lastFrame()).toBe('[hello|5]');
+  });
+});

package/src/hooks/useTextBuffer.ts

@@ -0,0 +1,97 @@
+import { useRef, useState, useCallback } from 'react';
+import { findPrevWordStart } from '../utils/text-navigation.js';
+
+export interface TextBufferActions {
+  /** Insert text at the current cursor position */
+  insert: (text: string) => void;
+  /** Delete the character before the cursor */
+  deleteBackward: () => void;
+  /** Delete from cursor back to start of previous word */
+  deleteWordBackward: () => void;
+  /** Move cursor to an absolute position (clamped to valid range) */
+  moveCursor: (position: number) => void;
+  /** Clear the buffer and reset cursor to 0 */
+  clear: () => void;
+  /** Set the buffer value and optionally position cursor at end */
+  setValue: (value: string, cursorAtEnd?: boolean) => void;
+}
+
+export interface UseTextBufferResult {
+  /** Current text content */
+  text: string;
+  /** Current cursor position (0-indexed) */
+  cursorPosition: number;
+  /** Actions to manipulate the buffer */
+  actions: TextBufferActions;
+}
+
+/**
+ * Hook for managing a text buffer with cursor position.
+ * Uses refs internally to avoid React state race conditions with fast typing,
+ * while still triggering re-renders when content changes.
+ */
+export function useTextBuffer(): UseTextBufferResult {
+  // Use refs to avoid race conditions with fast typing
+  const buffer = useRef('');
+  const cursorPos = useRef(0);
+  const [, forceRender] = useState(0);
+
+  const rerender = useCallback(() => forceRender(x => x + 1), []);
+
+  const actions: TextBufferActions = {
+    insert: (input: string) => {
+      // Normalize line endings but preserve newlines for multi-line input
+      const normalized = input.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+      buffer.current =
+        buffer.current.slice(0, cursorPos.current) +
+        normalized +
+        buffer.current.slice(cursorPos.current);
+      cursorPos.current += normalized.length;
+      rerender();
+    },
+
+    deleteBackward: () => {
+      if (cursorPos.current > 0) {
+        buffer.current =
+          buffer.current.slice(0, cursorPos.current - 1) +
+          buffer.current.slice(cursorPos.current);
+        cursorPos.current--;
+        rerender();
+      }
+    },
+
+    deleteWordBackward: () => {
+      if (cursorPos.current > 0) {
+        const wordStart = findPrevWordStart(buffer.current, cursorPos.current);
+        buffer.current =
+          buffer.current.slice(0, wordStart) +
+          buffer.current.slice(cursorPos.current);
+        cursorPos.current = wordStart;
+        rerender();
+      }
+    },
+
+    moveCursor: (position: number) => {
+      cursorPos.current = Math.max(0, Math.min(buffer.current.length, position));
+      rerender();
+    },
+
+    clear: () => {
+      buffer.current = '';
+      cursorPos.current = 0;
+      rerender();
+    },
+
+    setValue: (value: string, cursorAtEnd = true) => {
+      buffer.current = value;
+      cursorPos.current = cursorAtEnd ? value.length : 0;
+      rerender();
+    },
+  };
+
+  return {
+    text: buffer.current,
+    cursorPosition: cursorPos.current,
+    actions,
+  };
+}

package/src/index.tsx

@@ -0,0 +1,74 @@
+#!/usr/bin/env bun
+import { existsSync, readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirnamePreflight = dirname(fileURLToPath(import.meta.url));
+const projectRoot = join(__dirnamePreflight, '..');
+
+// Pre-flight: check dependencies are installed
+if (!existsSync(join(projectRoot, 'node_modules', 'react'))) {
+  console.error('Dependencies not installed. Run:  bun install');
+  process.exit(1);
+}
+
+// Pre-flight: warn if no .env file
+if (!existsSync(join(projectRoot, '.env'))) {
+  console.warn('No .env file found. Copy the template:  cp env.example .env');
+}
+
+import React from 'react';
+import { render } from 'ink';
+import { config } from 'dotenv';
+import { CLI } from './cli.js';
+
+// Handle --version / -v
+if (process.argv.includes('--version') || process.argv.includes('-v')) {
+  try {
+    const pkg = JSON.parse(readFileSync(join(projectRoot, 'package.json'), 'utf-8'));
+    console.log(`brownian-code v${pkg.version}`);
+  } catch {
+    console.log('brownian-code');
+  }
+  process.exit(0);
+}
+
+// Handle --help / -h
+if (process.argv.includes('--help') || process.argv.includes('-h')) {
+  console.log(`
+Brownian Code - Autonomous crypto research agent
+Think Claude Code, but built for crypto research.
+
+Usage:
+  brownian              Start interactive session
+  brownian --version    Show version
+  brownian --help       Show this help
+
+Environment:
+  Set API keys in .env or enter them interactively.
+  See env.example for all supported variables.
+
+Commands (inside the app):
+  /help       Show commands & keyboard shortcuts
+  /model      Switch model/provider
+  /clear      Clear conversation history
+  /cost       Show session token/cost stats
+  /compact    Summarize & clear old context
+  /history    Show past queries
+  /export     Export conversation to file
+  /debug      Toggle debug panel
+  /verbose    Toggle verbose tool output
+  /shortcuts  Show keyboard shortcuts
+
+More info: https://brownian.xyz
+`);
+  process.exit(0);
+}
+
+// Load environment variables
+config({ quiet: true });
+
+// Render the CLI app and wait for it to exit
+// This keeps the process alive until the user exits
+const { waitUntilExit } = render(<CLI />);
+await waitUntilExit();