@alumbwe/anvil 1.0.0

package/src/utils/__tests__/freebuff-streak-line.test.ts

@@ -0,0 +1,217 @@
+import { describe, test, expect } from 'bun:test'
+
+import {
+  FREEBUFF_STREAK_INLINE_GAP,
+  fitsFreebuffStreakOnHeadingRow,
+  getFreebuffStreakBonusNote,
+  getFreebuffStreakBonusNoteForLayout,
+  getFreebuffStreakInlineWidth,
+  getFreebuffStreakLine,
+} from '../freebuff-streak-line'
+
+// The CLI draws the shared ●/○ pair: filled-vs-hollow is what makes a partial
+// week distinguishable from a full one at a glance, which • and · (same shape,
+// different size) never managed.
+describe('getFreebuffStreakLine', () => {
+  test('hides the row for new / lapsed users (streak <= 0)', () => {
+    expect(getFreebuffStreakLine(0)).toBeNull()
+    expect(getFreebuffStreakLine(-1)).toBeNull()
+  })
+
+  test('labels and fills dots for an active streak', () => {
+    expect(getFreebuffStreakLine(2)).toEqual({
+      label: '2 day streak',
+      dots: '●●○○○○○',
+      progress: { filled: 2, total: 7, beyond: false },
+    })
+  })
+
+  test('"day" stays singular as a compound modifier', () => {
+    expect(getFreebuffStreakLine(1)?.label).toBe('1 day streak')
+    expect(getFreebuffStreakLine(5)?.label).toBe('5 day streak')
+  })
+
+  test('fills the whole week on a 7-day milestone', () => {
+    expect(getFreebuffStreakLine(7)).toEqual({
+      label: '7 day streak',
+      dots: '●●●●●●●',
+      // filled === total is how a surface without the constant knows the
+      // milestone is earned (the desktop banner gates its perk line on it)
+      progress: { filled: 7, total: 7, beyond: false },
+    })
+  })
+
+  test('stays full and gains a "+" once the streak passes the week', () => {
+    expect(getFreebuffStreakLine(9)).toEqual({
+      label: '9 day streak',
+      dots: '●●●●●●●+',
+      progress: { filled: 7, total: 7, beyond: true },
+    })
+    expect(getFreebuffStreakLine(19)).toEqual({
+      label: '19 day streak',
+      dots: '●●●●●●●+',
+      progress: { filled: 7, total: 7, beyond: true },
+    })
+  })
+})
+
+describe('fitsFreebuffStreakOnHeadingRow', () => {
+  const headingWidth = 'Start coding for free'.length
+  const line = getFreebuffStreakLine(18)!
+  // "18 day streak" + 2 + "●●●●●●●+"
+  const inlineWidth = getFreebuffStreakInlineWidth(line)
+  const exact = headingWidth + FREEBUFF_STREAK_INLINE_GAP + inlineWidth
+
+  test('measures the label and dots together', () => {
+    expect(inlineWidth).toBe(23)
+  })
+
+  test('shares the row only when the gap is fully clear', () => {
+    expect(
+      fitsFreebuffStreakOnHeadingRow({
+        line,
+        headingWidth,
+        availableWidth: exact,
+      }),
+    ).toBe(true)
+    expect(
+      fitsFreebuffStreakOnHeadingRow({
+        line,
+        headingWidth,
+        availableWidth: exact - 1,
+      }),
+    ).toBe(false)
+  })
+
+  test('measures an empty slot as the day-one streak it will become', () => {
+    const dayOne = getFreebuffStreakLine(1)!
+    const width = headingWidth + FREEBUFF_STREAK_INLINE_GAP
+    expect(
+      fitsFreebuffStreakOnHeadingRow({
+        line: null,
+        headingWidth,
+        availableWidth: width + getFreebuffStreakInlineWidth(dayOne),
+      }),
+    ).toBe(true)
+    expect(
+      fitsFreebuffStreakOnHeadingRow({
+        line: null,
+        headingWidth,
+        availableWidth: width + getFreebuffStreakInlineWidth(dayOne) - 1,
+      }),
+    ).toBe(false)
+  })
+
+  // A three-digit streak widens its own label, so the cutoff has to follow the
+  // rendered strings rather than a fixed column count.
+  test('accounts for the label growing with the day count', () => {
+    const long = getFreebuffStreakLine(365)!
+    expect(getFreebuffStreakInlineWidth(long)).toBeGreaterThan(inlineWidth)
+    expect(
+      fitsFreebuffStreakOnHeadingRow({
+        line: long,
+        headingWidth,
+        availableWidth: exact,
+      }),
+    ).toBe(false)
+  })
+})
+
+describe('getFreebuffStreakBonusNote', () => {
+  test('hidden with no streak at all', () => {
+    expect(
+      getFreebuffStreakBonusNote({ streak: 0, accessTier: 'full' }),
+    ).toBeNull()
+    expect(
+      getFreebuffStreakBonusNote({ streak: -1, accessTier: 'limited' }),
+    ).toBeNull()
+  })
+
+  test('teases the unlock countdown below the 7-day milestone', () => {
+    expect(getFreebuffStreakBonusNote({ streak: 3, accessTier: 'full' })).toBe(
+      '🎁 4 more days to unlock +1 bonus session every day + 1 GLM 5.2 session each day',
+    )
+    expect(
+      getFreebuffStreakBonusNote({ streak: 3, accessTier: 'limited' }),
+    ).toBe('🎁 4 more days to unlock +1 bonus session every day')
+  })
+
+  test('"day" goes singular on the eve of the milestone', () => {
+    expect(
+      getFreebuffStreakBonusNote({ streak: 6, accessTier: 'limited' }),
+    ).toBe('🎁 1 more day to unlock +1 bonus session every day')
+  })
+
+  test('full access advertises the daily session + daily GLM perk at 7+', () => {
+    const note = getFreebuffStreakBonusNote({ streak: 7, accessTier: 'full' })
+    expect(note).toBe(
+      '🎁 Streak perk: +1 bonus session every day + 1 GLM 5.2 session each day',
+    )
+  })
+
+  test('the GLM streak count grows per completed 7 days, capped at 4', () => {
+    expect(getFreebuffStreakBonusNote({ streak: 14, accessTier: 'full' })).toBe(
+      '🎁 Streak perk: +1 bonus session every day + 2 GLM 5.2 sessions each day',
+    )
+    expect(getFreebuffStreakBonusNote({ streak: 35, accessTier: 'full' })).toBe(
+      '🎁 Streak perk: +1 bonus session every day + 4 GLM 5.2 sessions each day',
+    )
+  })
+
+  test('limited access advertises only the daily session perk', () => {
+    const note = getFreebuffStreakBonusNote({
+      streak: 14,
+      accessTier: 'limited',
+    })
+    expect(note).toBe('🎁 Streak perk: +1 bonus session every day')
+  })
+})
+
+describe('getFreebuffStreakBonusNoteForLayout', () => {
+  const params = {
+    streak: 7,
+    accessTier: 'full' as const,
+  }
+  const note = getFreebuffStreakBonusNote(params)!
+
+  test('hides the unlock countdown before the bonus is earned', () => {
+    expect(
+      getFreebuffStreakBonusNoteForLayout({
+        ...params,
+        streak: 6,
+        terminalHeight: 30,
+        availableWidth: 200,
+      }),
+    ).toBeNull()
+  })
+
+  test('hides the earned note below 30 rows', () => {
+    expect(
+      getFreebuffStreakBonusNoteForLayout({
+        ...params,
+        terminalHeight: 29,
+        availableWidth: note.length,
+      }),
+    ).toBeNull()
+  })
+
+  test('shows the earned note at 30 rows when it fits on one line', () => {
+    expect(
+      getFreebuffStreakBonusNoteForLayout({
+        ...params,
+        terminalHeight: 30,
+        availableWidth: note.length,
+      }),
+    ).toBe(note)
+  })
+
+  test('hides the earned note when it would wrap', () => {
+    expect(
+      getFreebuffStreakBonusNoteForLayout({
+        ...params,
+        terminalHeight: 30,
+        availableWidth: note.length - 1,
+      }),
+    ).toBeNull()
+  })
+})

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',
+    })
+  })
+})