brownian-code 2026.2.10

package/src/utils/in-memory-chat-history.test.ts

@@ -0,0 +1,291 @@
+import { describe, test, expect, beforeEach, mock } from 'bun:test';
+
+// Mock callLlm before importing the module under test
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const mockCallLlm = mock(async (): Promise<any> => ({
+  response: 'mock summary',
+  usage: undefined,
+}));
+
+mock.module('../model/llm.js', () => ({
+  callLlm: mockCallLlm,
+  DEFAULT_MODEL: 'claude-sonnet-4-5',
+}));
+
+// Now import after mock is set up
+const { InMemoryChatHistory } = await import('./in-memory-chat-history.js');
+
+// ---------------------------------------------------------------------------
+// saveUserQuery
+// ---------------------------------------------------------------------------
+
+describe('saveUserQuery', () => {
+  test('adds a message with null answer and summary', () => {
+    const history = new InMemoryChatHistory();
+    history.saveUserQuery('What is BTC?');
+
+    const messages = history.getMessages();
+    expect(messages.length).toBe(1);
+    expect(messages[0].query).toBe('What is BTC?');
+    expect(messages[0].answer).toBeNull();
+    expect(messages[0].summary).toBeNull();
+  });
+
+  test('assigns sequential IDs', () => {
+    const history = new InMemoryChatHistory();
+    history.saveUserQuery('Query 1');
+    history.saveUserQuery('Query 2');
+
+    const messages = history.getMessages();
+    expect(messages[0].id).toBe(0);
+    expect(messages[1].id).toBe(1);
+  });
+
+  test('clears relevance cache on new query', async () => {
+    const history = new InMemoryChatHistory();
+    history.saveUserQuery('First query');
+    // Provide a completed answer so selectRelevantMessages works
+    mockCallLlm.mockResolvedValueOnce({ response: 'summary', usage: undefined });
+    await history.saveAnswer('Answer 1');
+
+    // Populate cache
+    mockCallLlm.mockResolvedValueOnce({
+      response: { message_ids: [0] },
+      usage: undefined,
+    });
+    await history.selectRelevantMessages('relevant?');
+
+    // New query should clear cache
+    history.saveUserQuery('Second query');
+
+    // Cache should be cleared — next selectRelevantMessages needs fresh LLM call
+    mockCallLlm.mockResolvedValueOnce({
+      response: { message_ids: [] },
+      usage: undefined,
+    });
+    const result = await history.selectRelevantMessages('relevant?');
+    // Won't return cached [0] — should use new LLM response
+    expect(mockCallLlm).toHaveBeenCalled();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// saveAnswer
+// ---------------------------------------------------------------------------
+
+describe('saveAnswer', () => {
+  beforeEach(() => {
+    mockCallLlm.mockClear();
+    mockCallLlm.mockResolvedValue({ response: 'generated summary', usage: undefined });
+  });
+
+  test('attaches answer to most recent query', async () => {
+    const history = new InMemoryChatHistory();
+    history.saveUserQuery('BTC price?');
+    await history.saveAnswer('$65,000');
+
+    const messages = history.getMessages();
+    expect(messages[0].answer).toBe('$65,000');
+  });
+
+  test('generates summary via LLM', async () => {
+    const history = new InMemoryChatHistory();
+    history.saveUserQuery('ETH analysis');
+    await history.saveAnswer('ETH is at $3500');
+
+    expect(mockCallLlm).toHaveBeenCalled();
+    const messages = history.getMessages();
+    expect(messages[0].summary).toBe('generated summary');
+  });
+
+  test('does nothing if no pending query', async () => {
+    const history = new InMemoryChatHistory();
+    // No saveUserQuery called
+    await history.saveAnswer('orphan answer');
+    expect(history.getMessages().length).toBe(0);
+  });
+
+  test('does nothing if answer already exists', async () => {
+    const history = new InMemoryChatHistory();
+    history.saveUserQuery('test');
+    await history.saveAnswer('first');
+    mockCallLlm.mockClear();
+    await history.saveAnswer('second');
+
+    // Should not have called LLM again
+    expect(mockCallLlm).not.toHaveBeenCalled();
+    expect(history.getMessages()[0].answer).toBe('first');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// selectRelevantMessages
+// ---------------------------------------------------------------------------
+
+describe('selectRelevantMessages', () => {
+  beforeEach(() => {
+    mockCallLlm.mockClear();
+  });
+
+  test('returns empty for no completed messages', async () => {
+    const history = new InMemoryChatHistory();
+    history.saveUserQuery('pending query');
+    // No saveAnswer — query is pending
+
+    const result = await history.selectRelevantMessages('anything');
+    expect(result).toEqual([]);
+  });
+
+  test('returns relevant messages selected by LLM', async () => {
+    const history = new InMemoryChatHistory();
+    history.saveUserQuery('BTC price');
+    mockCallLlm.mockResolvedValueOnce({ response: 'summary1', usage: undefined });
+    await history.saveAnswer('$65k');
+
+    history.saveUserQuery('ETH analysis');
+    mockCallLlm.mockResolvedValueOnce({ response: 'summary2', usage: undefined });
+    await history.saveAnswer('ETH strong');
+
+    // Mock the selection LLM call
+    mockCallLlm.mockResolvedValueOnce({
+      response: { message_ids: [0] },
+      usage: undefined,
+    });
+
+    const result = await history.selectRelevantMessages('What about BTC?');
+    expect(result.length).toBe(1);
+    expect(result[0].query).toBe('BTC price');
+  });
+
+  test('caches by query hash', async () => {
+    const history = new InMemoryChatHistory();
+    history.saveUserQuery('test');
+    mockCallLlm.mockResolvedValueOnce({ response: 'sum', usage: undefined });
+    await history.saveAnswer('answer');
+
+    mockCallLlm.mockResolvedValueOnce({
+      response: { message_ids: [0] },
+      usage: undefined,
+    });
+
+    await history.selectRelevantMessages('cached query');
+    mockCallLlm.mockClear();
+    // Second call with same query should use cache
+    const result = await history.selectRelevantMessages('cached query');
+    expect(mockCallLlm).not.toHaveBeenCalled();
+    expect(result.length).toBe(1);
+  });
+
+  test('returns empty on LLM failure', async () => {
+    const history = new InMemoryChatHistory();
+    history.saveUserQuery('test');
+    mockCallLlm.mockResolvedValueOnce({ response: 'sum', usage: undefined });
+    await history.saveAnswer('answer');
+
+    mockCallLlm.mockRejectedValueOnce(new Error('API error'));
+
+    const result = await history.selectRelevantMessages('failing query');
+    expect(result).toEqual([]);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// formatForPlanning
+// ---------------------------------------------------------------------------
+
+describe('formatForPlanning', () => {
+  test('formats messages with query + summary', () => {
+    const history = new InMemoryChatHistory();
+    const messages = [
+      { id: 0, query: 'BTC price', answer: '$65k', summary: 'BTC is $65k' },
+      { id: 1, query: 'ETH tvl', answer: '$50B', summary: 'ETH TVL is $50B' },
+    ];
+
+    const formatted = history.formatForPlanning(messages);
+    expect(formatted).toContain('User: BTC price');
+    expect(formatted).toContain('Assistant: BTC is $65k');
+    expect(formatted).toContain('User: ETH tvl');
+    expect(formatted).toContain('Assistant: ETH TVL is $50B');
+  });
+
+  test('returns empty string for empty array', () => {
+    const history = new InMemoryChatHistory();
+    expect(history.formatForPlanning([])).toBe('');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// formatForAnswerGeneration
+// ---------------------------------------------------------------------------
+
+describe('formatForAnswerGeneration', () => {
+  test('formats messages with query + full answer', () => {
+    const history = new InMemoryChatHistory();
+    const messages = [
+      { id: 0, query: 'What is SOL?', answer: 'SOL is Solana token', summary: 'SOL info' },
+    ];
+
+    const formatted = history.formatForAnswerGeneration(messages);
+    expect(formatted).toContain('User: What is SOL?');
+    expect(formatted).toContain('Assistant: SOL is Solana token');
+  });
+
+  test('returns empty string for empty array', () => {
+    const history = new InMemoryChatHistory();
+    expect(history.formatForAnswerGeneration([])).toBe('');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Utility methods
+// ---------------------------------------------------------------------------
+
+describe('utility methods', () => {
+  test('hasMessages returns false when empty', () => {
+    const history = new InMemoryChatHistory();
+    expect(history.hasMessages()).toBe(false);
+  });
+
+  test('hasMessages returns true when populated', () => {
+    const history = new InMemoryChatHistory();
+    history.saveUserQuery('test');
+    expect(history.hasMessages()).toBe(true);
+  });
+
+  test('getUserMessages returns queries in order', () => {
+    const history = new InMemoryChatHistory();
+    history.saveUserQuery('Q1');
+    history.saveUserQuery('Q2');
+    history.saveUserQuery('Q3');
+
+    expect(history.getUserMessages()).toEqual(['Q1', 'Q2', 'Q3']);
+  });
+
+  test('clear removes all messages and cache', async () => {
+    const history = new InMemoryChatHistory();
+    history.saveUserQuery('test');
+    mockCallLlm.mockResolvedValueOnce({ response: 'sum', usage: undefined });
+    await history.saveAnswer('answer');
+
+    history.clear();
+    expect(history.hasMessages()).toBe(false);
+    expect(history.getMessages()).toEqual([]);
+  });
+
+  test('setModel updates model', () => {
+    const history = new InMemoryChatHistory();
+    history.setModel('gpt-4o');
+    // No direct way to verify, but should not throw
+    expect(history).toBeDefined();
+  });
+
+  test('getMessages returns a copy', () => {
+    const history = new InMemoryChatHistory();
+    history.saveUserQuery('test');
+
+    const m1 = history.getMessages();
+    const m2 = history.getMessages();
+    expect(m1).not.toBe(m2);
+    expect(m1).toEqual(m2);
+  });
+});

package/src/utils/in-memory-chat-history.ts

@@ -0,0 +1,224 @@
+import { createHash } from 'crypto';
+import { callLlm, DEFAULT_MODEL } from '../model/llm.js';
+import { z } from 'zod';
+
+/**
+ * Represents a single conversation turn (query + answer + summary)
+ */
+export interface Message {
+  id: number;
+  query: string;
+  answer: string | null;   // null until answer completes
+  summary: string | null;  // LLM-generated summary, null until answer arrives
+}
+
+/**
+ * Schema for LLM to select relevant messages
+ */
+export const SelectedMessagesSchema = z.object({
+  message_ids: z.array(z.number()).describe('List of relevant message IDs (0-indexed)'),
+});
+
+/**
+ * System prompt for generating message summaries
+ */
+const MESSAGE_SUMMARY_SYSTEM_PROMPT = `You are a concise summarizer. Generate brief summaries of conversation answers.
+Keep summaries to 1-2 sentences that capture the key information.`;
+
+/**
+ * System prompt for selecting relevant messages
+ */
+const MESSAGE_SELECTION_SYSTEM_PROMPT = `You are a relevance evaluator. Select which previous conversation messages are relevant to the current query.
+Return only message IDs that contain information directly useful for answering the current query.`;
+
+/**
+ * Manages in-memory conversation history for multi-turn conversations.
+ * Stores user queries, final answers, and LLM-generated summaries.
+ */
+export class InMemoryChatHistory {
+  private messages: Message[] = [];
+  private model: string;
+  private relevantMessagesByQuery: Map<string, Message[]> = new Map();
+
+  constructor(model: string = DEFAULT_MODEL) {
+    this.model = model;
+  }
+
+  /**
+   * Hashes a query string for cache key generation
+   */
+  private hashQuery(query: string): string {
+    return createHash('md5').update(query).digest('hex').slice(0, 12);
+  }
+
+  /**
+   * Updates the model used for LLM calls (e.g., when user switches models)
+   */
+  setModel(model: string): void {
+    this.model = model;
+  }
+
+  /**
+   * Generates a brief summary of an answer for later relevance matching
+   */
+  private async generateSummary(query: string, answer: string): Promise<string> {
+    const answerPreview = answer.slice(0, 1500); // Limit for prompt size
+
+    const prompt = `Query: "${query}"
+Answer: "${answerPreview}"
+
+Generate a brief 1-2 sentence summary of this answer.`;
+
+    try {
+      const { response } = await callLlm(prompt, {
+        systemPrompt: MESSAGE_SUMMARY_SYSTEM_PROMPT,
+        model: this.model,
+      });
+      return typeof response === 'string' ? response.trim() : String(response).trim();
+    } catch {
+      // Fallback to a simple summary if LLM fails
+      return `Answer to: ${query.slice(0, 100)}`;
+    }
+  }
+
+  /**
+   * Saves a new user query to history immediately (before answer is available).
+   * Answer and summary are null until saveAnswer() is called with the answer.
+   */
+  saveUserQuery(query: string): void {
+    // Clear the relevance cache since message history has changed
+    this.relevantMessagesByQuery.clear();
+
+    this.messages.push({
+      id: this.messages.length,
+      query,
+      answer: null,
+      summary: null,
+    });
+  }
+
+  /**
+   * Saves the answer to the most recent message and generates a summary.
+   * Should be called when the agent completes answering.
+   */
+  async saveAnswer(answer: string): Promise<void> {
+    const lastMessage = this.messages[this.messages.length - 1];
+    if (!lastMessage || lastMessage.answer !== null) {
+      return; // No pending query or already has answer
+    }
+
+    lastMessage.answer = answer;
+    lastMessage.summary = await this.generateSummary(lastMessage.query, answer);
+  }
+
+  /**
+   * Uses LLM to select which messages are relevant to the current query.
+   * Results are cached by query hash to avoid redundant LLM calls within the same query.
+   * Only considers messages with completed answers for relevance selection.
+   */
+  async selectRelevantMessages(currentQuery: string): Promise<Message[]> {
+    // Only consider messages with completed answers
+    const completedMessages = this.messages.filter((m) => m.answer !== null);
+    if (completedMessages.length === 0) {
+      return [];
+    }
+
+    // Check cache first
+    const cacheKey = this.hashQuery(currentQuery);
+    const cached = this.relevantMessagesByQuery.get(cacheKey);
+    if (cached) {
+      return cached;
+    }
+
+    const messagesInfo = completedMessages.map((message) => ({
+      id: message.id,
+      query: message.query,
+      summary: message.summary,
+    }));
+
+    const prompt = `Current user query: "${currentQuery}"
+
+Previous conversations:
+${JSON.stringify(messagesInfo, null, 2)}
+
+Select which previous messages are relevant to understanding or answering the current query.`;
+
+    try {
+      const { response } = await callLlm(prompt, {
+        systemPrompt: MESSAGE_SELECTION_SYSTEM_PROMPT,
+        model: this.model,
+        outputSchema: SelectedMessagesSchema,
+      });
+
+      const selectedIds = (response as unknown as { message_ids: number[] }).message_ids || [];
+
+      const selectedMessages = selectedIds
+        .filter((idx) => idx >= 0 && idx < this.messages.length)
+        .map((idx) => this.messages[idx])
+        .filter((m) => m.answer !== null); // Ensure we only return completed messages
+
+      // Cache the result
+      this.relevantMessagesByQuery.set(cacheKey, selectedMessages);
+
+      return selectedMessages;
+    } catch {
+      // On failure, return empty (don't inject potentially irrelevant context)
+      return [];
+    }
+  }
+
+  /**
+   * Formats selected messages for task planning (queries + summaries only, lightweight)
+   */
+  formatForPlanning(messages: Message[]): string {
+    if (messages.length === 0) {
+      return '';
+    }
+
+    return messages
+      .map((message) => `User: ${message.query}\nAssistant: ${message.summary}`)
+      .join('\n\n');
+  }
+
+  /**
+   * Formats selected messages for answer generation (queries + full answers)
+   */
+  formatForAnswerGeneration(messages: Message[]): string {
+    if (messages.length === 0) {
+      return '';
+    }
+
+    return messages
+      .map((message) => `User: ${message.query}\nAssistant: ${message.answer}`)
+      .join('\n\n');
+  }
+
+  /**
+   * Returns all messages
+   */
+  getMessages(): Message[] {
+    return [...this.messages];
+  }
+
+  /**
+   * Returns user queries in chronological order (no LLM call)
+   */
+  getUserMessages(): string[] {
+    return this.messages.map((message) => message.query);
+  }
+
+  /**
+   * Returns true if there are any messages
+   */
+  hasMessages(): boolean {
+    return this.messages.length > 0;
+  }
+
+  /**
+   * Clears all messages and cache
+   */
+  clear(): void {
+    this.messages = [];
+    this.relevantMessagesByQuery.clear();
+  }
+}

package/src/utils/index.ts

@@ -0,0 +1,19 @@
+export { loadConfig, saveConfig, getSetting, setSetting } from './config.js';
+export {
+  getApiKeyNameForProvider,
+  getProviderDisplayName,
+  checkApiKeyExistsForProvider,
+  saveApiKeyForProvider,
+} from './env.js';
+export { InMemoryChatHistory } from './in-memory-chat-history.js';
+export { logger } from './logger.js';
+export type { LogEntry, LogLevel } from './logger.js';
+export { extractTextContent, hasToolCalls } from './ai-message.js';
+export { LongTermChatHistory } from './long-term-chat-history.js';
+export type { ConversationEntry } from './long-term-chat-history.js';
+export { findPrevWordStart, findNextWordEnd } from './text-navigation.js';
+export { cursorHandlers } from './input-key-handlers.js';
+export type { CursorContext } from './input-key-handlers.js';
+export { getToolDescription } from './tool-description.js';
+export { transformMarkdownTables, formatResponse } from './markdown-table.js';
+export { estimateTokens, TOKEN_BUDGET } from './tokens.js';

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

@@ -0,0 +1,155 @@
+import { describe, test, expect } from 'bun:test';
+import { cursorHandlers, type CursorContext } from './input-key-handlers.js';
+
+// Helper to create cursor context
+function ctx(text: string, cursorPosition: number): CursorContext {
+  return { text, cursorPosition };
+}
+
+// ---------------------------------------------------------------------------
+// moveLeft / moveRight
+// ---------------------------------------------------------------------------
+
+describe('moveLeft', () => {
+  test('moves one character left', () => {
+    expect(cursorHandlers.moveLeft(ctx('hello', 3))).toBe(2);
+  });
+
+  test('clamps at position 0', () => {
+    expect(cursorHandlers.moveLeft(ctx('hello', 0))).toBe(0);
+  });
+
+  test('moves from end of text', () => {
+    expect(cursorHandlers.moveLeft(ctx('hello', 5))).toBe(4);
+  });
+});
+
+describe('moveRight', () => {
+  test('moves one character right', () => {
+    expect(cursorHandlers.moveRight(ctx('hello', 3))).toBe(4);
+  });
+
+  test('clamps at text length', () => {
+    expect(cursorHandlers.moveRight(ctx('hello', 5))).toBe(5);
+  });
+
+  test('moves from position 0', () => {
+    expect(cursorHandlers.moveRight(ctx('hello', 0))).toBe(1);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// moveToLineStart / moveToLineEnd
+// ---------------------------------------------------------------------------
+
+describe('moveToLineStart', () => {
+  test('moves to start of single line', () => {
+    expect(cursorHandlers.moveToLineStart(ctx('hello world', 6))).toBe(0);
+  });
+
+  test('moves to start of second line', () => {
+    expect(cursorHandlers.moveToLineStart(ctx('hello\nworld', 8))).toBe(6);
+  });
+
+  test('no-op when already at line start', () => {
+    expect(cursorHandlers.moveToLineStart(ctx('hello\nworld', 6))).toBe(6);
+  });
+});
+
+describe('moveToLineEnd', () => {
+  test('moves to end of single line', () => {
+    expect(cursorHandlers.moveToLineEnd(ctx('hello world', 3))).toBe(11);
+  });
+
+  test('moves to end of first line (before newline)', () => {
+    expect(cursorHandlers.moveToLineEnd(ctx('hello\nworld', 2))).toBe(5);
+  });
+
+  test('moves to end of last line', () => {
+    expect(cursorHandlers.moveToLineEnd(ctx('hello\nworld', 8))).toBe(11);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// moveUp / moveDown
+// ---------------------------------------------------------------------------
+
+describe('moveUp', () => {
+  test('returns null on single line (signals history navigation)', () => {
+    expect(cursorHandlers.moveUp(ctx('hello', 3))).toBeNull();
+  });
+
+  test('returns null on first line of multi-line', () => {
+    expect(cursorHandlers.moveUp(ctx('hello\nworld', 3))).toBeNull();
+  });
+
+  test('moves to previous line maintaining column', () => {
+    // "hello\nworld", cursor at position 8 (col 2 of line 1)
+    // Should move to position 2 (col 2 of line 0)
+    const result = cursorHandlers.moveUp(ctx('hello\nworld', 8));
+    expect(result).toBe(2);
+  });
+
+  test('clamps column when previous line is shorter', () => {
+    // "hi\nworld", cursor at position 7 (col 4 of line 1)
+    // Line 0 has length 2, should clamp to position 2
+    const result = cursorHandlers.moveUp(ctx('hi\nworld', 7));
+    expect(result).toBe(2);
+  });
+});
+
+describe('moveDown', () => {
+  test('returns null on single line', () => {
+    expect(cursorHandlers.moveDown(ctx('hello', 3))).toBeNull();
+  });
+
+  test('returns null on last line of multi-line', () => {
+    expect(cursorHandlers.moveDown(ctx('hello\nworld', 8))).toBeNull();
+  });
+
+  test('moves to next line maintaining column', () => {
+    // "hello\nworld", cursor at position 2 (col 2 of line 0)
+    // Should move to position 8 (col 2 of line 1)
+    const result = cursorHandlers.moveDown(ctx('hello\nworld', 2));
+    expect(result).toBe(8);
+  });
+
+  test('clamps column when next line is shorter', () => {
+    // "world\nhi", cursor at position 4 (col 4 of line 0)
+    // Line 1 has length 2, should clamp to position 8 (6+2)
+    const result = cursorHandlers.moveDown(ctx('world\nhi', 4));
+    expect(result).toBe(8);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// moveWordBackward / moveWordForward
+// ---------------------------------------------------------------------------
+
+describe('moveWordBackward', () => {
+  test('moves to start of previous word', () => {
+    expect(cursorHandlers.moveWordBackward(ctx('hello world', 8))).toBe(6);
+  });
+
+  test('moves from end of text to start of last word', () => {
+    expect(cursorHandlers.moveWordBackward(ctx('hello world', 11))).toBe(6);
+  });
+
+  test('returns 0 at beginning', () => {
+    expect(cursorHandlers.moveWordBackward(ctx('hello', 0))).toBe(0);
+  });
+});
+
+describe('moveWordForward', () => {
+  test('moves to end of current word', () => {
+    expect(cursorHandlers.moveWordForward(ctx('hello world', 0))).toBe(5);
+  });
+
+  test('moves from space to end of next word', () => {
+    expect(cursorHandlers.moveWordForward(ctx('hello world', 5))).toBe(11);
+  });
+
+  test('returns text length at end', () => {
+    expect(cursorHandlers.moveWordForward(ctx('hello', 5))).toBe(5);
+  });
+});