@alumbwe/anvil 1.0.42 → 1.0.49

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

@@ -1,101 +0,0 @@
-/**
- * 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

@@ -1,135 +0,0 @@
-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

@@ -1,313 +0,0 @@
-/**
- * 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

@@ -1,132 +0,0 @@
-/**
- * @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
-}