@alumbwe/anvil 1.0.0 → 1.0.2

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

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

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