@alumbwe/anvil 1.0.20 → 1.0.22

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

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

@@ -0,0 +1,282 @@
+/**
+ * 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/testing-env-ci.ts

@@ -0,0 +1,15 @@
+import type { CiEnv } from './types/contracts/env'
+
+/**
+ * Test-only helpers for CI env snapshots.
+ * Keep production code using `@anvil/common/env-ci`.
+ */
+export const createTestCiEnv = (overrides: Partial<CiEnv> = {}): CiEnv => ({
+  CI: undefined,
+  GITHUB_ACTIONS: undefined,
+  RENDER: undefined,
+  IS_PULL_REQUEST: undefined,
+  ANVIL_GITHUB_TOKEN: undefined,
+  ANVIL_API_KEY: 'test-api-key',
+  ...overrides,
+})

package/vendor/@anvil/common/src/testing-env-process.ts

@@ -0,0 +1,78 @@
+import type { BaseEnv, ProcessEnv } from './types/contracts/env'
+
+/**
+ * Test-only helpers for process env snapshots.
+ * Keep production code using `@anvil/common/env-process`.
+ */
+export const createTestBaseEnv = (
+  overrides: Partial<BaseEnv> = {},
+): BaseEnv => ({
+  SHELL: undefined,
+  COMSPEC: undefined,
+  HOME: '/home/test',
+  USERPROFILE: undefined,
+  APPDATA: undefined,
+  XDG_CONFIG_HOME: undefined,
+  TERM: 'xterm-256color',
+  TERM_PROGRAM: undefined,
+  TERM_BACKGROUND: undefined,
+  TERMINAL_EMULATOR: undefined,
+  COLORFGBG: undefined,
+  NODE_ENV: 'test',
+  NODE_PATH: undefined,
+  PATH: '/usr/bin',
+  ...overrides,
+})
+
+export const createTestProcessEnv = (
+  overrides: Partial<ProcessEnv> = {},
+): ProcessEnv => ({
+  ...createTestBaseEnv(),
+
+  // Terminal-specific
+  KITTY_WINDOW_ID: undefined,
+  SIXEL_SUPPORT: undefined,
+  ZED_NODE_ENV: undefined,
+
+  // VS Code family detection
+  VSCODE_THEME_KIND: undefined,
+  VSCODE_COLOR_THEME_KIND: undefined,
+  VSCODE_GIT_IPC_HANDLE: undefined,
+  VSCODE_PID: undefined,
+  VSCODE_CWD: undefined,
+  VSCODE_NLS_CONFIG: undefined,
+
+  // Cursor editor detection
+  CURSOR_PORT: undefined,
+  CURSOR: undefined,
+
+  // JetBrains IDE detection
+  JETBRAINS_REMOTE_RUN: undefined,
+  IDEA_INITIAL_DIRECTORY: undefined,
+  IDE_CONFIG_DIR: undefined,
+  JB_IDE_CONFIG_DIR: undefined,
+
+  // Editor preferences
+  VISUAL: undefined,
+  EDITOR: undefined,
+  ANVIL_CLI_EDITOR: undefined,
+  ANVIL_EDITOR: undefined,
+
+  // Theme preferences
+  OPEN_TUI_THEME: undefined,
+  OPENTUI_THEME: undefined,
+
+  // Anvil CLI-specific
+  ANVIL_IS_BINARY: undefined,
+  ANVIL_CLI_VERSION: undefined,
+  ANVIL_CLI_TARGET: undefined,
+  ANVIL_RG_PATH: undefined,
+  ANVIL_WASM_DIR: undefined,
+
+  // Build/CI flags
+  VERBOSE: undefined,
+  OVERRIDE_TARGET: undefined,
+  OVERRIDE_PLATFORM: undefined,
+  OVERRIDE_ARCH: undefined,
+  ...overrides,
+})

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

@@ -0,0 +1,34 @@
+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/compile-tool-definitions.ts

@@ -0,0 +1,157 @@
+import z from 'zod/v4'
+
+import { publishedTools } from './constants'
+import { toolParams } from './list'
+
+/** A tool name plus the Zod schema describing its parameters. */
+export interface ToolSchemaEntry {
+  /** Snake_case tool name, e.g. 'web_search'. */
+  name: string
+  /** Zod schema for the tool's parameters. */
+  inputSchema: z.ZodType
+}
+
+/** The published tools and their parameter schemas, in published order. */
+function getPublishedToolEntries(): ToolSchemaEntry[] {
+  return publishedTools.map((toolName) => ({
+    name: toolName,
+    inputSchema: toolParams[toolName].inputSchema,
+  }))
+}
+
+/**
+ * Compiles tool definitions into a single TypeScript definition file content.
+ * This generates type definitions for the given tools and their parameters.
+ *
+ * Defaults to every published tool; callers (e.g. tests) may pass an explicit
+ * list to compile definitions for a specific set of schemas instead.
+ */
+export function compileToolDefinitions(
+  tools: ToolSchemaEntry[] = getPublishedToolEntries(),
+): string {
+  const toolInterfaces = tools
+    .map(({ name: toolName, inputSchema: parameterSchema }) => {
+      // Convert Zod schema to TypeScript interface using JSON schema
+      let typeDefinition: string
+      let jsonSchema: unknown
+      try {
+        jsonSchema = z.toJSONSchema(parameterSchema, { io: 'input' })
+        typeDefinition = jsonSchemaToTypeScript(jsonSchema)
+      } catch (error) {
+        console.warn(`Failed to convert schema for ${toolName}:`, error)
+        typeDefinition = '{ [key: string]: any }'
+      }
+
+      const typeName = `${toPascalCase(toolName)}Params`
+      const declaration = canEmitInterface(jsonSchema)
+        ? `export interface ${typeName} ${typeDefinition}`
+        : `export type ${typeName} = ${typeDefinition}`
+
+      return `/**
+ * ${parameterSchema.description || `Parameters for ${toolName} tool`}
+ */
+${declaration}`
+    })
+    .join('\n\n')
+
+  const toolUnion = tools.map(({ name }) => `'${name}'`).join(' | ')
+
+  const toolParamsMap = tools
+    .map(({ name }) => `  '${name}': ${toPascalCase(name)}Params`)
+    .join('\n')
+
+  return `/**
+ * Union type of all available tool names
+ */
+export type ToolName = ${toolUnion}
+
+/**
+ * Map of tool names to their parameter types
+ */
+export interface ToolParamsMap {
+${toolParamsMap}
+}
+
+${toolInterfaces}
+
+/**
+ * Get parameters type for a specific tool
+ */
+export type GetToolParams<T extends ToolName> = ToolParamsMap[T]
+`
+}
+
+/**
+ * Converts kebab-case to PascalCase
+ * e.g., 'write-file' -> 'WriteFile'
+ */
+function toPascalCase(str: string): string {
+  return str
+    .split(/[-_]/)
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+    .join('')
+}
+
+/**
+ * Converts JSON Schema to TypeScript interface definition
+ */
+function jsonSchemaToTypeScript(schema: any): string {
+  if (schema.type === 'object' && schema.properties) {
+    const properties = Object.entries(schema.properties).map(
+      ([key, prop]: [string, any]) => {
+        const isOptional = !schema.required?.includes(key)
+        const propType = getTypeFromJsonSchema(prop)
+        const comment = prop.description ? `  /** ${prop.description} */\n` : ''
+        return `${comment}  "${key}"${isOptional ? '?' : ''}: ${propType}`
+      },
+    )
+    return `{\n${properties.join('\n')}\n}`
+  }
+  return getTypeFromJsonSchema(schema)
+}
+
+function canEmitInterface(schema: any): boolean {
+  return (
+    schema.type === 'object' &&
+    !!schema.properties &&
+    !schema.anyOf &&
+    !schema.oneOf
+  )
+}
+
+/**
+ * Gets TypeScript type from JSON Schema property
+ */
+function getTypeFromJsonSchema(prop: any): string {
+  if (prop.const !== undefined) {
+    return JSON.stringify(prop.const)
+  }
+
+  if (prop.type === 'string') {
+    if (prop.enum) {
+      return prop.enum.map((v: string) => JSON.stringify(v)).join(' | ')
+    }
+    return 'string'
+  }
+  if (prop.type === 'number' || prop.type === 'integer') return 'number'
+  if (prop.type === 'boolean') return 'boolean'
+  if (prop.type === 'array') {
+    const itemType = prop.items ? getTypeFromJsonSchema(prop.items) : 'any'
+    return `${itemType}[]`
+  }
+  if (prop.type === 'object') {
+    if (prop.properties) {
+      return jsonSchemaToTypeScript(prop)
+    }
+    if (prop.additionalProperties) {
+      const valueType = getTypeFromJsonSchema(prop.additionalProperties)
+      return `Record<string, ${valueType}>`
+    }
+    return 'Record<string, any>'
+  }
+  if (prop.anyOf || prop.oneOf) {
+    const schemas = prop.anyOf || prop.oneOf
+    return schemas.map((s: any) => getTypeFromJsonSchema(s)).join(' | ')
+  }
+  return 'any'
+}