brownian-code 2026.2.10

package/src/gateway/index.ts

@@ -0,0 +1,62 @@
+#!/usr/bin/env bun
+/**
+ * Brownian WhatsApp Gateway — Entry Point
+ *
+ * Run:  bun run gateway
+ *
+ * Listens for self-messages on WhatsApp, routes them to the Brownian agent,
+ * and sends responses back. Handles graceful shutdown on SIGINT/SIGTERM.
+ */
+import { config } from 'dotenv';
+import { loadGatewayConfig } from './config.js';
+import { createWhatsAppSession } from './channels/whatsapp/session.js';
+import { registerInboundHandler } from './channels/whatsapp/inbound.js';
+import { disconnectHiveMCP } from '../mcp/client.js';
+import type { WASocket } from '@whiskeysockets/baileys';
+
+// Load environment variables
+config({ quiet: true });
+
+const gatewayConfig = loadGatewayConfig();
+let activeSock: WASocket | null = null;
+
+console.log('Brownian WhatsApp Gateway');
+console.log('Connecting to WhatsApp...\n');
+
+if (!gatewayConfig.channels.whatsapp.enabled) {
+  console.error('WhatsApp channel is disabled in ~/.brownian/gateway.json');
+  process.exit(1);
+}
+
+await createWhatsAppSession({
+  printQR: true,
+  onReady: (sock) => {
+    activeSock = sock;
+    registerInboundHandler(sock, gatewayConfig.channels.whatsapp);
+    console.log('Gateway is running. Send yourself a WhatsApp message to query Brownian.');
+    console.log('Press Ctrl+C to stop.\n');
+  },
+  onLoggedOut: () => {
+    console.log('Session logged out. Run: bun run gateway:login');
+    process.exit(1);
+  },
+});
+
+// Graceful shutdown
+async function shutdown() {
+  console.log('\nShutting down gateway...');
+
+  if (activeSock) {
+    try {
+      await activeSock.logout();
+    } catch {
+      // Best-effort
+    }
+  }
+
+  await disconnectHiveMCP();
+  process.exit(0);
+}
+
+process.on('SIGINT', shutdown);
+process.on('SIGTERM', shutdown);

package/src/hooks/useAgentRunner.ts

@@ -0,0 +1,317 @@
+import { useState, useCallback, useRef } from 'react';
+import { Agent } from '../agent/agent.js';
+import { InMemoryChatHistory } from '../utils/in-memory-chat-history.js';
+import { estimateCost } from '../utils/cost-calculator.js';
+import { callLlm, getFastModel } from '../model/llm.js';
+import type { HistoryItem, WorkingState } from '../components/index.js';
+import type { AgentConfig, AgentEvent, DoneEvent } from '../agent/index.js';
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export interface RunQueryResult {
+  answer: string;
+}
+
+export interface UseAgentRunnerResult {
+  // State
+  history: HistoryItem[];
+  workingState: WorkingState;
+  error: string | null;
+  isProcessing: boolean;
+
+  // Cumulative session stats
+  cumulativeTokens: number;
+  cumulativeCost: number;
+  turnCount: number;
+
+  // Actions
+  runQuery: (query: string) => Promise<RunQueryResult | undefined>;
+  runCompactQuery: (instructions?: string) => Promise<void>;
+  cancelExecution: () => void;
+  setError: (error: string | null) => void;
+  clearHistory: () => void;
+}
+
+// ============================================================================
+// Hook
+// ============================================================================
+
+export function useAgentRunner(
+  agentConfig: AgentConfig,
+  inMemoryChatHistoryRef: React.RefObject<InMemoryChatHistory>
+): UseAgentRunnerResult {
+  const [history, setHistory] = useState<HistoryItem[]>([]);
+  const [workingState, setWorkingState] = useState<WorkingState>({ status: 'idle' });
+  const [error, setError] = useState<string | null>(null);
+
+  // Cumulative session stats
+  const [cumulativeTokens, setCumulativeTokens] = useState(0);
+  const [cumulativeCost, setCumulativeCost] = useState(0);
+  const [turnCount, setTurnCount] = useState(0);
+
+  const abortControllerRef = useRef<AbortController | null>(null);
+
+  // Helper to update the last (processing) history item
+  const updateLastHistoryItem = useCallback((
+    updater: (item: HistoryItem) => Partial<HistoryItem>
+  ) => {
+    setHistory(prev => {
+      const last = prev[prev.length - 1];
+      if (!last || last.status !== 'processing') return prev;
+      return [...prev.slice(0, -1), { ...last, ...updater(last) }];
+    });
+  }, []);
+
+  // Handle agent events
+  const handleEvent = useCallback((event: AgentEvent) => {
+    switch (event.type) {
+      case 'thinking':
+        setWorkingState({ status: 'thinking' });
+        updateLastHistoryItem(item => ({
+          events: [...item.events, {
+            id: `thinking-${Date.now()}`,
+            event,
+            completed: true,
+          }],
+        }));
+        break;
+
+      case 'tool_start': {
+        const toolId = `tool-${event.tool}-${Date.now()}`;
+        setWorkingState({ status: 'tool', toolName: event.tool });
+        updateLastHistoryItem(item => ({
+          activeToolId: toolId,
+          events: [...item.events, {
+            id: toolId,
+            event,
+            completed: false,
+          }],
+        }));
+        break;
+      }
+
+      case 'tool_progress':
+        updateLastHistoryItem(item => ({
+          events: item.events.map(e =>
+            e.id === item.activeToolId
+              ? { ...e, progressMessage: event.message }
+              : e
+          ),
+        }));
+        break;
+
+      case 'tool_end':
+        setWorkingState({ status: 'thinking' });
+        updateLastHistoryItem(item => ({
+          activeToolId: undefined,
+          events: item.events.map(e =>
+            e.id === item.activeToolId
+              ? { ...e, completed: true, endEvent: event }
+              : e
+          ),
+        }));
+        break;
+
+      case 'tool_error':
+        setWorkingState({ status: 'thinking' });
+        updateLastHistoryItem(item => ({
+          activeToolId: undefined,
+          events: item.events.map(e =>
+            e.id === item.activeToolId
+              ? { ...e, completed: true, endEvent: event }
+              : e
+          ),
+        }));
+        break;
+
+      case 'answer_start':
+        setWorkingState({ status: 'answering', startTime: Date.now() });
+        break;
+
+      case 'done': {
+        const doneEvent = event as DoneEvent;
+
+        // Accumulate session stats
+        if (doneEvent.tokenUsage) {
+          setCumulativeTokens(prev => prev + doneEvent.tokenUsage!.totalTokens);
+          const cost = estimateCost(
+            agentConfig.model || '',
+            doneEvent.tokenUsage.inputTokens,
+            doneEvent.tokenUsage.outputTokens
+          );
+          setCumulativeCost(prev => prev + cost.totalCost);
+        }
+        setTurnCount(prev => prev + 1);
+
+        updateLastHistoryItem(item => {
+          // Update answer in chat history for multi-turn context
+          if (doneEvent.answer) {
+            inMemoryChatHistoryRef.current?.saveAnswer(doneEvent.answer).catch(() => {
+              // Silently ignore errors in updating history
+            });
+          }
+          return {
+            answer: doneEvent.answer,
+            status: 'complete' as const,
+            duration: doneEvent.totalTime,
+            tokenUsage: doneEvent.tokenUsage,
+            tokensPerSecond: doneEvent.tokensPerSecond,
+          };
+        });
+        setWorkingState({ status: 'idle' });
+        break;
+      }
+    }
+  }, [updateLastHistoryItem, inMemoryChatHistoryRef, agentConfig.model]);
+
+  // Run a query through the agent
+  const runQuery = useCallback(async (query: string): Promise<RunQueryResult | undefined> => {
+    // Create abort controller for this execution
+    const abortController = new AbortController();
+    abortControllerRef.current = abortController;
+
+    // Track the final answer to return
+    let finalAnswer: string | undefined;
+
+    // Add to history immediately
+    const itemId = Date.now().toString();
+    const startTime = Date.now();
+    setHistory(prev => [...prev, {
+      id: itemId,
+      query,
+      events: [],
+      answer: '',
+      status: 'processing',
+      startTime,
+    }]);
+
+    // Save query to chat history immediately for multi-turn context
+    inMemoryChatHistoryRef.current?.saveUserQuery(query);
+
+    setError(null);
+    setWorkingState({ status: 'thinking' });
+
+    try {
+      const agent = await Agent.create({
+        ...agentConfig,
+        signal: abortController.signal,
+      });
+      const stream = agent.run(query, inMemoryChatHistoryRef.current!);
+
+      for await (const event of stream) {
+        // Capture the final answer from the done event
+        if (event.type === 'done') {
+          finalAnswer = (event as DoneEvent).answer;
+        }
+        handleEvent(event);
+      }
+
+      // Return the answer if we got one
+      if (finalAnswer) {
+        return { answer: finalAnswer };
+      }
+    } catch (e) {
+      // Handle abort gracefully - mark as interrupted, not error
+      if (e instanceof Error && e.name === 'AbortError') {
+        setHistory(prev => {
+          const last = prev[prev.length - 1];
+          if (!last || last.status !== 'processing') return prev;
+          return [...prev.slice(0, -1), { ...last, status: 'interrupted' }];
+        });
+        setWorkingState({ status: 'idle' });
+        return undefined;
+      }
+
+      const errorMsg = e instanceof Error ? e.message : String(e);
+      setError(errorMsg);
+      // Mark the history item as error
+      setHistory(prev => {
+        const last = prev[prev.length - 1];
+        if (!last || last.status !== 'processing') return prev;
+        return [...prev.slice(0, -1), { ...last, status: 'error' }];
+      });
+      setWorkingState({ status: 'idle' });
+      return undefined;
+    } finally {
+      abortControllerRef.current = null;
+    }
+  }, [agentConfig, inMemoryChatHistoryRef, handleEvent]);
+
+  // Cancel the current execution
+  const cancelExecution = useCallback(() => {
+    if (abortControllerRef.current) {
+      abortControllerRef.current.abort();
+      abortControllerRef.current = null;
+    }
+
+    // Mark current processing item as interrupted
+    setHistory(prev => {
+      const last = prev[prev.length - 1];
+      if (!last || last.status !== 'processing') return prev;
+      return [...prev.slice(0, -1), { ...last, status: 'interrupted' }];
+    });
+    setWorkingState({ status: 'idle' });
+  }, []);
+
+  // Clear conversation history (session only)
+  const clearHistory = useCallback(() => {
+    setHistory([]);
+    setError(null);
+    setTurnCount(0);
+    setCumulativeTokens(0);
+    setCumulativeCost(0);
+    // Clear in-memory chat context but keep persistent history
+    inMemoryChatHistoryRef.current?.clear();
+  }, [inMemoryChatHistoryRef]);
+
+  // Compact conversation: summarize history, clear, and reset counters
+  const runCompactQuery = useCallback(async (instructions?: string) => {
+    const chatHistory = inMemoryChatHistoryRef.current;
+    if (!chatHistory?.hasMessages()) {
+      setError('Nothing to compact.');
+      return;
+    }
+
+    const messages = chatHistory.getMessages();
+    const summaryPrompt = `Summarize this conversation concisely:\n${messages.map(m =>
+      `User: ${m.query}\nAssistant: ${m.summary || m.answer || '(pending)'}`
+    ).join('\n\n')}${instructions ? `\nFocus on: ${instructions}` : ''}`;
+
+    try {
+      const fastModel = getFastModel(agentConfig.modelProvider || 'anthropic', agentConfig.model || '');
+      const { response } = await callLlm(summaryPrompt, {
+        model: fastModel,
+        systemPrompt: 'Summarize the conversation briefly. Keep key facts, numbers, and decisions.',
+      });
+      const summary = typeof response === 'string' ? response : String(response);
+
+      chatHistory.clear();
+      chatHistory.saveUserQuery('[Compacted conversation]');
+      await chatHistory.saveAnswer(summary);
+      setCumulativeTokens(0);
+      setCumulativeCost(0);
+    } catch (e) {
+      setError(`Compact failed: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  }, [inMemoryChatHistoryRef, agentConfig.modelProvider, agentConfig.model, setError]);
+
+  // Check if currently processing
+  const isProcessing = history.length > 0 && history[history.length - 1].status === 'processing';
+
+  return {
+    history,
+    workingState,
+    error,
+    isProcessing,
+    cumulativeTokens,
+    cumulativeCost,
+    turnCount,
+    runQuery,
+    runCompactQuery,
+    cancelExecution,
+    setError,
+    clearHistory,
+  };
+}

package/src/hooks/useDebugLogs.ts

@@ -0,0 +1,22 @@
+import { useState, useEffect } from 'react';
+import type { LogEntry } from '../utils/logger.js';
+import { logger } from '../utils/logger.js';
+
+/**
+ * Hook to get debug logs for display in the UI.
+ */
+export function useDebugLogs(): LogEntry[] {
+  const [logs, setLogs] = useState<LogEntry[]>([]);
+
+  useEffect(() => {
+    const unsubscribe = logger.subscribe((entries) => {
+      setLogs(entries);
+    });
+
+    return () => {
+      unsubscribe();
+    };
+  }, []);
+
+  return logs;
+}

package/src/hooks/useInputHistory.ts

@@ -0,0 +1,106 @@
+import { useState, useCallback, useEffect, useRef } from 'react';
+import { LongTermChatHistory } from '../utils/long-term-chat-history.js';
+
+export interface UseInputHistoryResult {
+  /** Current history value to display (null = user is typing fresh input) */
+  historyValue: string | null;
+  /** Navigate to older message (up arrow) */
+  navigateUp: () => void;
+  /** Navigate to newer message (down arrow) */
+  navigateDown: () => void;
+  /** Save a user message to history */
+  saveMessage: (message: string) => Promise<void>;
+  /** Update the agent response for the most recent conversation */
+  updateAgentResponse: (response: string) => Promise<void>;
+  /** Reset navigation back to typing mode */
+  resetNavigation: () => void;
+}
+
+/**
+ * Hook for managing input history navigation.
+ * Allows users to scroll through previous messages using up/down arrows.
+ * 
+ * Uses stack ordering (newest first) for O(1) access:
+ * - historyIndex = -1: User is typing (not navigating history)
+ * - historyIndex = 0: Most recent message
+ * - historyIndex = N: N messages back from most recent
+ */
+export function useInputHistory(): UseInputHistoryResult {
+  const storeRef = useRef<LongTermChatHistory>(new LongTermChatHistory());
+  const [messages, setMessages] = useState<string[]>([]);
+  const [historyIndex, setHistoryIndex] = useState<number>(-1);
+
+  // Load messages on mount
+  useEffect(() => {
+    const loadMessages = async () => {
+      await storeRef.current.load();
+      setMessages(storeRef.current.getMessageStrings());
+    };
+    loadMessages();
+  }, []);
+
+  // Navigate to older message (up arrow)
+  const navigateUp = useCallback(() => {
+    if (messages.length === 0) return;
+
+    setHistoryIndex(prev => {
+      const maxIndex = messages.length - 1;
+      if (prev === -1) {
+        // Start navigation from most recent
+        return 0;
+      } else if (prev < maxIndex) {
+        // Move to older message
+        return prev + 1;
+      }
+      // At oldest message, stay there
+      return prev;
+    });
+  }, [messages.length]);
+
+  // Navigate to newer message (down arrow)
+  const navigateDown = useCallback(() => {
+    setHistoryIndex(prev => {
+      if (prev === -1) {
+        // Already in typing mode, do nothing
+        return -1;
+      } else if (prev === 0) {
+        // At most recent, go back to typing mode
+        return -1;
+      } else {
+        // Move to newer message
+        return prev - 1;
+      }
+    });
+  }, []);
+
+  // Save a new user message to history
+  const saveMessage = useCallback(async (message: string) => {
+    await storeRef.current.addUserMessage(message);
+    setMessages(storeRef.current.getMessageStrings());
+  }, []);
+
+  // Update agent response for most recent conversation
+  const updateAgentResponse = useCallback(async (response: string) => {
+    await storeRef.current.updateAgentResponse(response);
+  }, []);
+
+  // Reset navigation to typing mode
+  const resetNavigation = useCallback(() => {
+    setHistoryIndex(-1);
+  }, []);
+
+  // Compute the current history value based on index
+  // Stack ordering: messages[0] is most recent, direct access
+  const historyValue = historyIndex === -1 
+    ? null 
+    : messages[historyIndex] ?? null;
+
+  return {
+    historyValue,
+    navigateUp,
+    navigateDown,
+    saveMessage,
+    updateAgentResponse,
+    resetNavigation,
+  };
+}