@alumbwe/anvil 1.0.18 → 1.0.20

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

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

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

@@ -0,0 +1,209 @@
+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',
+    })
+  })
+})