@alumbwe/anvil 1.0.42 → 1.0.49

package/vendor/@anvil/common/src/testing/mocks/tree-sitter.ts

@@ -1,127 +0,0 @@
-import { mock } from 'bun:test'
-
-export interface MockTreeNode {
-  text: string
-  type?: string
-  startPosition?: { row: number; column: number }
-  endPosition?: { row: number; column: number }
-  children?: MockTreeNode[]
-}
-
-export interface MockTree {
-  rootNode: MockTreeNode
-}
-
-export interface MockCapture {
-  name: string
-  node: MockTreeNode
-}
-
-export interface MockParser {
-  parse: (input: string) => MockTree | null
-}
-
-export interface MockQuery {
-  captures: (node: MockTreeNode) => MockCapture[]
-}
-
-export interface CreateMockParserOptions {
-  tree?: MockTree | null
-  parseImpl?: (input: string) => MockTree | null
-}
-
-export interface CreateMockQueryOptions {
-  captures?: MockCapture[]
-  capturesImpl?: (node: MockTreeNode) => MockCapture[]
-}
-
-export function createMockCapture(name: string, text: string): MockCapture {
-  return {
-    name,
-    node: { text },
-  }
-}
-
-export function createMockTreeSitterCaptures(
-  items: Array<{ name: string; text: string }>,
-): MockCapture[] {
-  return items.map(({ name, text }) => createMockCapture(name, text))
-}
-
-export function createMockTree(rootNodeText: string = 'mock tree'): MockTree {
-  return {
-    rootNode: { text: rootNodeText },
-  }
-}
-
-export function createMockTreeSitterParser(
-  options: CreateMockParserOptions = {},
-): MockParser {
-  const { tree, parseImpl } = options
-  const defaultTree = createMockTree()
-  const parseFn = parseImpl ?? (() => tree ?? defaultTree)
-
-  return {
-    parse: mock(parseFn),
-  }
-}
-
-export function createMockTreeSitterQuery(
-  options: CreateMockQueryOptions = {},
-): MockQuery {
-  const { captures = [], capturesImpl } = options
-  const capturesFn = capturesImpl ?? (() => captures)
-
-  return {
-    captures: mock(capturesFn),
-  }
-}
-
-export interface CreateMockLanguageConfigOptions {
-  extensions?: string[]
-  wasmFile?: string
-  queryText?: string
-  parser?: MockParser | null
-  query?: MockQuery | null
-  captures?: MockCapture[]
-  tree?: MockTree | null
-}
-
-export function createMockLanguageConfig(
-  options: CreateMockLanguageConfigOptions = {},
-): {
-  extensions: string[]
-  wasmFile: string
-  queryText: string
-  parser: MockParser | null
-  query: MockQuery | null
-} {
-  const {
-    extensions = ['.ts'],
-    wasmFile = 'tree-sitter-typescript.wasm',
-    queryText = 'mock query',
-    parser,
-    query,
-    captures,
-    tree,
-  } = options
-
-  const finalQuery =
-    query ??
-    (captures
-      ? createMockTreeSitterQuery({ captures })
-      : createMockTreeSitterQuery())
-  const finalParser =
-    parser ??
-    (tree !== undefined
-      ? createMockTreeSitterParser({ tree })
-      : createMockTreeSitterParser())
-
-  return {
-    extensions,
-    wasmFile,
-    queryText,
-    parser: finalParser,
-    query: finalQuery,
-  }
-}

package/vendor/@anvil/common/src/testing/setup.ts

@@ -1,282 +0,0 @@
-/**
- * Test setup utilities for common patterns.
- *
- * Provides helper functions for setting up and tearing down test fixtures
- * in a consistent way across the codebase.
- *
- * @example
- * ```typescript
- * import { createTestSetup, TestSetupResult } from '@anvil/common/testing/setup'
- *
- * describe('my test', () => {
- *   const setup = createTestSetup()
- *
- *   beforeEach(() => setup.beforeEach())
- *   afterEach(() => setup.afterEach())
- * })
- * ```
- */
-
-import { setupAnalyticsMocks } from './mocks/analytics'
-import { setupCryptoMocks } from './mocks/crypto'
-import { setupDbSpies } from './mocks/database'
-import { createMockLogger } from './mocks/logger'
-import { resetToolCallIdCounter } from './mocks/stream'
-
-import type {
-  AnalyticsSpies,
-  TrackEventFn,
-  FlushAnalyticsFn,
-} from './mocks/analytics'
-import type { CryptoMockSpies } from './mocks/crypto'
-import type { DbSpies } from './mocks/database'
-import type { MockLogger } from './mocks/logger'
-
-/**
- * Options for creating a test setup.
- */
-export interface CreateTestSetupOptions {
-  /**
-   * Whether to set up analytics mocks.
-   * @default true
-   */
-  analytics?: boolean
-
-  /**
-   * Whether to set up crypto mocks.
-   * @default true
-   */
-  crypto?: boolean
-
-  /**
-   * Whether to set up database mocks.
-   * Requires passing the db module.
-   * @default false
-   */
-  database?: boolean
-
-  /**
-   * The database module to mock (required if database is true).
-   * Must have insert and update methods that are functions.
-   */
-  dbModule?: {
-    insert: (...args: unknown[]) => unknown
-    update: (...args: unknown[]) => unknown
-  }
-
-  /**
-   * The analytics module to mock (required if analytics is true).
-   */
-  analyticsModule?: {
-    trackEvent: TrackEventFn
-    flushAnalytics: FlushAnalyticsFn
-  }
-
-  /**
-   * Prefix for crypto mock UUIDs.
-   * @default 'test'
-   */
-  cryptoPrefix?: string
-}
-
-/**
- * Result of creating a test setup.
- */
-export interface TestSetupResult {
-  /** The mock logger instance */
-  logger: MockLogger
-
-  /** Analytics spies (if enabled) */
-  analyticsSpy?: AnalyticsSpies
-
-  /** Crypto spies (if enabled) */
-  cryptoSpy?: CryptoMockSpies
-
-  /** Database spies (if enabled) */
-  dbSpy?: DbSpies
-
-  /** Call this in beforeEach */
-  beforeEach: () => void
-
-  /** Call this in afterEach */
-  afterEach: () => void
-
-  /** Restore all mocks */
-  restore: () => void
-}
-
-/**
- * Creates a test setup with common mocks pre-configured.
- *
- * @param options - Configuration options
- * @returns A test setup result with mocks and lifecycle methods
- *
- * @example
- * ```typescript
- * import * as analytics from '@anvil/common/analytics'
- * const db = createMockDbOperations()
- *
- * describe('my test', () => {
- *   const setup = createTestSetup({
- *     analytics: true,
- *     analyticsModule: analytics,
- *     database: true,
- *     dbModule: db,
- *   })
- *
- *   beforeEach(() => setup.beforeEach())
- *   afterEach(() => setup.afterEach())
- *
- *   it('does something', () => {
- *     expect(setup.analyticsSpy.trackEvent).toHaveBeenCalled()
- *   })
- * })
- * ```
- */
-export function createTestSetup(
-  options: CreateTestSetupOptions = {},
-): TestSetupResult {
-  const {
-    analytics = true,
-    crypto = true,
-    database = false,
-    dbModule,
-    analyticsModule,
-    cryptoPrefix = 'test',
-  } = options
-
-  const logger = createMockLogger()
-  let analyticsSpy: AnalyticsSpies | undefined
-  let cryptoSpy: CryptoMockSpies | undefined
-  let dbSpy: DbSpies | undefined
-
-  const beforeEach = (): void => {
-    // Reset tool call ID counter for deterministic tests
-    resetToolCallIdCounter()
-
-    // Set up analytics mocks
-    if (analytics && analyticsModule) {
-      analyticsSpy = setupAnalyticsMocks(analyticsModule)
-    }
-
-    // Set up crypto mocks
-    if (crypto) {
-      cryptoSpy = setupCryptoMocks({ prefix: cryptoPrefix, sequential: true })
-    }
-
-    // Set up database mocks
-    if (database && dbModule) {
-      dbSpy = setupDbSpies(dbModule)
-    }
-  }
-
-  const afterEach = (): void => {
-    // Restore all mocks
-    analyticsSpy?.restore()
-    cryptoSpy?.restore()
-    dbSpy?.restore()
-
-    // Reset the spies
-    analyticsSpy = undefined
-    cryptoSpy = undefined
-    dbSpy = undefined
-  }
-
-  const restore = afterEach
-
-  return {
-    logger,
-    get analyticsSpy() {
-      return analyticsSpy
-    },
-    get cryptoSpy() {
-      return cryptoSpy
-    },
-    get dbSpy() {
-      return dbSpy
-    },
-    beforeEach,
-    afterEach,
-    restore,
-  }
-}
-
-/**
- * A simple sleep function for async tests.
- *
- * @param ms - Milliseconds to sleep
- * @returns A promise that resolves after the specified time
- *
- * @example
- * ```typescript
- * await sleep(100) // Wait 100ms
- * ```
- */
-export function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms))
-}
-
-/**
- * Waits for a condition to be true, polling at the specified interval.
- *
- * @param condition - Function that returns true when the condition is met
- * @param timeout - Maximum time to wait in ms
- * @param interval - Polling interval in ms
- * @returns A promise that resolves when the condition is met
- * @throws Error if the timeout is reached
- *
- * @example
- * ```typescript
- * await waitFor(() => document.querySelector('.loaded') !== null)
- * ```
- */
-export async function waitFor(
-  condition: () => boolean | Promise<boolean>,
-  timeout: number = 5000,
-  interval: number = 50,
-): Promise<void> {
-  const start = Date.now()
-
-  while (Date.now() - start < timeout) {
-    const result = await condition()
-    if (result) {
-      return
-    }
-    await sleep(interval)
-  }
-
-  throw new Error(`waitFor timed out after ${timeout}ms`)
-}
-
-/**
- * Wraps a function to capture its call arguments.
- * Useful for verifying function calls in tests.
- *
- * @param fn - The function to wrap
- * @returns An object with the wrapped function and captured calls
- *
- * @example
- * ```typescript
- * const { fn, calls } = captureCallArgs((a: number, b: string) => a + b.length)
- *
- * fn(1, 'hello')
- * fn(2, 'world')
- *
- * expect(calls).toEqual([
- *   [1, 'hello'],
- *   [2, 'world'],
- * ])
- * ```
- */
-export function captureCallArgs<T extends unknown[], R>(
-  fn: (...args: T) => R,
-): { fn: (...args: T) => R; calls: T[] } {
-  const calls: T[] = []
-
-  const wrappedFn = (...args: T): R => {
-    calls.push(args)
-    return fn(...args)
-  }
-
-  return { fn: wrappedFn, calls }
-}

package/vendor/@anvil/common/src/tools/__tests__/compile-tool-definitions.test.ts

@@ -1,34 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import z from 'zod/v4'
-
-import { compileToolDefinitions } from '../compile-tool-definitions'
-
-// These tests feed synthetic schemas so they exercise the compile logic
-// directly and stay stable as real tools are added, removed, or reshaped.
-describe('compileToolDefinitions', () => {
-  test('emits gravity index action enum values', () => {
-    const definitions = compileToolDefinitions()
-
-    expect(definitions).toContain('export interface GravityIndexParams {')
-    expect(definitions).not.toContain('export type GravityIndexParams =')
-    expect(definitions).toContain(
-      '"action": "search" | "browse" | "list_categories" | "get_service" | "report_integration"',
-    )
-  })
-
-  test('keeps object tool schemas as interfaces', () => {
-    const objectSchema = z.object({ query: z.string() })
-    const definitions = compileToolDefinitions([
-      { name: 'web_search', inputSchema: objectSchema },
-    ])
-
-    expect(definitions).toContain('export interface WebSearchParams {')
-  })
-
-  test('compiles every published tool by default', () => {
-    const definitions = compileToolDefinitions()
-
-    expect(definitions).toContain('export type ToolName =')
-    expect(definitions).toContain('export interface ToolParamsMap {')
-  })
-})

package/vendor/@anvil/common/src/tools/params/__tests__/coerce-to-array.test.ts

@@ -1,213 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-import z from 'zod/v4'
-
-import {
-  coerceToArray,
-  coerceToObject,
-  normalizeReplacementAliases,
-} from '../utils'
-
-describe('coerceToArray', () => {
-  it('passes through arrays unchanged', () => {
-    expect(coerceToArray(['a', 'b'])).toEqual(['a', 'b'])
-    expect(coerceToArray([{ old: 'x', new: 'y' }])).toEqual([
-      { old: 'x', new: 'y' },
-    ])
-    expect(coerceToArray([])).toEqual([])
-  })
-
-  it('wraps a single string in an array', () => {
-    expect(coerceToArray('file.ts')).toEqual(['file.ts'])
-  })
-
-  it('wraps a single object in an array', () => {
-    expect(coerceToArray({ old: 'x', new: 'y' })).toEqual([
-      { old: 'x', new: 'y' },
-    ])
-  })
-
-  it('wraps a single number in an array', () => {
-    expect(coerceToArray(42)).toEqual([42])
-  })
-
-  it('parses a stringified JSON array', () => {
-    expect(coerceToArray('["file1.ts", "file2.ts"]')).toEqual([
-      'file1.ts',
-      'file2.ts',
-    ])
-  })
-
-  it('wraps a non-JSON string (does not parse as array)', () => {
-    expect(coerceToArray('not-json')).toEqual(['not-json'])
-  })
-
-  it('wraps a stringified JSON object (not an array) in an array', () => {
-    expect(coerceToArray('{"key": "value"}')).toEqual(['{"key": "value"}'])
-  })
-
-  it('passes through null', () => {
-    expect(coerceToArray(null)).toBeNull()
-  })
-
-  it('passes through undefined', () => {
-    expect(coerceToArray(undefined)).toBeUndefined()
-  })
-})
-
-describe('coerceToObject', () => {
-  it('passes through objects unchanged', () => {
-    expect(coerceToObject({ key: 'value' })).toEqual({ key: 'value' })
-  })
-
-  it('parses a stringified JSON object', () => {
-    expect(coerceToObject('{"key": "value"}')).toEqual({ key: 'value' })
-  })
-
-  it('leaves non-JSON strings untouched', () => {
-    expect(coerceToObject('not-json')).toBe('not-json')
-  })
-
-  it('passes through arrays and primitives so validation can reject them', () => {
-    expect(coerceToObject(['a'])).toEqual(['a'])
-    expect(coerceToObject(1)).toBe(1)
-  })
-})
-
-describe('coerceToArray with Zod schemas', () => {
-  it('coerces a single string into an array for z.array(z.string())', () => {
-    const schema = z.object({
-      paths: z.preprocess(coerceToArray, z.array(z.string())),
-    })
-    const result = schema.safeParse({ paths: 'file.ts' })
-    expect(result.success).toBe(true)
-    if (result.success) {
-      expect(result.data.paths).toEqual(['file.ts'])
-    }
-  })
-
-  it('coerces a single object into an array for z.array(z.object(...))', () => {
-    const schema = z.object({
-      replacements: z.preprocess(
-        coerceToArray,
-        z.array(z.object({ old: z.string(), new: z.string() })),
-      ),
-    })
-    const result = schema.safeParse({ replacements: { old: 'x', new: 'y' } })
-    expect(result.success).toBe(true)
-    if (result.success) {
-      expect(result.data.replacements).toEqual([{ old: 'x', new: 'y' }])
-    }
-  })
-
-  it('still validates correctly when already an array', () => {
-    const schema = z.object({
-      paths: z.preprocess(coerceToArray, z.array(z.string())),
-    })
-    const result = schema.safeParse({ paths: ['a.ts', 'b.ts'] })
-    expect(result.success).toBe(true)
-    if (result.success) {
-      expect(result.data.paths).toEqual(['a.ts', 'b.ts'])
-    }
-  })
-
-  it('still rejects invalid inner types after coercion', () => {
-    const schema = z.object({
-      paths: z.preprocess(coerceToArray, z.array(z.string())),
-    })
-    const result = schema.safeParse({ paths: 123 })
-    expect(result.success).toBe(false)
-  })
-
-  it('works with optional arrays', () => {
-    const schema = z.object({
-      paths: z.preprocess(coerceToArray, z.array(z.string())).optional(),
-    })
-    const withValue = schema.safeParse({ paths: 'file.ts' })
-    expect(withValue.success).toBe(true)
-    if (withValue.success) {
-      expect(withValue.data.paths).toEqual(['file.ts'])
-    }
-
-    const withoutValue = schema.safeParse({})
-    expect(withoutValue.success).toBe(true)
-    if (withoutValue.success) {
-      expect(withoutValue.data.paths).toBeUndefined()
-    }
-  })
-
-  it('produces identical JSON schema with or without preprocess', () => {
-    const plain = z.object({ paths: z.array(z.string()) })
-    const coerced = z.object({
-      paths: z.preprocess(coerceToArray, z.array(z.string())),
-    })
-
-    const plainSchema = z.toJSONSchema(plain, { io: 'input' })
-    const coercedSchema = z.toJSONSchema(coerced, { io: 'input' })
-    expect(coercedSchema).toEqual(plainSchema)
-  })
-})
-
-describe('coerceToObject with Zod schemas', () => {
-  it('produces identical JSON schema with or without preprocess', () => {
-    const plain = z.object({
-      params: z.record(z.string(), z.any()).optional(),
-    })
-    const coerced = z.object({
-      params: z
-        .preprocess(coerceToObject, z.record(z.string(), z.any()))
-        .optional(),
-    })
-
-    const plainSchema = z.toJSONSchema(plain, { io: 'input' })
-    const coercedSchema = z.toJSONSchema(coerced, { io: 'input' })
-    expect(coercedSchema).toEqual(plainSchema)
-  })
-})
-
-describe('normalizeReplacementAliases', () => {
-  it('maps old_str and new_str onto the documented replacement keys', () => {
-    expect(
-      normalizeReplacementAliases({
-        old_str: 'before',
-        new_str: 'after',
-        allowMultiple: true,
-      }),
-    ).toEqual({
-      old_str: 'before',
-      new_str: 'after',
-      oldString: 'before',
-      newString: 'after',
-      allowMultiple: true,
-    })
-  })
-
-  it('maps old_string and new_string onto the documented replacement keys', () => {
-    expect(
-      normalizeReplacementAliases({
-        old_string: 'before',
-        new_string: 'after',
-      }),
-    ).toEqual({
-      old_string: 'before',
-      new_string: 'after',
-      oldString: 'before',
-      newString: 'after',
-    })
-  })
-
-  it('does not overwrite documented replacement keys', () => {
-    expect(
-      normalizeReplacementAliases({
-        oldString: 'before',
-        newString: 'after',
-        old_str: 'ignored',
-        new_str: 'ignored',
-      }),
-    ).toEqual({
-      oldString: 'before',
-      newString: 'after',
-      old_str: 'ignored',
-      new_str: 'ignored',
-    })
-  })
-})

package/vendor/@anvil/common/src/tools/params/__tests__/read-docs.test.ts

@@ -1,47 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-
-import { readDocsParams } from '../tool/read-docs'
-
-describe('read_docs parameters', () => {
-  test('trims text inputs and defaults max_tokens', () => {
-    const result = readDocsParams.inputSchema.parse({
-      libraryTitle: '  React  ',
-      topic: '  hooks  ',
-    })
-
-    expect(result).toEqual({
-      libraryTitle: 'React',
-      topic: 'hooks',
-      max_tokens: 10_000,
-    })
-  })
-
-  test('rejects empty text and invalid token counts', () => {
-    expect(
-      readDocsParams.inputSchema.safeParse({
-        libraryTitle: '   ',
-        topic: 'hooks',
-      }).success,
-    ).toBe(false)
-    expect(
-      readDocsParams.inputSchema.safeParse({
-        libraryTitle: 'React',
-        topic: '   ',
-      }).success,
-    ).toBe(false)
-    expect(
-      readDocsParams.inputSchema.safeParse({
-        libraryTitle: 'React',
-        topic: 'hooks',
-        max_tokens: -1,
-      }).success,
-    ).toBe(false)
-    expect(
-      readDocsParams.inputSchema.safeParse({
-        libraryTitle: 'React',
-        topic: 'hooks',
-        max_tokens: 1.5,
-      }).success,
-    ).toBe(false)
-  })
-})