@alumbwe/anvil 1.0.20 → 1.0.22

package/vendor/@anvil/common/src/testing/mocks/index.ts

@@ -0,0 +1,101 @@
+/**
+ * Mock utilities index.
+ *
+ * Re-exports all mock factories for convenient importing.
+ */
+
+export {
+  createMockLogger,
+  createMockLoggerWithCapture,
+  restoreMockLogger,
+  clearMockLogger,
+} from './logger'
+export type {
+  LogLevel,
+  LogMethod,
+  MockLogMethod,
+  MockLogger,
+  CreateMockLoggerOptions,
+  CapturedLogEntry,
+  MockLoggerWithCapture,
+} from './logger'
+
+export {
+  createMockAnalytics,
+  createMockAnalyticsWithCapture,
+  setupAnalyticsMocks,
+  restoreMockAnalytics,
+} from './analytics'
+export type {
+  MockAnalytics,
+  MockAnalyticsWithCapture,
+  AnalyticsSpies,
+  CreateMockAnalyticsOptions,
+  TrackedEvent,
+  EventProperties,
+} from './analytics'
+
+export { createMockDbOperations, setupDbSpies } from './database'
+export type { MockDbOperations, DbSpies, CreateMockDbOptions } from './database'
+
+export { setupCryptoMocks, createMockUuid, TEST_UUIDS } from './crypto'
+export type { CryptoMockSpies, UUID, SetupCryptoMocksOptions } from './crypto'
+export { createUuidGenerator, setupSequentialCryptoMocks } from './crypto'
+
+export {
+  createToolCallChunk,
+  createMockStream,
+  createMockTextStream,
+} from './stream'
+
+export { createMockTimers, installMockTimers } from './timers'
+export type { PendingTimer, MockTimers } from './timers'
+
+export { createMockFs, restoreMockFs, clearMockFs } from './filesystem'
+export type { MockFs, MockFsWithMocks, CreateMockFsOptions } from './filesystem'
+
+export {
+  createMockFetch,
+  installMockFetch,
+  mockJsonResponse,
+  mockTextResponse,
+  mockErrorResponse,
+} from './fetch'
+export type {
+  MockFetch,
+  MockFetchCall,
+  MockResponseOptions,
+  CreateMockFetchOptions,
+  InstallMockFetchResult,
+} from './fetch'
+
+export {
+  createMockCapture,
+  createMockTreeSitterCaptures,
+  createMockTree,
+  createMockTreeSitterParser,
+  createMockTreeSitterQuery,
+  createMockLanguageConfig,
+} from './tree-sitter'
+export type {
+  MockTreeNode,
+  MockTree,
+  MockCapture,
+  MockParser,
+  MockQuery,
+  CreateMockParserOptions,
+  CreateMockQueryOptions,
+  CreateMockLanguageConfigOptions,
+} from './tree-sitter'
+
+export {
+  createMockChildProcess,
+  createMockSpawn,
+  asCodeSearchResult,
+  createRgJsonMatch,
+  createRgJsonContext,
+} from './child-process'
+export type {
+  MockChildProcess,
+  CodeSearchResult,
+} from './child-process'

package/vendor/@anvil/common/src/testing/mocks/logger.ts

@@ -0,0 +1,135 @@
+import { mock } from 'bun:test'
+
+import type { Mock } from 'bun:test'
+
+export type LogLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal'
+
+export type LogMethod = (
+  data: unknown,
+  msg?: string,
+  ...args: unknown[]
+) => unknown
+
+export type MockLogMethod = Mock<LogMethod>
+
+export interface MockLogger {
+  trace: MockLogMethod
+  debug: MockLogMethod
+  info: MockLogMethod
+  warn: MockLogMethod
+  error: MockLogMethod
+  fatal: MockLogMethod
+  child: Mock<(bindings: Record<string, unknown>) => MockLogger>
+}
+
+export interface CreateMockLoggerOptions {
+  captureOutput?: boolean
+  customImplementations?: Partial<Record<LogLevel, LogMethod>>
+}
+
+export interface CapturedLogEntry {
+  level: LogLevel
+  message: string
+  meta?: Record<string, unknown>
+  timestamp: Date
+}
+
+export function createMockLogger(
+  options: CreateMockLoggerOptions = {},
+): MockLogger {
+  const { customImplementations = {} } = options
+
+  const createLogMethod = (level: LogLevel): MockLogMethod => {
+    const customImpl = customImplementations[level]
+    if (customImpl) {
+      return mock(customImpl)
+    }
+    return mock(() => {})
+  }
+
+  const mockLogger: MockLogger = {
+    trace: createLogMethod('trace'),
+    debug: createLogMethod('debug'),
+    info: createLogMethod('info'),
+    warn: createLogMethod('warn'),
+    error: createLogMethod('error'),
+    fatal: createLogMethod('fatal'),
+    child: mock(() => createMockLogger(options)),
+  }
+
+  return mockLogger
+}
+
+export interface MockLoggerWithCapture {
+  logger: MockLogger
+  captured: CapturedLogEntry[]
+  clearCaptured: () => void
+  getByLevel: (level: LogLevel) => CapturedLogEntry[]
+  getByMessage: (pattern: string | RegExp) => CapturedLogEntry[]
+}
+
+/** Creates a mock logger that captures all output for inspection. */
+export function createMockLoggerWithCapture(): MockLoggerWithCapture {
+  const captured: CapturedLogEntry[] = []
+
+  const createCapturingLogMethod = (level: LogLevel): MockLogMethod => {
+    return mock((data: unknown, msg?: string) => {
+      const message = typeof data === 'string' ? data : (msg ?? String(data))
+      const meta =
+        typeof data === 'object' && data !== null
+          ? (data as Record<string, unknown>)
+          : undefined
+      captured.push({
+        level,
+        message,
+        meta,
+        timestamp: new Date(),
+      })
+    })
+  }
+
+  const logger: MockLogger = {
+    trace: createCapturingLogMethod('trace'),
+    debug: createCapturingLogMethod('debug'),
+    info: createCapturingLogMethod('info'),
+    warn: createCapturingLogMethod('warn'),
+    error: createCapturingLogMethod('error'),
+    fatal: createCapturingLogMethod('fatal'),
+    child: mock(() => createMockLoggerWithCapture().logger),
+  }
+
+  return {
+    logger,
+    captured,
+    clearCaptured: () => {
+      captured.length = 0
+    },
+    getByLevel: (level: LogLevel) => captured.filter((e) => e.level === level),
+    getByMessage: (pattern: string | RegExp) =>
+      captured.filter((e) =>
+        typeof pattern === 'string'
+          ? e.message.includes(pattern)
+          : pattern.test(e.message),
+      ),
+  }
+}
+
+export function restoreMockLogger(logger: MockLogger): void {
+  logger.trace.mockRestore()
+  logger.debug.mockRestore()
+  logger.info.mockRestore()
+  logger.warn.mockRestore()
+  logger.error.mockRestore()
+  logger.fatal.mockRestore()
+  logger.child.mockRestore()
+}
+
+export function clearMockLogger(logger: MockLogger): void {
+  logger.trace.mockClear()
+  logger.debug.mockClear()
+  logger.info.mockClear()
+  logger.warn.mockClear()
+  logger.error.mockClear()
+  logger.fatal.mockClear()
+  logger.child.mockClear()
+}

package/vendor/@anvil/common/src/testing/mocks/stream.ts

@@ -0,0 +1,313 @@
+/**
+ * Typed stream mock factory for testing LLM streaming.
+ *
+ * Provides type-safe utilities for creating mock LLM streams
+ * and testing streaming behavior.
+ *
+ * @example
+ * ```typescript
+ * import { createMockStream, createToolCallChunk } from '@anvil/common/testing/mocks/stream'
+ *
+ * // Create a mock stream with text and tool calls
+ * const stream = createMockStream([
+ *   { type: 'text', text: 'Hello ' },
+ *   { type: 'text', text: 'world!' },
+ *   createToolCallChunk('end_turn', {}),
+ * ])
+ *
+ * // Use in tests
+ * for await (const chunk of stream) {
+ *   console.log(chunk)
+ * }
+ * ```
+ */
+
+import { mock } from 'bun:test'
+
+import type { Mock } from 'bun:test'
+
+/**
+ * A text chunk from an LLM stream.
+ */
+export interface TextChunk {
+  type: 'text'
+  text: string
+  agentId?: string
+}
+
+/**
+ * A tool call chunk from an LLM stream.
+ */
+export interface ToolCallChunk {
+  type: 'tool-call'
+  toolName: string
+  toolCallId: string
+  input: Record<string, unknown>
+}
+
+/**
+ * A reasoning chunk from an LLM stream.
+ */
+export interface ReasoningChunk {
+  type: 'reasoning'
+  text: string
+}
+
+/**
+ * Union of all stream chunk types.
+ */
+export type StreamChunk = TextChunk | ToolCallChunk | ReasoningChunk
+
+/**
+ * Options for creating a tool call chunk.
+ */
+export interface CreateToolCallOptions {
+  /**
+   * Custom tool call ID. If not provided, a random one is generated.
+   */
+  toolCallId?: string
+}
+
+let toolCallIdCounter = 0
+
+/**
+ * Creates a tool call chunk for testing.
+ *
+ * @param toolName - The name of the tool being called
+ * @param input - The input parameters for the tool
+ * @param options - Additional options
+ * @returns A properly typed tool call chunk
+ *
+ * @example
+ * ```typescript
+ * const chunk = createToolCallChunk('read_files', { paths: ['file.ts'] })
+ * // { type: 'tool-call', toolName: 'read_files', toolCallId: 'tool-call-1', input: { paths: ['file.ts'] } }
+ * ```
+ */
+export function createToolCallChunk(
+  toolName: string,
+  input: Record<string, unknown>,
+  options: CreateToolCallOptions = {},
+): ToolCallChunk {
+  const { toolCallId = `tool-call-${++toolCallIdCounter}` } = options
+  return {
+    type: 'tool-call',
+    toolName,
+    toolCallId,
+    input,
+  }
+}
+
+/**
+ * Creates a text chunk for testing.
+ *
+ * @param text - The text content
+ * @param agentId - Optional agent ID for subagent chunks
+ * @returns A text chunk
+ *
+ * @example
+ * ```typescript
+ * const chunk = createTextChunk('Hello world!')
+ * // { type: 'text', text: 'Hello world!' }
+ * ```
+ */
+export function createTextChunk(text: string, agentId?: string): TextChunk {
+  const chunk: TextChunk = { type: 'text', text }
+  if (agentId) {
+    chunk.agentId = agentId
+  }
+  return chunk
+}
+
+/**
+ * Creates a reasoning chunk for testing.
+ *
+ * @param text - The reasoning text
+ * @returns A reasoning chunk
+ */
+export function createReasoningChunk(text: string): ReasoningChunk {
+  return { type: 'reasoning', text }
+}
+
+/**
+ * Creates a mock async generator that yields the provided chunks.
+ *
+ * @param chunks - The chunks to yield
+ * @param returnValue - The value to return when the generator completes
+ * @returns An async generator that yields the chunks
+ *
+ * @example
+ * ```typescript
+ * const stream = createMockStream([
+ *   createTextChunk('Processing...'),
+ *   createToolCallChunk('read_files', { paths: ['test.ts'] }),
+ *   createTextChunk('Done!'),
+ *   createToolCallChunk('end_turn', {}),
+ * ])
+ *
+ * // Consume the stream
+ * const chunks = []
+ * for await (const chunk of stream) {
+ *   chunks.push(chunk)
+ * }
+ * ```
+ */
+export function createMockStream(
+  chunks: StreamChunk[],
+  returnValue: string | null = 'mock-message-id',
+): AsyncGenerator<StreamChunk, string | null, undefined> {
+  async function* generator(): AsyncGenerator<
+    StreamChunk,
+    string | null,
+    undefined
+  > {
+    for (const chunk of chunks) {
+      yield chunk
+    }
+    return returnValue
+  }
+  return generator()
+}
+
+/**
+ * Creates a mock stream that yields text in multiple chunks.
+ * Useful for testing streaming text display.
+ *
+ * @param text - The complete text to stream
+ * @param chunkSize - Size of each chunk
+ * @param endWithTool - Whether to end with an end_turn tool call
+ * @returns A mock stream
+ *
+ * @example
+ * ```typescript
+ * const stream = createMockTextStream('Hello world!', 3)
+ * // Yields: 'Hel', 'lo ', 'wor', 'ld!'
+ * ```
+ */
+export function createMockTextStream(
+  text: string,
+  chunkSize: number = 10,
+  endWithTool: boolean = true,
+): AsyncGenerator<StreamChunk, string | null, undefined> {
+  const chunks: StreamChunk[] = []
+
+  for (let i = 0; i < text.length; i += chunkSize) {
+    chunks.push(createTextChunk(text.slice(i, i + chunkSize)))
+  }
+
+  if (endWithTool) {
+    chunks.push(createToolCallChunk('end_turn', {}))
+  }
+
+  return createMockStream(chunks)
+}
+
+/**
+ * Options for creating a mock prompt function.
+ */
+export interface MockPromptOptions {
+  /**
+   * Default response text.
+   */
+  defaultResponse?: string
+
+  /**
+   * Whether to include an end_turn tool call.
+   */
+  includeEndTurn?: boolean
+
+  /**
+   * Custom chunks to yield.
+   */
+  chunks?: StreamChunk[]
+}
+
+/**
+ * Mock prompt function result type.
+ */
+export type MockPromptFn = Mock<
+  (
+    params: Record<string, unknown>,
+  ) => AsyncGenerator<StreamChunk, string | null>
+>
+
+/**
+ * Creates a mock promptAiSdkStream function for testing.
+ *
+ * @param options - Configuration options
+ * @returns A mock function that returns streams
+ *
+ * @example
+ * ```typescript
+ * const mockPrompt = createMockPromptAiSdkStream({
+ *   defaultResponse: 'I understand your request.',
+ * })
+ *
+ * loopAgentStepsBaseParams.promptAiSdkStream = mockPrompt
+ *
+ * await loopAgentSteps({ ...params })
+ *
+ * expect(mockPrompt).toHaveBeenCalledTimes(1)
+ * ```
+ */
+export function createMockPromptAiSdkStream(
+  options: MockPromptOptions = {},
+): MockPromptFn {
+  const {
+    defaultResponse = 'Mock response\n\n',
+    includeEndTurn = true,
+    chunks,
+  } = options
+
+  return mock(async function* () {
+    if (chunks) {
+      for (const chunk of chunks) {
+        yield chunk
+      }
+    } else {
+      yield createTextChunk(defaultResponse)
+      if (includeEndTurn) {
+        yield createToolCallChunk('end_turn', {})
+      }
+    }
+    return 'mock-message-id'
+  })
+}
+
+/**
+ * Collects all chunks from a stream into an array.
+ * Useful for testing stream content.
+ *
+ * @param stream - The stream to collect from
+ * @returns An array of all chunks and the return value
+ *
+ * @example
+ * ```typescript
+ * const stream = createMockStream([...])
+ * const { chunks, returnValue } = await collectStreamChunks(stream)
+ *
+ * expect(chunks).toHaveLength(3)
+ * expect(returnValue).toBe('mock-message-id')
+ * ```
+ */
+export async function collectStreamChunks<T, R>(
+  stream: AsyncGenerator<T, R, undefined>,
+): Promise<{ chunks: T[]; returnValue: R }> {
+  const chunks: T[] = []
+
+  let result = await stream.next()
+  while (!result.done) {
+    chunks.push(result.value)
+    result = await stream.next()
+  }
+
+  return { chunks, returnValue: result.value }
+}
+
+/**
+ * Resets the tool call ID counter.
+ * Call this in beforeEach to ensure deterministic IDs.
+ */
+export function resetToolCallIdCounter(): void {
+  toolCallIdCounter = 0
+}

package/vendor/@anvil/common/src/testing/mocks/timers.ts

@@ -0,0 +1,132 @@
+/**
+ * @deprecated Use Bun's built-in mock.setSystemTime() instead.
+ */
+
+export interface PendingTimer {
+  id: number
+  ms: number
+  fn: () => void
+  active: boolean
+  createdAt: number
+}
+
+export interface MockTimers {
+  setTimeout: typeof globalThis.setTimeout
+  clearTimeout: typeof globalThis.clearTimeout
+  install: () => void
+  restore: () => void
+  runAll: () => void
+  advanceBy: (ms: number) => void
+  getPending: () => PendingTimer[]
+  getPendingCount: () => number
+  clearAll: () => void
+  isPending: (id: number) => boolean
+  getNext: () => PendingTimer | undefined
+}
+
+/** @deprecated Use Bun's built-in mock.setSystemTime() instead. */
+export function createMockTimers(): MockTimers {
+  const pendingTimers: PendingTimer[] = []
+  let nextId = 1
+  let currentTime = 0
+
+  const originalSetTimeout = globalThis.setTimeout
+  const originalClearTimeout = globalThis.clearTimeout
+
+  const mockSetTimeout = ((fn: () => void, ms?: number): number => {
+    const id = nextId++
+    pendingTimers.push({
+      id,
+      ms: Number(ms ?? 0),
+      fn,
+      active: true,
+      createdAt: currentTime,
+    })
+    return id
+  }) as typeof globalThis.setTimeout
+
+  const mockClearTimeout = ((id?: number): void => {
+    if (id === undefined) return
+    const timer = pendingTimers.find((t) => t.id === id)
+    if (timer) {
+      timer.active = false
+    }
+  }) as typeof globalThis.clearTimeout
+
+  const getActivePending = (): PendingTimer[] => {
+    return pendingTimers.filter((t) => t.active)
+  }
+
+  return {
+    setTimeout: mockSetTimeout,
+    clearTimeout: mockClearTimeout,
+
+    install(): void {
+      globalThis.setTimeout = mockSetTimeout
+      globalThis.clearTimeout = mockClearTimeout
+    },
+
+    restore(): void {
+      globalThis.setTimeout = originalSetTimeout
+      globalThis.clearTimeout = originalClearTimeout
+      pendingTimers.length = 0
+      nextId = 1
+      currentTime = 0
+    },
+
+    runAll(): void {
+      const active = getActivePending()
+      for (const timer of active) {
+        if (timer.active) {
+          timer.active = false
+          timer.fn()
+        }
+      }
+    },
+
+    advanceBy(ms: number): void {
+      currentTime += ms
+      const active = getActivePending()
+        .filter((t) => t.createdAt + t.ms <= currentTime)
+        .sort((a, b) => a.createdAt + a.ms - (b.createdAt + b.ms))
+
+      for (const timer of active) {
+        if (timer.active) {
+          timer.active = false
+          timer.fn()
+        }
+      }
+    },
+
+    getPending(): PendingTimer[] {
+      return getActivePending()
+    },
+
+    getPendingCount(): number {
+      return getActivePending().length
+    },
+
+    clearAll(): void {
+      for (const timer of pendingTimers) {
+        timer.active = false
+      }
+    },
+
+    isPending(id: number): boolean {
+      return pendingTimers.some((t) => t.id === id && t.active)
+    },
+
+    getNext(): PendingTimer | undefined {
+      return getActivePending().sort(
+        (a, b) => a.createdAt + a.ms - (b.createdAt + b.ms),
+      )[0]
+    },
+  }
+}
+
+/** @deprecated Use Bun's built-in mock.setSystemTime() instead. */
+export function installMockTimers(): MockTimers {
+  const timers = createMockTimers()
+  timers.install()
+  return timers
+}