@alumbwe/anvil 1.0.0 → 1.0.2

package/src/__tests__/test-utils.ts

@@ -1,271 +0,0 @@
-import { execSync } from 'child_process'
-import fs from 'fs'
-import path from 'path'
-
-/**
- * Check if tmux is available and usable on the system.
- * This checks both that tmux is installed AND that it can actually run
- * (e.g., the tmux server socket directory exists and is accessible).
- *
- * Returns false on CI unless ANVIL_RUN_TMUX_TESTS=1 explicitly opts into
- * running deterministic tmux tests in a known terminal environment.
- */
-export function isTmuxAvailable(): boolean {
-  // Skip on CI - tmux integration tests need a real terminal environment
-  if (
-    (process.env.CI === 'true' || process.env.CI === '1') &&
-    process.env.ANVIL_RUN_TMUX_TESTS !== '1'
-  ) {
-    return false
-  }
-
-  try {
-    // First check if tmux is installed
-    execSync('which tmux', { stdio: 'pipe' })
-    // Then verify tmux can actually run by creating and killing a test session
-    // This will fail if tmux server can't start (e.g., no socket directory on CI)
-    execSync('tmux new-session -d -s __anvil_tmux_check__ && tmux kill-session -t __anvil_tmux_check__', {
-      stdio: 'pipe',
-      timeout: 5000,
-    })
-    return true
-  } catch {
-    return false
-  }
-}
-
-/**
- * Check if the SDK is built by checking for the dist directory
- */
-export function isSDKBuilt(): boolean {
-  try {
-    const sdkDistDir = path.join(__dirname, '../../../sdk/dist')
-    const possibleArtifacts = ['index.js', 'index.mjs', 'index.cjs']
-    return possibleArtifacts.some((file) =>
-      fs.existsSync(path.join(sdkDistDir, file)),
-    )
-  } catch {
-    return false
-  }
-}
-
-/**
- * Sleep utility for async delays
- */
-export const sleep = (ms: number) =>
-  new Promise((resolve) => setTimeout(resolve, ms))
-
-let cachedEnv: Record<string, string> | null = null
-
-const TEST_CLIENT_ENV_DEFAULTS: Record<string, string> = {
-  NEXT_PUBLIC_CB_ENVIRONMENT: 'test',
-  NEXT_PUBLIC_ANVIL_APP_URL: 'http://localhost:3000',
-  NEXT_PUBLIC_SUPPORT_EMAIL: 'support@codebuff.com',
-  NEXT_PUBLIC_POSTHOG_API_KEY: 'test-posthog-key',
-  NEXT_PUBLIC_POSTHOG_HOST_URL: 'https://us.i.posthog.com',
-  NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY: 'pk_test_placeholder',
-  NEXT_PUBLIC_STRIPE_CUSTOMER_PORTAL:
-    'https://billing.stripe.com/p/login/test_placeholder',
-  NEXT_PUBLIC_GOOGLE_SITE_VERIFICATION_ID: 'test-verification',
-  NEXT_PUBLIC_WEB_PORT: '3000',
-}
-const TEST_SERVER_ENV_DEFAULTS: Record<string, string> = {
-  OPEN_ROUTER_API_KEY: 'test',
-  OPENAI_API_KEY: 'test',
-  ANTHROPIC_API_KEY: 'test',
-  SERPER_API_KEY: 'test',
-  GRAVITY_API_KEY: 'test',
-  GRAVITY_CAPI_KEY: 'test',
-  PORT: '4242',
-  DATABASE_URL: 'postgres://user:pass@localhost:5432/db',
-  ANVIL_GITHUB_ID: 'test-id',
-  ANVIL_GITHUB_SECRET: 'test-secret',
-  NEXTAUTH_SECRET: 'test-secret',
-  STRIPE_SECRET_KEY: 'sk_test_dummy',
-  STRIPE_WEBHOOK_SECRET_KEY: 'whsec_dummy',
-  STRIPE_TEAM_FEE_PRICE_ID: 'price_test',
-  LOOPS_API_KEY: 'test',
-  DISCORD_PUBLIC_KEY: 'test',
-  DISCORD_BOT_TOKEN: 'test',
-  DISCORD_APPLICATION_ID: 'test',
-}
-
-function ensureCliEnvDefaults(): void {
-  if (!process.env.NODE_ENV) {
-    process.env.NODE_ENV = 'test'
-  }
-  if (!process.env.BUN_ENV) {
-    process.env.BUN_ENV = 'test'
-  }
-  if (process.env.CI !== 'true' && process.env.CI !== '1') {
-    process.env.CI = 'true'
-  }
-
-  for (const [key, value] of Object.entries(TEST_CLIENT_ENV_DEFAULTS)) {
-    if (!process.env[key]) {
-      process.env[key] = value
-    }
-  }
-
-  for (const [key, value] of Object.entries(TEST_SERVER_ENV_DEFAULTS)) {
-    if (!process.env[key]) {
-      process.env[key] = value
-    }
-  }
-}
-
-function loadCliEnv(): Record<string, string> {
-  if (cachedEnv) {
-    return cachedEnv
-  }
-
-  try {
-    ensureCliEnvDefaults()
-    // NOTE: Inline require() is used for lazy loading - the env module depends on
-    // Infisical secrets which may not be available at module load time in test environments
-    const { env } = require('../../../packages/internal/src/env') as {
-      env: Record<string, unknown>
-    }
-
-    cachedEnv = Object.entries(env).reduce<Record<string, string>>(
-      (acc, [key, value]) => {
-        if (value !== undefined && value !== null) {
-          acc[key] = String(value)
-        }
-        return acc
-      },
-      {},
-    )
-
-    return cachedEnv
-  } catch (error) {
-    const message =
-      error instanceof Error
-        ? error.message
-        : 'unknown error loading environment'
-    throw new Error(
-      `Failed to load CLI environment via packages/internal/src/env: ${message}. ` +
-        'Run commands via "infisical run -- bun …" or export the required variables.',
-    )
-  }
-}
-
-export function ensureCliTestEnv(): void {
-  loadCliEnv()
-}
-
-export function getDefaultCliEnv(): Record<string, string> {
-  return { ...loadCliEnv() }
-}
-
-/**
- * Parsed re-render log entry from useWhyDidYouUpdate hook
- */
-export interface RerenderLogEntry {
-  timestamp: string
-  componentName: string
-  messageId: string
-  renderCount: number
-  changedProps: string[]
-}
-
-/**
- * Aggregated re-render analysis results
- */
-export interface RerenderAnalysis {
-  totalRerenders: number
-  rerendersByMessage: Map<string, number>
-  propChangeFrequency: Map<string, number>
-  maxRerenderPerMessage: number
-}
-
-/**
- * Parse re-render logs from the CLI debug log file
- */
-export function parseRerenderLogs(logPath: string): RerenderLogEntry[] {
-  const entries: RerenderLogEntry[] = []
-
-  try {
-    const content = fs.readFileSync(logPath, 'utf-8')
-    const lines = content.split('\n').filter((line) => line.trim())
-
-    for (const line of lines) {
-      try {
-        const parsed = JSON.parse(line)
-
-        // Check if this is a re-render log entry
-        if (
-          parsed.msg &&
-          typeof parsed.msg === 'string' &&
-          parsed.msg.includes('render #')
-        ) {
-          // Extract component name from msg like "MessageBlock render #2 [user-123]: 2 props changed"
-          const msgMatch = parsed.msg.match(
-            /^(\w+) render #(\d+) \[([^\]]+)\]/,
-          )
-          if (msgMatch && parsed.data) {
-            entries.push({
-              timestamp: parsed.timestamp,
-              componentName: msgMatch[1],
-              messageId: parsed.data.id || msgMatch[3],
-              renderCount: parseInt(msgMatch[2], 10),
-              changedProps: parsed.data.changedProps || [],
-            })
-          }
-        }
-      } catch {
-        // Skip malformed lines
-      }
-    }
-  } catch {
-    // File doesn't exist or can't be read
-  }
-
-  return entries
-}
-
-/**
- * Analyze re-render logs and return aggregated statistics
- */
-export function analyzeRerenders(entries: RerenderLogEntry[]): RerenderAnalysis {
-  const rerendersByMessage = new Map<string, number>()
-  const propChangeFrequency = new Map<string, number>()
-
-  for (const entry of entries) {
-    // Count re-renders per message
-    const currentCount = rerendersByMessage.get(entry.messageId) || 0
-    rerendersByMessage.set(entry.messageId, currentCount + 1)
-
-    // Count how often each prop changes
-    for (const prop of entry.changedProps) {
-      const propCount = propChangeFrequency.get(prop) || 0
-      propChangeFrequency.set(prop, propCount + 1)
-    }
-  }
-
-  // Find max re-renders for any single message
-  let maxRerenderPerMessage = 0
-  for (const count of rerendersByMessage.values()) {
-    if (count > maxRerenderPerMessage) {
-      maxRerenderPerMessage = count
-    }
-  }
-
-  return {
-    totalRerenders: entries.length,
-    rerendersByMessage,
-    propChangeFrequency,
-    maxRerenderPerMessage,
-  }
-}
-
-/**
- * Clear the CLI debug log file
- */
-export function clearCliDebugLog(logPath: string): void {
-  try {
-    fs.writeFileSync(logPath, '')
-  } catch {
-    // Ignore errors
-  }
-}

package/src/__tests__/tmux-poc.ts

@@ -1,150 +0,0 @@
-#!/usr/bin/env bun
-
-/**
- * Proof of Concept: tmux-based CLI testing
- *
- * This script demonstrates how to:
- * 1. Create a tmux session
- * 2. Run the CLI in that session
- * 3. Send commands to the CLI
- * 4. Capture and verify output
- * 5. Clean up the session
- */
-
-import { spawn } from 'child_process'
-
-import stripAnsi from 'strip-ansi'
-
-import { isTmuxAvailable, sleep } from './test-utils'
-
-// Utility to run tmux commands
-function tmux(args: string[]): Promise<string> {
-  return new Promise((resolve, reject) => {
-    const proc = spawn('tmux', args, { stdio: 'pipe' })
-    let stdout = ''
-    let stderr = ''
-
-    proc.stdout?.on('data', (data) => {
-      stdout += data.toString()
-    })
-
-    proc.stderr?.on('data', (data) => {
-      stderr += data.toString()
-    })
-
-    proc.on('close', (code) => {
-      if (code === 0) {
-        resolve(stdout)
-      } else {
-        reject(new Error(`tmux command failed: ${stderr}`))
-      }
-    })
-  })
-}
-
-// Capture pane content
-async function capturePane(sessionName: string): Promise<string> {
-  return await tmux(['capture-pane', '-t', sessionName, '-p'])
-}
-
-// Main test function
-async function testCLIWithTmux() {
-  const sessionName = 'anvil-test-' + Date.now()
-
-  console.log('🚀 Starting tmux-based CLI test...')
-  console.log(`📦 Session: ${sessionName}`)
-
-  // 1. Check if tmux is installed
-  if (!isTmuxAvailable()) {
-    console.error('❌ tmux not found')
-    console.error('\n📦 Installation:')
-    console.error('  macOS:   brew install tmux')
-    console.error('  Ubuntu:  sudo apt-get install tmux')
-    console.error('  Windows: Use WSL and run sudo apt-get install tmux')
-    console.error(
-      '\nℹ️  This is just a proof-of-concept. See the documentation for alternatives.',
-    )
-    process.exit(1)
-  }
-
-  try {
-    const version = await tmux(['-V'])
-    console.log(`✅ tmux is installed: ${version.trim()}`)
-
-    // 2. Create new detached tmux session running the CLI
-    console.log('\n📺 Creating tmux session...')
-    await tmux([
-      'new-session',
-      '-d',
-      '-s',
-      sessionName,
-      '-x',
-      '120', // width
-      '-y',
-      '30', // height
-      'bun',
-      'run',
-      'src/entry.ts',
-      '--help',
-    ])
-    console.log('✅ Session created')
-
-    // 3. Wait for CLI to start
-    await sleep(1000)
-
-    // 4. Capture initial output
-    console.log('\n📸 Capturing initial output...')
-    const initialOutput = await capturePane(sessionName)
-    const cleanOutput = stripAnsi(initialOutput)
-
-    console.log('\n--- Output ---')
-    console.log(cleanOutput)
-    console.log('--- End Output ---\n')
-
-    // 5. Verify output contains expected text
-    const checks = [
-      { text: '--agent', pass: cleanOutput.includes('--agent') },
-      { text: 'Usage:', pass: cleanOutput.includes('Usage:') },
-      { text: '--help', pass: cleanOutput.includes('--help') },
-    ]
-
-    console.log('🔍 Verification:')
-    checks.forEach(({ text, pass }) => {
-      console.log(
-        `  ${pass ? '✅' : '❌'} Contains "${text}"${pass ? '' : ' - NOT FOUND'}`,
-      )
-    })
-
-    const allPassed = checks.every((c) => c.pass)
-    console.log(
-      `\n${allPassed ? '🎉 All checks passed!' : '⚠️  Some checks failed'}`,
-    )
-
-    // 6. Example: Send interactive command (commented out for --help test)
-    /*
-    console.log('\n⌨️  Sending test command...')
-    await sendKeys(sessionName, 'hello world')
-    await sendKeys(sessionName, 'Enter')
-    await sleep(2000)
-    
-    const responseOutput = await capturePane(sessionName)
-    console.log('\n--- Response ---')
-    console.log(stripAnsi(responseOutput))
-    console.log('--- End Response ---')
-    */
-  } catch (error) {
-    console.error('\n❌ Test failed:', error)
-  } finally {
-    // 7. Cleanup: kill the tmux session
-    console.log('\n🧹 Cleaning up...')
-    try {
-      await tmux(['kill-session', '-t', sessionName])
-      console.log('✅ Session cleaned up')
-    } catch (e) {
-      console.log('⚠️  Session may have already exited')
-    }
-  }
-}
-
-// Run the test
-testCLIWithTmux().catch(console.error)

package/src/__tests__/unit/agent-mode-toggle.test.ts

@@ -1,137 +0,0 @@
-import { describe, test, expect, beforeEach, afterEach } from 'bun:test'
-
-import {
-  buildExpandedSegments,
-  resolveAgentModeClick,
-  OPEN_DELAY_MS,
-  CLOSE_DELAY_MS,
-  REOPEN_SUPPRESS_MS,
-} from '../../components/agent-mode-toggle'
-import { createHoverToggleControllerForTest } from '../mocks/hover-toggle-controller'
-
-import type { AgentMode } from '../../utils/constants'
-
-describe('AgentModeToggle - buildExpandedSegments', () => {
-  const modes: AgentMode[] = ['DEFAULT', 'MAX', 'PLAN']
-
-  for (const mode of modes) {
-    test(`returns segments with active indicator for ${mode}`, () => {
-      const segs = buildExpandedSegments(mode)
-      // 4 mode options (DEFAULT, LITE, MAX, PLAN) + 1 active indicator
-      expect(segs.length).toBe(5)
-
-      // Current mode is disabled among the choices
-      const current = segs.find((s) => s.id === mode)
-      expect(current?.disabled).toBe(true)
-
-      // Active indicator has expected id and flags
-      const active = segs.find((s) => s.id === `active-${mode}`)
-      expect(active).toBeTruthy()
-      expect(active?.isSelected).toBe(true)
-      expect(active?.defaultHighlighted).toBe(true)
-    })
-  }
-})
-
-describe('AgentModeToggle - resolveAgentModeClick', () => {
-  test('clicking active indicator returns closeActive', () => {
-    const action = resolveAgentModeClick('DEFAULT', 'active-DEFAULT', true)
-    expect(action).toEqual({ type: 'closeActive' })
-  })
-
-  test('with onSelectMode provided, clicking different mode selects it', () => {
-    const action = resolveAgentModeClick('DEFAULT', 'MAX', true)
-    expect(action).toEqual({ type: 'selectMode', mode: 'MAX' })
-  })
-
-  test('without onSelectMode, clicking different mode toggles', () => {
-    const action = resolveAgentModeClick('DEFAULT', 'PLAN', false)
-    expect(action).toEqual({ type: 'toggleMode', mode: 'PLAN' })
-  })
-})
-
-// Extended Date.now type with test helper method
-interface MockDateNow {
-  (): number
-  set: (v: number) => void
-}
-
-describe('useHoverToggle timing (controller)', () => {
-  let originalSetTimeout: typeof setTimeout
-  let originalClearTimeout: typeof clearTimeout
-  let originalNow: typeof Date.now
-
-  let timers: { id: number; ms: number; fn: () => void; active: boolean }[]
-  let nextId: number
-
-  const runAll = () => {
-    for (const t of timers) {
-      if (t.active) t.fn()
-    }
-    timers = []
-  }
-
-  beforeEach(() => {
-    timers = []
-    nextId = 1
-    originalSetTimeout = setTimeout
-    originalClearTimeout = clearTimeout
-    originalNow = Date.now
-
-    let now = 1_000
-    const mockDateNow: MockDateNow = Object.assign(
-      () => now,
-      { set: (v: number) => { now = v } }
-    )
-    Date.now = mockDateNow
-
-    globalThis.setTimeout = ((fn: () => void, ms?: number) => {
-      const id = nextId++
-      timers.push({ id, ms: Number(ms ?? 0), fn, active: true })
-      return id as unknown as ReturnType<typeof setTimeout>
-    }) as typeof setTimeout
-
-    globalThis.clearTimeout = ((id?: ReturnType<typeof clearTimeout>) => {
-      const rec = timers.find((t) => t.id === (id as unknown as number))
-      if (rec) rec.active = false
-    }) as typeof clearTimeout
-  })
-
-  afterEach(() => {
-    globalThis.setTimeout = originalSetTimeout
-    globalThis.clearTimeout = originalClearTimeout
-    Date.now = originalNow
-  })
-
-  test('scheduleOpen waits OPEN_DELAY_MS then opens', () => {
-    const ctl = createHoverToggleControllerForTest()
-    expect(ctl.isOpen).toBe(false)
-    ctl.scheduleOpen()
-    expect(timers.length).toBe(1)
-    expect(timers[0].ms).toBe(OPEN_DELAY_MS)
-    runAll()
-    expect(ctl.isOpen).toBe(true)
-  })
-
-  test('scheduleClose waits CLOSE_DELAY_MS then closes', () => {
-    const ctl = createHoverToggleControllerForTest()
-    ctl.openNow()
-    expect(ctl.isOpen).toBe(true)
-    ctl.scheduleClose()
-    expect(timers.length).toBe(1)
-    expect(timers[0].ms).toBe(CLOSE_DELAY_MS)
-    runAll()
-    expect(ctl.isOpen).toBe(false)
-  })
-
-  test('closeNow(true) suppresses reopen until time passes', () => {
-    const ctl = createHoverToggleControllerForTest()
-    ctl.closeNow(true)
-    ctl.scheduleOpen()
-    expect(timers.length).toBe(0)
-    ;(Date.now as MockDateNow).set(1_000 + REOPEN_SUPPRESS_MS + 1)
-    ctl.scheduleOpen()
-    expect(timers.length).toBe(1)
-    expect(timers[0].ms).toBe(OPEN_DELAY_MS)
-  })
-})

package/src/__tests__/unit/copy-button.test.ts

@@ -1,157 +0,0 @@
-import { createMockTimers } from '@anvil/common/testing/mocks/timers'
-import { describe, test, expect, beforeEach, afterEach } from 'bun:test'
-
-import {
-  getCopyIconText,
-  copyButtonHandlers,
-  COPIED_RESET_DELAY_MS,
-  COPY_ICON_COLLAPSED,
-  COPY_ICON_EXPANDED,
-  COPY_ICON_COPIED,
-} from '../../components/copy-button'
-import { initializeThemeStore } from '../../hooks/use-theme'
-
-import type { MockTimers } from '@anvil/common/testing/mocks/timers'
-
-// Initialize theme before tests
-initializeThemeStore()
-
-/**
- * Tests for CopyButton component logic.
- *
- * These tests use the exported utilities from copy-button.tsx:
- * - getCopyIconText: determines what text to display
- * - copyButtonHandlers: pure functions for state transitions
- * - COPIED_RESET_DELAY_MS: the timeout constant
- */
-
-describe('CopyButton - CopyIcon text rendering', () => {
-  describe('with leadingSpace=true (default)', () => {
-    test('renders collapsed icon when not hovered or copied', () => {
-      const text = getCopyIconText(false, false, true)
-      expect(text).toBe(' ⎘')
-    })
-
-    test('renders expanded text when hovered', () => {
-      const text = getCopyIconText(false, true, true)
-      expect(text).toBe(' [⎘ copy]')
-    })
-
-    test('renders copied text when copied', () => {
-      const text = getCopyIconText(true, false, true)
-      expect(text).toBe(' [✔ copied]')
-    })
-
-    test('renders copied text even when hovered (copied takes priority)', () => {
-      const text = getCopyIconText(true, true, true)
-      expect(text).toBe(' [✔ copied]')
-    })
-  })
-
-  describe('with leadingSpace=false', () => {
-    test('renders collapsed icon without leading space', () => {
-      const text = getCopyIconText(false, false, false)
-      expect(text).toBe('⎘')
-    })
-
-    test('renders expanded text without leading space', () => {
-      const text = getCopyIconText(false, true, false)
-      expect(text).toBe('[⎘ copy]')
-    })
-
-    test('renders copied text without leading space', () => {
-      const text = getCopyIconText(true, false, false)
-      expect(text).toBe('[✔ copied]')
-    })
-  })
-})
-
-describe('CopyButton - copyButtonHandlers (from component)', () => {
-  describe('handleMouseOver', () => {
-    test('returns true (should hover) when not copied', () => {
-      expect(copyButtonHandlers.handleMouseOver(false)).toBe(true)
-    })
-
-    test('returns false (block hover) when copied', () => {
-      expect(copyButtonHandlers.handleMouseOver(true)).toBe(false)
-    })
-  })
-
-  describe('handleMouseOut', () => {
-    test('always returns false to clear hover', () => {
-      expect(copyButtonHandlers.handleMouseOut()).toBe(false)
-    })
-  })
-
-  describe('handleCopy', () => {
-    test('returns copied=true and clears hover', () => {
-      const result = copyButtonHandlers.handleCopy()
-      expect(result).toEqual({ isCopied: true, isHovered: false })
-    })
-  })
-})
-
-describe('CopyButton - exported constants', () => {
-  test('COPIED_RESET_DELAY_MS is 2000ms', () => {
-    expect(COPIED_RESET_DELAY_MS).toBe(2000)
-  })
-
-  test('icon constants are defined', () => {
-    expect(COPY_ICON_COLLAPSED).toBe('⎘')
-    expect(COPY_ICON_EXPANDED).toBe('[⎘ copy]')
-    expect(COPY_ICON_COPIED).toBe('[✔ copied]')
-  })
-})
-
-describe('CopyButton - copied state reset timing', () => {
-  let mockTimers: MockTimers
-
-  beforeEach(() => {
-    mockTimers = createMockTimers()
-    mockTimers.install()
-  })
-
-  afterEach(() => {
-    mockTimers.restore()
-  })
-
-  test('uses the exported COPIED_RESET_DELAY_MS constant (2000ms)', () => {
-    let isCopied = false
-
-    // Simulate handleCopy using the exported constant
-    const handleCopy = () => {
-      const newState = copyButtonHandlers.handleCopy()
-      isCopied = newState.isCopied
-      setTimeout(() => {
-        isCopied = false
-      }, COPIED_RESET_DELAY_MS)
-    }
-
-    handleCopy()
-    expect(isCopied).toBe(true)
-    expect(mockTimers.getPendingCount()).toBe(1)
-    const nextTimer = mockTimers.getNext()
-    expect(nextTimer?.ms).toBe(COPIED_RESET_DELAY_MS)
-
-    mockTimers.runAll()
-    expect(isCopied).toBe(false)
-  })
-
-  test('multiple rapid clicks only create one active timer', () => {
-    let currentTimerId: number | null = null
-
-    const handleCopy = () => {
-      if (currentTimerId !== null) {
-        clearTimeout(currentTimerId)
-      }
-      copyButtonHandlers.handleCopy()
-      currentTimerId = setTimeout(() => {}, COPIED_RESET_DELAY_MS) as unknown as number
-    }
-
-    handleCopy()
-    handleCopy()
-    handleCopy()
-
-    expect(mockTimers.getPendingCount()).toBe(1)
-  })
-})