@alumbwe/anvil 1.0.42 → 1.0.49

package/src/utils/__tests__/format-timeout.test.ts

@@ -1,87 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-
-import { formatTimeout } from '../format-timeout'
-
-describe('formatTimeout', () => {
-  describe('normal values', () => {
-    test('returns seconds for values less than 60', () => {
-      expect(formatTimeout(10)).toBe('10s timeout')
-      expect(formatTimeout(30)).toBe('30s timeout')
-      expect(formatTimeout(45)).toBe('45s timeout')
-    })
-
-    test('returns minutes for values evenly divisible by 60', () => {
-      expect(formatTimeout(60)).toBe('1m timeout')
-      expect(formatTimeout(120)).toBe('2m timeout')
-      expect(formatTimeout(300)).toBe('5m timeout')
-    })
-
-    test('returns hours for values evenly divisible by 3600', () => {
-      expect(formatTimeout(3600)).toBe('1h timeout')
-      expect(formatTimeout(7200)).toBe('2h timeout')
-      expect(formatTimeout(10800)).toBe('3h timeout')
-    })
-
-    test('returns minutes for large values divisible by 60 but not 3600', () => {
-      expect(formatTimeout(5400)).toBe('90m timeout')
-    })
-
-    test('returns seconds for large values not evenly divisible by 60', () => {
-      expect(formatTimeout(3700)).toBe('3700s timeout')
-    })
-
-    test('returns seconds for values >= 60 not evenly divisible by 60', () => {
-      expect(formatTimeout(90)).toBe('90s timeout')
-      expect(formatTimeout(150)).toBe('150s timeout')
-    })
-
-    test('returns "0s timeout" for 0', () => {
-      expect(formatTimeout(0)).toBe('0s timeout')
-    })
-  })
-
-  describe('negative values', () => {
-    test('returns "no timeout" for -1', () => {
-      expect(formatTimeout(-1)).toBe('no timeout')
-    })
-
-    test('returns "no timeout" for other negative values', () => {
-      expect(formatTimeout(-5)).toBe('no timeout')
-      expect(formatTimeout(-100)).toBe('no timeout')
-      expect(formatTimeout(-0.5)).toBe('no timeout')
-    })
-  })
-
-  describe('non-finite values', () => {
-    test('returns "no timeout" for NaN', () => {
-      expect(formatTimeout(NaN)).toBe('no timeout')
-    })
-
-    test('returns "no timeout" for Infinity', () => {
-      expect(formatTimeout(Infinity)).toBe('no timeout')
-    })
-
-    test('returns "no timeout" for -Infinity', () => {
-      expect(formatTimeout(-Infinity)).toBe('no timeout')
-    })
-  })
-
-  describe('floating point values', () => {
-    test('rounds floating point values to nearest integer', () => {
-      expect(formatTimeout(30.4)).toBe('30s timeout')
-      expect(formatTimeout(30.5)).toBe('31s timeout')
-      expect(formatTimeout(30.9)).toBe('31s timeout')
-    })
-
-    test('rounds floating point values for minute display', () => {
-      expect(formatTimeout(59.5)).toBe('1m timeout')
-      expect(formatTimeout(60.4)).toBe('1m timeout')
-      expect(formatTimeout(119.6)).toBe('2m timeout')
-    })
-
-    test('handles floating point values that round to non-minute values', () => {
-      expect(formatTimeout(60.6)).toBe('61s timeout')
-      expect(formatTimeout(89.5)).toBe('90s timeout')
-    })
-  })
-})

package/src/utils/__tests__/image-dimensions.test.ts

@@ -1,249 +0,0 @@
-import { mkdirSync, mkdtempSync, rmSync } from 'fs'
-import os from 'os'
-import path from 'path'
-
-import { describe, test, expect, beforeEach, afterEach, mock } from 'bun:test'
-import { Jimp } from 'jimp'
-
-import { setProjectRoot } from '../../project-files'
-import { calculateDisplaySize } from '../image-display'
-import { processImageFile } from '../image-handler'
-
-// Mock the logger to prevent analytics initialization errors in tests
-mock.module('../logger', () => ({
-  logger: {
-    debug: () => {},
-    info: () => {},
-    warn: () => {},
-    error: () => {},
-    fatal: () => {},
-  },
-}))
-
-/** A directory this run owns. It was a fixed `__dirname/temp-test-images`,
- *  which `afterEach` deletes recursively — so a second, overlapping run wiped
- *  the images this one was still reading (6 of 10 overlapped runs failed; solo
- *  always passed), and a crashed run left debris in the working tree. See
- *  docs/testing.md. */
-let TEST_DIR: string
-
-beforeEach(async () => {
-  TEST_DIR = mkdtempSync(path.join(os.tmpdir(), 'cli-image-dimensions-'))
-  // Create debug directory for logger
-  mkdirSync(path.join(TEST_DIR, 'debug'), { recursive: true })
-
-  // Set project root so logger doesn't throw
-  setProjectRoot(TEST_DIR)
-
-  // Create test images with known dimensions using Jimp
-  // Wide image: 200x100 (2:1 aspect ratio)
-  const wideImage = new Jimp({ width: 200, height: 100, color: 0xff0000ff })
-  await wideImage.write(
-    path.join(TEST_DIR, 'wide-200x100.png') as `${string}.${string}`,
-  )
-
-  // Tall image: 100x200 (1:2 aspect ratio)
-  const tallImage = new Jimp({ width: 100, height: 200, color: 0x00ff00ff })
-  await tallImage.write(
-    path.join(TEST_DIR, 'tall-100x200.png') as `${string}.${string}`,
-  )
-
-  // Square image: 150x150 (1:1 aspect ratio)
-  const squareImage = new Jimp({ width: 150, height: 150, color: 0x0000ffff })
-  await squareImage.write(
-    path.join(TEST_DIR, 'square-150x150.png') as `${string}.${string}`,
-  )
-})
-
-afterEach(() => {
-  try {
-    rmSync(TEST_DIR, { recursive: true, force: true })
-  } catch {
-    // Ignore cleanup errors
-  }
-})
-
-describe('Image Dimensions', () => {
-  describe('processImageFile returns dimensions', () => {
-    test('should return width and height for a wide image', async () => {
-      // Use filename only since processImageFile resolves relative to cwd
-      const result = await processImageFile('wide-200x100.png', TEST_DIR)
-
-      expect(result.success).toBe(true)
-      expect(result.imagePart).toBeDefined()
-      expect(result.imagePart!.width).toBe(200)
-      expect(result.imagePart!.height).toBe(100)
-    })
-
-    test('should return width and height for a tall image', async () => {
-      const result = await processImageFile('tall-100x200.png', TEST_DIR)
-
-      expect(result.success).toBe(true)
-      expect(result.imagePart).toBeDefined()
-      expect(result.imagePart!.width).toBe(100)
-      expect(result.imagePart!.height).toBe(200)
-    })
-
-    test('should return width and height for a square image', async () => {
-      const result = await processImageFile('square-150x150.png', TEST_DIR)
-
-      expect(result.success).toBe(true)
-      expect(result.imagePart).toBeDefined()
-      expect(result.imagePart!.width).toBe(150)
-      expect(result.imagePart!.height).toBe(150)
-    })
-
-    test('should return compressed dimensions when image is compressed', async () => {
-      // Create a large image that will be compressed
-      const largeImage = new Jimp({
-        width: 2000,
-        height: 1000,
-        color: 0xff00ffff,
-      })
-
-      // Fill with varied data to make it less compressible (using unsigned values)
-      for (let y = 0; y < 1000; y++) {
-        for (let x = 0; x < 2000; x++) {
-          const r = (x * y) % 256
-          const g = (x + y) % 256
-          const b = x % 256
-          const a = 255
-          // Jimp uses RGBA format as unsigned 32-bit: 0xRRGGBBAA
-          const color = ((r << 24) | (g << 16) | (b << 8) | a) >>> 0
-          largeImage.setPixelColor(color, x, y)
-        }
-      }
-      await largeImage.write(
-        path.join(TEST_DIR, 'large-2000x1000.png') as `${string}.${string}`,
-      )
-
-      const result = await processImageFile('large-2000x1000.png', TEST_DIR)
-
-      expect(result.success).toBe(true)
-      expect(result.imagePart).toBeDefined()
-      // Dimensions should be defined even after compression
-      expect(result.imagePart!.width).toBeDefined()
-      expect(result.imagePart!.height).toBeDefined()
-      // After compression, dimensions should be reduced
-      if (result.wasCompressed) {
-        expect(result.imagePart!.width).toBeLessThanOrEqual(1500) // Max dimension limit
-        expect(result.imagePart!.height).toBeLessThanOrEqual(1500)
-      }
-    })
-  })
-
-  describe('calculateDisplaySize', () => {
-    const CELL_ASPECT_RATIO = 2 // Terminal cells are ~2:1 height:width
-
-    test('should scale wide image to fit available width while preserving aspect ratio', () => {
-      const result = calculateDisplaySize({
-        width: 200,
-        height: 100,
-        availableWidth: 80,
-      })
-
-      // With 200x100 image (2:1), scaling to fit 80 width
-      // Display width should be reasonable portion of available
-      expect(result.width).toBeLessThanOrEqual(80)
-      expect(result.width).toBeGreaterThan(0)
-      // Height adjusted for terminal cell aspect ratio
-      expect(result.height).toBeGreaterThan(0)
-    })
-
-    test('should scale tall image appropriately', () => {
-      const result = calculateDisplaySize({
-        width: 100,
-        height: 200,
-        availableWidth: 80,
-      })
-
-      expect(result.width).toBeLessThanOrEqual(80)
-      expect(result.width).toBeGreaterThan(0)
-      expect(result.height).toBeGreaterThan(0)
-      // Tall images should have larger height relative to width
-      expect(result.height).toBeGreaterThanOrEqual(
-        result.width / CELL_ASPECT_RATIO,
-      )
-    })
-
-    test('should handle square images', () => {
-      const result = calculateDisplaySize({
-        width: 150,
-        height: 150,
-        availableWidth: 80,
-      })
-
-      expect(result.width).toBeLessThanOrEqual(80)
-      expect(result.width).toBeGreaterThan(0)
-      expect(result.height).toBeGreaterThan(0)
-    })
-
-    test('should use fallback when dimensions are not provided', () => {
-      const result = calculateDisplaySize({
-        availableWidth: 80,
-      })
-
-      // Fallback should still return reasonable values
-      expect(result.width).toBeLessThanOrEqual(80)
-      expect(result.width).toBeGreaterThan(0)
-      expect(result.height).toBeGreaterThan(0)
-    })
-
-    test('should use fallback when width is 0', () => {
-      const result = calculateDisplaySize({
-        width: 0,
-        height: 100,
-        availableWidth: 80,
-      })
-
-      expect(result.width).toBeGreaterThan(0)
-      expect(result.height).toBeGreaterThan(0)
-    })
-
-    test('should use fallback when height is 0', () => {
-      const result = calculateDisplaySize({
-        width: 100,
-        height: 0,
-        availableWidth: 80,
-      })
-
-      expect(result.width).toBeGreaterThan(0)
-      expect(result.height).toBeGreaterThan(0)
-    })
-
-    test('should respect minimum display size', () => {
-      const result = calculateDisplaySize({
-        width: 1,
-        height: 1,
-        availableWidth: 80,
-      })
-
-      // Even tiny images should have at least 1 cell
-      expect(result.width).toBeGreaterThanOrEqual(1)
-      expect(result.height).toBeGreaterThanOrEqual(1)
-    })
-
-    test('should handle very wide available width', () => {
-      const result = calculateDisplaySize({
-        width: 100,
-        height: 100,
-        availableWidth: 200,
-      })
-
-      // Should not blow up image beyond reasonable size
-      expect(result.width).toBeLessThanOrEqual(100) // Don't exceed original
-      expect(result.height).toBeGreaterThan(0)
-    })
-
-    test('should handle narrow available width', () => {
-      const result = calculateDisplaySize({
-        width: 1000,
-        height: 500,
-        availableWidth: 20,
-      })
-
-      expect(result.width).toBeLessThanOrEqual(20)
-      expect(result.height).toBeGreaterThan(0)
-    })
-  })
-})

package/src/utils/__tests__/image-processor.test.ts

@@ -1,209 +0,0 @@
-import { describe, expect, test, mock } from 'bun:test'
-
-import { processImagesForMessage } from '../image-processor'
-
-import type { PendingImageAttachment } from '../../types/store'
-
-// Type for the processor function used in tests
-type ProcessorResult = 
-  | { success: true; imagePart: { type: 'image'; image: string; mediaType: string } }
-  | { success: false; error: string }
-type MockProcessor = (path: string, projectRoot: string) => Promise<ProcessorResult>
-
-// Minimal logger type for tests - only need warn for these tests
-interface TestLogger {
-  warn: (...args: unknown[]) => void
-  error: (...args: unknown[]) => void
-  debug: (...args: unknown[]) => void
-  info: (...args: unknown[]) => void
-  fatal: (...args: unknown[]) => void
-}
-
-const createPendingImage = (path: string, processedImage?: { base64: string; mediaType: string }): PendingImageAttachment => ({
-  kind: 'image',
-  path,
-  filename: path.split('/').pop() ?? 'image.png',
-  status: 'ready',
-  ...(processedImage && { processedImage }),
-})
-
-describe('processImagesForMessage', () => {
-  test('uses pre-processed image data from pendingImages without re-reading from disk', async () => {
-    const pendingImages = [createPendingImage('/tmp/pic.png', {
-      base64: 'pre-processed-base64-data',
-      mediaType: 'image/png',
-    })]
-    const processor = mock(async () => ({
-      success: true,
-      imagePart: {
-        type: 'image' as const,
-        image: 'disk-base64-data',
-        mediaType: 'image/png',
-      },
-    }))
-
-    const result = await processImagesForMessage({
-      content: 'Here is an image @/tmp/pic.png',
-      pendingImages,
-      projectRoot: '/repo',
-      processor: processor as MockProcessor,
-    })
-
-    // Should NOT call processor since we have pre-processed data
-    expect(processor).not.toHaveBeenCalled()
-    expect(result.attachments).toHaveLength(1)
-    expect(result.messageContent?.[0]).toMatchObject({
-      type: 'image',
-      image: 'pre-processed-base64-data',
-      mediaType: 'image/png',
-    })
-  })
-
-  test('processes inline image paths that are not in pendingImages', async () => {
-    const pendingImages = [createPendingImage('/tmp/pic.png', {
-      base64: 'pre-processed-base64-data',
-      mediaType: 'image/png',
-    })]
-    const processor = mock(async () => ({
-      success: true,
-      imagePart: {
-        type: 'image' as const,
-        image: 'inline-base64-data',
-        mediaType: 'image/jpeg',
-      },
-    }))
-
-    const result = await processImagesForMessage({
-      content: 'Here is another image @/tmp/other.jpg',
-      pendingImages,
-      projectRoot: '/repo',
-      processor: processor as MockProcessor,
-    })
-
-    // Should call processor only for the inline path
-    expect(processor).toHaveBeenCalledTimes(1)
-    expect(processor).toHaveBeenCalledWith('/tmp/other.jpg', '/repo')
-    expect(result.messageContent).toHaveLength(2)
-    expect(result.messageContent?.[0]).toMatchObject({
-      type: 'image',
-      image: 'pre-processed-base64-data',
-    })
-    expect(result.messageContent?.[1]).toMatchObject({
-      type: 'image',
-      image: 'inline-base64-data',
-    })
-  })
-
-  test('backwards compatibility: processes from disk when processedImage is missing', async () => {
-    // This tests the edge case where processedImage is missing but status is 'ready'
-    const pendingImages = [createPendingImage('/tmp/pic.png')] // No processedImage
-    const warn = mock(() => {})
-    const processor = mock(async () => ({
-      success: true,
-      imagePart: {
-        type: 'image' as const,
-        image: 'disk-base64-data',
-        mediaType: 'image/png',
-      },
-    }))
-
-    const result = await processImagesForMessage({
-      content: '',
-      pendingImages,
-      projectRoot: '/repo',
-      processor: processor as MockProcessor,
-      log: { warn, error: () => {}, debug: () => {}, info: () => {}, fatal: () => {} } as TestLogger,
-    })
-
-    // Should warn about missing processedImage and fall back to disk
-    expect(warn).toHaveBeenCalled()
-    expect(processor).toHaveBeenCalledTimes(1)
-    expect(result.messageContent?.[0]).toMatchObject({
-      type: 'image',
-      image: 'disk-base64-data',
-    })
-  })
-
-  test('skips images with processing or error status', async () => {
-    const pendingImages: PendingImageAttachment[] = [
-      { kind: 'image', path: '/tmp/processing.png', filename: 'processing.png', status: 'processing' },
-      { kind: 'image', path: '/tmp/error.png', filename: 'error.png', status: 'error', note: 'failed' },
-      createPendingImage('/tmp/ready.png', { base64: 'ready-data', mediaType: 'image/png' }),
-    ]
-    const processor = mock(async () => ({
-      success: true,
-      imagePart: {
-        type: 'image' as const,
-        image: 'should-not-be-used',
-        mediaType: 'image/png',
-      },
-    }))
-
-    const result = await processImagesForMessage({
-      content: '',
-      pendingImages,
-      projectRoot: '/repo',
-      processor: processor as MockProcessor,
-    })
-
-    // Should not call processor at all (ready image has processedImage)
-    expect(processor).not.toHaveBeenCalled()
-    // Only the ready image should be in messageContent
-    expect(result.messageContent).toHaveLength(1)
-    expect(result.messageContent?.[0]).toMatchObject({
-      type: 'image',
-      image: 'ready-data',
-    })
-  })
-
-  test('logs warnings when inline path processing fails', async () => {
-    const warn = mock(() => {})
-    const pendingImages: PendingImageAttachment[] = []
-    const processor = mock(async () => ({
-      success: false,
-      error: 'boom',
-    }))
-
-    const result = await processImagesForMessage({
-      content: 'Here is an image @/tmp/fail.png',
-      pendingImages,
-      projectRoot: '/repo',
-      processor: processor as MockProcessor,
-      log: { warn, error: () => {}, debug: () => {}, info: () => {}, fatal: () => {} } as TestLogger,
-    })
-
-    expect(warn).toHaveBeenCalled()
-    expect(result.messageContent).toBeUndefined()
-  })
-
-  test('deduplicates: does not process inline path that matches pending image path', async () => {
-    const pendingImages = [createPendingImage('/tmp/pic.png', {
-      base64: 'pre-processed-data',
-      mediaType: 'image/png',
-    })]
-    const processor = mock(async () => ({
-      success: true,
-      imagePart: {
-        type: 'image' as const,
-        image: 'disk-data',
-        mediaType: 'image/png',
-      },
-    }))
-
-    const result = await processImagesForMessage({
-      content: 'Here is the same image @/tmp/pic.png and again /tmp/pic.png',
-      pendingImages,
-      projectRoot: '/repo',
-      processor: processor as MockProcessor,
-    })
-
-    // Should not call processor since the path is already in pendingImages
-    expect(processor).not.toHaveBeenCalled()
-    // Should only have one image in messageContent (no duplicates)
-    expect(result.messageContent).toHaveLength(1)
-    expect(result.messageContent?.[0]).toMatchObject({
-      type: 'image',
-      image: 'pre-processed-data',
-    })
-  })
-})