@alumbwe/anvil 1.0.20 → 1.0.21

package/vendor/@anvil/common/src/util/__tests__/error-api-details.test.ts

@@ -0,0 +1,206 @@
+import { describe, expect, it } from 'bun:test'
+
+import {
+  extractApiErrorDetails,
+  FETCH_IDLE_TIMEOUT_USER_MESSAGE,
+  isFetchIdleTimeoutError,
+  isTransientNetworkError,
+} from '../error'
+
+describe('extractApiErrorDetails', () => {
+  it('extracts structured details from nested retry errors', () => {
+    const apiError = new Error('Conflict') as Error & {
+      statusCode: number
+      responseBody: string
+    }
+    apiError.statusCode = 409
+    apiError.responseBody = JSON.stringify({
+      error: 'session_superseded',
+      message:
+        'Another instance of anvil has taken over this session. Only one instance per account is allowed.',
+    })
+
+    const retryError = new Error(
+      'Failed after 4 attempts. Last error: Conflict',
+    ) as Error & {
+      lastError: unknown
+      errors: unknown[]
+    }
+    retryError.name = 'AI_RetryError'
+    retryError.lastError = apiError
+    retryError.errors = [apiError]
+
+    expect(extractApiErrorDetails(retryError)).toEqual({
+      statusCode: 409,
+      errorCode: 'session_superseded',
+      message:
+        'Another instance of anvil has taken over this session. Only one instance per account is allowed.',
+    })
+  })
+
+  it('extracts details from OpenAI-style nested error objects', () => {
+    const apiError = new Error('Too Many Requests') as Error & {
+      statusCode: number
+      responseBody: string
+    }
+    apiError.statusCode = 429
+    apiError.responseBody = JSON.stringify({
+      error: {
+        message: 'Model is at capacity. Please try again later.',
+        code: null,
+        type: 'rate_limit_error',
+      },
+    })
+
+    expect(extractApiErrorDetails(apiError)).toEqual({
+      statusCode: 429,
+      errorCode: 'rate_limit_error',
+      message: 'Model is at capacity. Please try again later.',
+    })
+  })
+
+  it('prefers nested error code over type when both are strings', () => {
+    const apiError = new Error('Too Many Requests') as Error & {
+      statusCode: number
+      responseBody: string
+    }
+    apiError.statusCode = 429
+    apiError.responseBody = JSON.stringify({
+      error: {
+        message: 'Slow down.',
+        code: 'rate_limited',
+        type: 'rate_limit_error',
+      },
+    })
+
+    expect(extractApiErrorDetails(apiError)).toEqual({
+      statusCode: 429,
+      errorCode: 'rate_limited',
+      message: 'Slow down.',
+    })
+  })
+
+  it('keeps top-level string fields when both shapes are present', () => {
+    const apiError = new Error('Too Many Requests') as Error & {
+      statusCode: number
+      responseBody: string
+    }
+    apiError.statusCode = 429
+    apiError.responseBody = JSON.stringify({
+      error: 'free_mode_rate_limited',
+      message: 'Free mode rate limit exceeded (1 minute limit).',
+    })
+
+    expect(extractApiErrorDetails(apiError)).toEqual({
+      statusCode: 429,
+      errorCode: 'free_mode_rate_limited',
+      message: 'Free mode rate limit exceeded (1 minute limit).',
+    })
+  })
+})
+
+describe('isFetchIdleTimeoutError', () => {
+  it('detects a DOMException-style TimeoutError by name', () => {
+    const error = new Error('The operation timed out.')
+    error.name = 'TimeoutError'
+    expect(isFetchIdleTimeoutError(error)).toBe(true)
+  })
+
+  it('detects the Bun timeout message without the TimeoutError name', () => {
+    expect(isFetchIdleTimeoutError(new Error('The operation timed out.'))).toBe(
+      true,
+    )
+  })
+
+  it('detects a timeout nested inside an AI SDK RetryError wrapper', () => {
+    const timeoutError = new Error('The operation timed out.')
+    timeoutError.name = 'TimeoutError'
+    const retryError = new Error(
+      'Failed after 3 attempts.',
+    ) as Error & { errors: unknown[] }
+    retryError.errors = [timeoutError]
+    expect(isFetchIdleTimeoutError(retryError)).toBe(true)
+  })
+
+  it('returns false for unrelated errors', () => {
+    expect(isFetchIdleTimeoutError(new Error('Internal Server Error'))).toBe(
+      false,
+    )
+    expect(isFetchIdleTimeoutError(undefined)).toBe(false)
+    expect(isFetchIdleTimeoutError('The operation timed out.')).toBe(false)
+  })
+})
+
+describe('FETCH_IDLE_TIMEOUT_USER_MESSAGE', () => {
+  it('states the symptom without pinning the blame on the user', () => {
+    expect(FETCH_IDLE_TIMEOUT_USER_MESSAGE).toContain(
+      'no data was received from the server for 5 minutes',
+    )
+    expect(FETCH_IDLE_TIMEOUT_USER_MESSAGE).toContain('slow model start')
+    // A slow model start produces this error with nothing wrong on the user's
+    // end, so the copy must not assert a cause it cannot know.
+    expect(FETCH_IDLE_TIMEOUT_USER_MESSAGE).not.toContain('usually means')
+    expect(FETCH_IDLE_TIMEOUT_USER_MESSAGE).not.toContain(
+      'rather than a server outage',
+    )
+  })
+})
+
+describe('isTransientNetworkError', () => {
+  it('detects the Bun socket-close message', () => {
+    expect(
+      isTransientNetworkError(
+        new Error(
+          'The socket connection was closed unexpectedly. For more information, pass `verbose: true` in the second argument to fetch()',
+        ),
+      ),
+    ).toBe(true)
+  })
+
+  it('detects transient network error codes', () => {
+    const error = new Error('request failed') as Error & { code: string }
+    error.code = 'ECONNRESET'
+    expect(isTransientNetworkError(error)).toBe(true)
+
+    const bunError = new Error('request failed') as Error & { code: string }
+    bunError.code = 'ConnectionClosed'
+    expect(isTransientNetworkError(bunError)).toBe(true)
+  })
+
+  it('detects the undici "fetch failed" TypeError', () => {
+    expect(isTransientNetworkError(new TypeError('fetch failed'))).toBe(true)
+  })
+
+  it('detects a socket error nested inside an AI SDK RetryError wrapper', () => {
+    const socketError = new Error(
+      'The socket connection was closed unexpectedly. For more information, pass `verbose: true` in the second argument to fetch()',
+    ) as Error & { code: string }
+    socketError.code = 'ECONNRESET'
+    const retryError = new Error('Failed after 3 attempts.') as Error & {
+      errors: unknown[]
+    }
+    retryError.errors = [socketError]
+    expect(isTransientNetworkError(retryError)).toBe(true)
+  })
+
+  it('detects a socket error in a cause chain', () => {
+    const inner = new Error('read ECONNRESET') as Error & { code: string }
+    inner.code = 'ECONNRESET'
+    const outer = new Error('Cannot connect to API')
+    ;(outer as Error & { cause: unknown }).cause = inner
+    expect(isTransientNetworkError(outer)).toBe(true)
+  })
+
+  it('returns false for unrelated errors', () => {
+    expect(isTransientNetworkError(new Error('Internal Server Error'))).toBe(
+      false,
+    )
+    expect(isTransientNetworkError(undefined)).toBe(false)
+    expect(isTransientNetworkError('fetch failed')).toBe(false)
+    const serverError = new Error('Bad Request') as Error & {
+      statusCode: number
+    }
+    serverError.statusCode = 400
+    expect(isTransientNetworkError(serverError)).toBe(false)
+  })
+})

package/vendor/@anvil/common/src/util/__tests__/file-read-limits.test.ts

@@ -0,0 +1,173 @@
+import { describe, expect, test } from 'bun:test'
+
+import {
+  createFileReadLimiter,
+  MAX_READ_FILE_CHARS,
+  MAX_READ_FILE_LINES,
+  MAX_READ_FILES_CHARS,
+  MAX_READ_FILES_TOKENS,
+  windowFileRead,
+} from '../file-read-limits'
+
+describe('createFileReadLimiter', () => {
+  test('returns a small file unchanged', () => {
+    const limiter = createFileReadLimiter()
+
+    expect(limiter.limit('small file')).toBe('small file')
+  })
+
+  test('caps a single file at the per-file limit', () => {
+    const limiter = createFileReadLimiter()
+    const content = 'a'.repeat(MAX_READ_FILES_CHARS + 1)
+    const result = limiter.limit(content)
+
+    expect(result).toStartWith('a'.repeat(MAX_READ_FILES_CHARS))
+    expect(result).toContain('character hard limit')
+    expect(result).not.toContain('a'.repeat(MAX_READ_FILES_CHARS + 1))
+  })
+
+  test('does not split a surrogate pair at the character limit', () => {
+    const limiter = createFileReadLimiter()
+    const prefix = 'a'.repeat(MAX_READ_FILES_CHARS - 1)
+    const result = limiter.limit(`${prefix}😀tail`)
+
+    expect(result).toStartWith(`${prefix}\n\n[FILE_TOO_LARGE]`)
+    expect(result).not.toContain('\ud83d')
+  })
+
+  test('shares one aggregate budget across files in request order', () => {
+    const limiter = createFileReadLimiter()
+    const first = limiter.limit('a'.repeat(60_000))
+    const second = limiter.limit('b'.repeat(60_000))
+    const third = limiter.limit('UNIQUE_THIRD_FILE_CONTENT')
+
+    expect(first).toBe('a'.repeat(60_000))
+    expect(second).toStartWith('b'.repeat(40_000))
+    expect(second).not.toContain('b'.repeat(40_001))
+    expect(second).toContain('combined read_files output')
+    expect(third).not.toContain('UNIQUE_THIRD_FILE_CONTENT')
+    expect(third).toContain('truncated after 0 characters')
+    expect(60_000 + 40_000).toBe(MAX_READ_FILES_CHARS)
+  })
+
+  test('caps a token-dense file using an injected estimator', () => {
+    const limiter = createFileReadLimiter({
+      countTokens: (text) => text.length,
+    })
+    const result = limiter.limit('t'.repeat(25_000))
+    const includedContent = result.split('\n\n[FILE_TOO_LARGE]')[0]
+
+    expect(includedContent).toBe('t'.repeat(19 * 1_024))
+    expect(includedContent.length).toBeLessThanOrEqual(MAX_READ_FILES_TOKENS)
+    expect(result).toContain('estimated-token per-file limit')
+  })
+
+  test('does not split a surrogate pair at the token limit', () => {
+    const limiter = createFileReadLimiter({
+      countTokens: (text) => Array.from(text).length,
+    })
+    const result = limiter.limit('😀'.repeat(25_000))
+    const includedContent = result.split('\n\n[FILE_TOO_LARGE]')[0]
+    const lastCodeUnit = includedContent.charCodeAt(includedContent.length - 1)
+
+    expect(Array.from(includedContent).length).toBeLessThanOrEqual(
+      MAX_READ_FILES_TOKENS,
+    )
+    expect(lastCodeUnit < 0xd800 || lastCodeUnit > 0xdbff).toBe(true)
+  })
+
+  test('shares one token budget across files in request order', () => {
+    const limiter = createFileReadLimiter({
+      countTokens: (text) => text.length,
+    })
+    const first = limiter.limit('a'.repeat(12_000))
+    const second = limiter.limit('b'.repeat(12_000))
+    const thirdContent = 'UNIQUE_THIRD_FILE_CONTENT'
+    const third = limiter.limit(thirdContent)
+    const secondContent = second.split('\n\n[FILE_TOO_LARGE]')[0]
+
+    expect(first).toBe('a'.repeat(12_000))
+    expect(secondContent).toBe('b'.repeat(7 * 1_024))
+    expect(second).toContain('combined read_files output')
+    expect(second).toContain('estimated-token limit')
+    expect(third).toBe(thirdContent)
+    expect(first.length + secondContent.length + third.length).toBeLessThan(
+      MAX_READ_FILES_TOKENS,
+    )
+  })
+})
+
+describe('windowFileRead', () => {
+  test('returns a small file unchanged, including its trailing newline', () => {
+    const content = 'a\nb\nc\n'
+
+    expect(windowFileRead(content)).toBe(content)
+  })
+
+  test('does not count the trailing newline as an extra line', () => {
+    const content =
+      Array.from({ length: MAX_READ_FILE_LINES }, (_, i) => `line ${i + 1}`).join('\n') + '\n'
+
+    expect(windowFileRead(content)).toBe(content)
+  })
+
+  test('caps an unwindowed read at the line limit and reports the true total', () => {
+    const totalLines = MAX_READ_FILE_LINES + 500
+    const content = Array.from({ length: totalLines }, (_, i) => `line ${i + 1}`).join('\n')
+    const result = windowFileRead(content)
+
+    expect(result).toContain(`showing lines 1-${MAX_READ_FILE_LINES} of ${totalLines}`)
+    expect(result).toContain(`offset=${MAX_READ_FILE_LINES + 1} to continue`)
+    expect(result).not.toContain(`line ${MAX_READ_FILE_LINES + 1}\n`)
+  })
+
+  test('returns the requested window with a footer', () => {
+    const content = Array.from({ length: 100 }, (_, i) => `line ${i + 1}`).join('\n')
+    const result = windowFileRead(content, 10, 5)
+
+    expect(result).toContain('line 10')
+    expect(result).toContain('line 14')
+    expect(result).not.toContain('line 15\n')
+    expect(result).toContain('showing lines 10-14 of 100')
+    expect(result).toContain('offset=15 to continue')
+  })
+
+  test('omits the continue advice when the window reaches the end of the file', () => {
+    const content = Array.from({ length: 100 }, (_, i) => `line ${i + 1}`).join('\n')
+    const result = windowFileRead(content, 90, 20)
+
+    expect(result).toContain('showing lines 90-100 of 100')
+    expect(result).not.toContain('to continue')
+  })
+
+  test('reports an offset beyond the end of the file', () => {
+    const content = 'a\nb\nc'
+
+    expect(windowFileRead(content, 10)).toBe(
+      '[read_files: 3 lines total; offset 10 is beyond the end of the file.]',
+    )
+  })
+
+  test('clamps a requested limit to the line cap', () => {
+    const totalLines = MAX_READ_FILE_LINES + 500
+    const content = Array.from({ length: totalLines }, (_, i) => `line ${i + 1}`).join('\n')
+    const result = windowFileRead(content, 1, totalLines)
+
+    expect(result).toContain(`showing lines 1-${MAX_READ_FILE_LINES} of ${totalLines}`)
+  })
+
+  test('shortens a window that exceeds the char cap and says so', () => {
+    const line = 'x'.repeat(1000)
+    const totalLines = 100
+    const content = Array.from({ length: totalLines }, () => line).join('\n')
+    const result = windowFileRead(content, 1, totalLines)
+
+    const match = result.match(/showing lines 1-(\d+) of 100/)
+    expect(match).not.toBeNull()
+    expect(Number(match![1])).toBeLessThan(totalLines)
+    expect(result).toContain(
+      `shortened to stay under ${MAX_READ_FILE_CHARS.toLocaleString()} characters`,
+    )
+    expect(result).toContain('to continue')
+  })
+})

package/vendor/@anvil/common/src/util/__tests__/format-code-search.test.ts

@@ -0,0 +1,60 @@
+import { describe, expect, it } from 'bun:test'
+
+import { formatCodeSearchOutput } from '../format-code-search'
+
+describe('formatCodeSearchOutput', () => {
+  it('adds a match count and line labels', () => {
+    const output = formatCodeSearchOutput(
+      [
+        'src/a.ts:12:const alpha = true',
+        'src/a.ts:18:return alpha',
+        'src/b.ts:3:export const beta = false',
+      ].join('\n'),
+      { matchCount: 3 },
+    )
+
+    expect(output).toBe(
+      [
+        'Found 3 matches',
+        'src/a.ts:',
+        '  Line 12: const alpha = true',
+        '  Line 18: return alpha',
+        '',
+        'src/b.ts:',
+        '  Line 3: export const beta = false',
+      ].join('\n'),
+    )
+  })
+
+  it('uses the provided match count instead of counting context lines', () => {
+    const output = formatCodeSearchOutput(
+      [
+        'src/a.ts:10:const before = true',
+        'src/a.ts:11:const match = true',
+        'src/a.ts:12:const after = true',
+      ].join('\n'),
+      { matchCount: 1 },
+    )
+
+    expect(output).toContain('Found 1 matches')
+    expect(output).toContain('  Line 10: const before = true')
+    expect(output).toContain('  Line 11: const match = true')
+    expect(output).toContain('  Line 12: const after = true')
+  })
+
+  it('does not count native ripgrep context lines as matches', () => {
+    const output = formatCodeSearchOutput(
+      [
+        'src/a.ts-10-const before = true',
+        'src/a.ts:11:const match = true',
+        'src/a.ts-12-const after = true',
+      ].join('\n'),
+    )
+
+    expect(output).toContain('Found 1 matches')
+  })
+
+  it('reports zero matches for empty output', () => {
+    expect(formatCodeSearchOutput('')).toBe('Found 0 matches')
+  })
+})

package/vendor/@anvil/common/src/util/__tests__/log-mirror.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, it } from 'bun:test'
+
+import {
+  AXIOM_MIRROR_DENYLIST,
+  shouldMirrorAnalyticsEvent,
+} from '../log-mirror'
+
+describe('shouldMirrorAnalyticsEvent', () => {
+  it('drops high-volume PostHog auto-events from the Axiom mirror', () => {
+    for (const denied of AXIOM_MIRROR_DENYLIST) {
+      expect(shouldMirrorAnalyticsEvent(denied)).toBe(false)
+    }
+    expect(shouldMirrorAnalyticsEvent('$snapshot')).toBe(false)
+    expect(shouldMirrorAnalyticsEvent('$autocapture')).toBe(false)
+  })
+
+  it('keeps named product events and useful $ events', () => {
+    expect(shouldMirrorAnalyticsEvent('cli.login')).toBe(true)
+    expect(shouldMirrorAnalyticsEvent('cli.app_launched')).toBe(true)
+    expect(shouldMirrorAnalyticsEvent('web.signup')).toBe(true)
+    expect(shouldMirrorAnalyticsEvent('$pageview')).toBe(true)
+    expect(shouldMirrorAnalyticsEvent('$identify')).toBe(true)
+    expect(shouldMirrorAnalyticsEvent('$exception')).toBe(true)
+  })
+
+  it('treats empty/null event names as mirror-eligible (logs without an event)', () => {
+    expect(shouldMirrorAnalyticsEvent(null)).toBe(true)
+    expect(shouldMirrorAnalyticsEvent(undefined)).toBe(true)
+    expect(shouldMirrorAnalyticsEvent('')).toBe(true)
+  })
+})