egaki 0.6.0 → 0.7.0

package/src/cli/cache-utils.ts

@@ -0,0 +1,169 @@
+// Shared caching utilities for egaki generate functions.
+//
+// Provides deterministic cache keys, file lookup, deduplication queues,
+// and stale file management. Used by the cached variants of generateImage,
+// generateSpeech, generateVideo, and transcribeAudio.
+//
+// The project root (for locating public/generated/) is set via setProjectRoot()
+// at startup. In Vite context, server-components.tsx sets it from the virtual
+// module. Falls back to process.cwd() if not set.
+
+import { createHash } from 'node:crypto'
+import fs from 'node:fs'
+import path from 'node:path'
+
+// ---------------------------------------------------------------------------
+// Project root
+// ---------------------------------------------------------------------------
+
+let _projectRoot: string | undefined
+
+/** Set the project root directory. Called by the Vite plugin on startup. */
+export function setProjectRoot(root: string) {
+  _projectRoot = root
+}
+
+/** Get the project root directory. Falls back to cwd if not set. */
+export function getProjectRoot(): string {
+  return _projectRoot ?? process.cwd()
+}
+
+// ---------------------------------------------------------------------------
+// Deterministic cache keys
+// ---------------------------------------------------------------------------
+
+/** Deterministic JSON from a value: keys sorted recursively, undefined
+ *  values stripped. Safe for nested objects and arrays. */
+export function stableJsonKey(value: unknown): string {
+  return JSON.stringify(sortValue(value))
+}
+
+function sortValue(value: unknown): unknown {
+  if (Array.isArray(value)) return value.map(sortValue)
+  if (!value || typeof value !== 'object') return value
+  return Object.fromEntries(
+    Object.entries(value as Record<string, unknown>)
+      .filter(([, v]) => v !== undefined)
+      .sort(([a], [b]) => a.localeCompare(b))
+      .map(([k, v]) => [k, sortValue(v)]),
+  )
+}
+
+/** First 8 hex chars of sha256. */
+export function hashKey(input: string | Uint8Array): string {
+  return createHash('sha256').update(input).digest('hex').slice(0, 8)
+}
+
+/** First ~40 chars of text, kebab-cased, filesystem-safe. */
+export function promptPrefix(text: string): string {
+  const slug = text
+    .toLowerCase()
+    .replace(/[^a-z0-9\s-]/g, '')
+    .trim()
+    .replace(/\s+/g, '-')
+    .slice(0, 40)
+    .replace(/-$/, '')
+  return slug || 'generated'
+}
+
+export function extensionFromMediaType(mediaType: string): string {
+  const map: Record<string, string> = {
+    'image/png': '.png',
+    'image/jpeg': '.jpg',
+    'image/webp': '.webp',
+    'video/mp4': '.mp4',
+    'video/webm': '.webm',
+    'audio/mpeg': '.mp3',
+    'audio/wav': '.wav',
+    'audio/opus': '.opus',
+    'audio/ogg': '.ogg',
+    'audio/aac': '.aac',
+    'audio/flac': '.flac',
+  }
+  return map[mediaType] || '.bin'
+}
+
+// ---------------------------------------------------------------------------
+// Generated directory management
+// ---------------------------------------------------------------------------
+
+/** Returns the generated files directory for a given namespace.
+ *  Creates the directory if it doesn't exist. */
+export function generatedDir(namespace: string): string {
+  const root = getProjectRoot()
+  const dir = path.join(root, 'public', 'generated', namespace)
+  fs.mkdirSync(dir, { recursive: true })
+  return dir
+}
+
+// ---------------------------------------------------------------------------
+// File lookup
+// ---------------------------------------------------------------------------
+
+/** Find an existing cached file by hash in the generated directory.
+ *  Also checks the stale/ subfolder — if found there, restores it. */
+export function findCachedFile(dir: string, hash: string): string | undefined {
+  try {
+    const found = fs.readdirSync(dir).find((f) => f.includes(hash))
+    if (found) return found
+  } catch { /* empty */ }
+  try {
+    const staleDir = path.join(dir, 'stale')
+    const inStale = fs.readdirSync(staleDir).find((f) => f.includes(hash))
+    if (inStale) {
+      fs.renameSync(path.join(staleDir, inStale), path.join(dir, inStale))
+      console.log(`[egaki] restored from stale: ${inStale}`)
+      return inStale
+    }
+  } catch { /* empty */ }
+  return undefined
+}
+
+/** Find a previous generation with the same prompt prefix (different hash)
+ *  that can serve as fallback while a new generation is in progress. */
+export function findFallbackFile(dir: string, prefix: string, currentHash: string): { filename: string; inStale: boolean } | undefined {
+  const match = (f: string) => f.startsWith(prefix + '-') && !f.includes(currentHash)
+  try {
+    const inDir = fs.readdirSync(dir).find(match)
+    if (inDir) return { filename: inDir, inStale: false }
+  } catch { /* empty */ }
+  try {
+    const staleDir = path.join(dir, 'stale')
+    const inStale = fs.readdirSync(staleDir).find(match)
+    if (inStale) return { filename: inStale, inStale: true }
+  } catch { /* empty */ }
+  return undefined
+}
+
+// ---------------------------------------------------------------------------
+// Stale file management
+// ---------------------------------------------------------------------------
+
+/** Move a specific file into the stale/ subfolder of its directory. */
+export function moveFileToStale(dir: string, fallback: { filename: string; inStale: boolean }) {
+  if (fallback.inStale) return
+  const src = path.join(dir, fallback.filename)
+  const staleDir = path.join(dir, 'stale')
+  try {
+    if (!fs.existsSync(src)) return
+    fs.mkdirSync(staleDir, { recursive: true })
+    fs.renameSync(src, path.join(staleDir, fallback.filename))
+    console.log(`[egaki] moved stale: ${fallback.filename} → stale/`)
+  } catch { /* race with another rename, safe to ignore */ }
+}
+
+// ---------------------------------------------------------------------------
+// Generation queue — deduplicates concurrent calls with the same cache key.
+// Stored on globalThis so in-flight promises survive Vite HMR module reloads.
+// ---------------------------------------------------------------------------
+
+export const generationQueue: Map<string, Promise<any>> =
+  (globalThis as any).__egakiGenerationQueue ??= new Map<string, Promise<any>>()
+
+/** Format key params for logging, omitting undefined values and the _type field. */
+export function formatKeyParams(params: Record<string, unknown>): string {
+  const entries = Object.entries(params)
+    .filter(([k, v]) => v !== undefined && k !== '_type')
+    .map(([k, v]) => `${k}=${typeof v === 'string' ? v : JSON.stringify(v)}`)
+  return entries.join(', ')
+}

package/src/cli/cached-generate.test.ts

@@ -0,0 +1,531 @@
+/**
+ * Tests for cachedGenerate — the general-purpose persisted memoization HOF.
+ *
+ * Uses a temp directory as the project root so tests are isolated and don't
+ * touch the real public/generated/ folder. Tests verify: cache hit/miss,
+ * dedup of concurrent calls, stale fallback management, auto-hashing of
+ * Uint8Array params, JSON serialization, progress tracking, error handling,
+ * and the getCacheInfo helper.
+ */
+
+import { describe, test, expect, beforeEach, afterEach } from 'vitest'
+import fs from 'node:fs'
+import path from 'node:path'
+import os from 'node:os'
+import {
+  cachedGenerate,
+  getCacheInfo,
+  getGenerationProgress,
+  type CachedGenerateConfig,
+} from './cached-generate.ts'
+import { setProjectRoot } from './cache-utils.ts'
+
+let tmpDir: string
+
+beforeEach(() => {
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'egaki-cached-generate-test-'))
+  setProjectRoot(tmpDir)
+})
+
+afterEach(() => {
+  fs.rmSync(tmpDir, { recursive: true, force: true })
+})
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+interface TestParams {
+  prompt: string
+  seed?: number
+  inputData?: Uint8Array
+}
+
+function makeTestConfig(overrides?: Partial<CachedGenerateConfig<TestParams, { data: string }, { src: string }>>) {
+  let callCount = 0
+  const config: CachedGenerateConfig<TestParams, { data: string }, { src: string }> = {
+    namespace: 'test',
+    prefixFrom: (p) => p.prompt,
+    generate: async (params) => {
+      callCount++
+      return { data: `generated-${params.prompt}` }
+    },
+    serialize: (result) => ({
+      bytes: new Uint8Array(Buffer.from(result.data)),
+      extension: '.txt',
+    }),
+    ...overrides,
+  }
+  return { config, getCallCount: () => callCount }
+}
+
+// ---------------------------------------------------------------------------
+// Cache hit / miss
+// ---------------------------------------------------------------------------
+
+describe('cache hit and miss', () => {
+  test('first call generates and writes file', async () => {
+    const { config, getCallCount } = makeTestConfig()
+    const fn = cachedGenerate(config)
+
+    const result = await fn({ prompt: 'hello world' })
+    expect(result).not.toBeInstanceOf(Error)
+    const r = result as { src: string }
+    expect(r.src).toMatch(/^\/generated\/test\/hello-world-[a-f0-9]{8}\.txt$/)
+    expect(getCallCount()).toBe(1)
+
+    // File exists on disk
+    const filePath = path.join(tmpDir, 'public', r.src)
+    expect(fs.existsSync(filePath)).toBe(true)
+    expect(fs.readFileSync(filePath, 'utf-8')).toBe('generated-hello world')
+  })
+
+  test('second call with same params returns cached (no generation)', async () => {
+    const { config, getCallCount } = makeTestConfig()
+    const fn = cachedGenerate(config)
+
+    const r1 = await fn({ prompt: 'hello world' })
+    const r2 = await fn({ prompt: 'hello world' })
+
+    expect(r1).not.toBeInstanceOf(Error)
+    expect(r2).not.toBeInstanceOf(Error)
+    expect((r1 as { src: string }).src).toBe((r2 as { src: string }).src)
+    expect(getCallCount()).toBe(1) // only called once
+  })
+
+  test('different params generate different files', async () => {
+    const { config, getCallCount } = makeTestConfig()
+    const fn = cachedGenerate(config)
+
+    const r1 = await fn({ prompt: 'alpha' })
+    const r2 = await fn({ prompt: 'beta' })
+
+    expect(r1).not.toBeInstanceOf(Error)
+    expect(r2).not.toBeInstanceOf(Error)
+    expect((r1 as { src: string }).src).not.toBe((r2 as { src: string }).src)
+    expect(getCallCount()).toBe(2)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Concurrent dedup
+// ---------------------------------------------------------------------------
+
+describe('deduplication', () => {
+  test('concurrent calls with same params return same promise', async () => {
+    let resolveGenerate!: (v: { data: string }) => void
+    const { config } = makeTestConfig({
+      generate: () => new Promise((resolve) => { resolveGenerate = resolve }),
+    })
+    const fn = cachedGenerate(config)
+
+    const p1 = fn({ prompt: 'dedup test' })
+    const p2 = fn({ prompt: 'dedup test' })
+
+    // Resolve the single generation
+    resolveGenerate({ data: 'result' })
+
+    const [r1, r2] = await Promise.all([p1, p2])
+    expect(r1).not.toBeInstanceOf(Error)
+    expect(r2).not.toBeInstanceOf(Error)
+    expect((r1 as { src: string }).src).toBe((r2 as { src: string }).src)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Stale fallback management
+// ---------------------------------------------------------------------------
+
+describe('stale management', () => {
+  test('changing params moves old file to stale/', async () => {
+    const { config } = makeTestConfig()
+    const fn = cachedGenerate(config)
+
+    // Generate first version
+    const r1 = await fn({ prompt: 'hello world', seed: 1 })
+    expect(r1).not.toBeInstanceOf(Error)
+
+    const firstFile = path.basename((r1 as { src: string }).src)
+
+    // Generate with different seed but same prompt prefix
+    const r2 = await fn({ prompt: 'hello world', seed: 2 })
+    expect(r2).not.toBeInstanceOf(Error)
+
+    // Old file should be in stale/
+    const staleDir = path.join(tmpDir, 'public', 'generated', 'test', 'stale')
+    const staleFiles = fs.existsSync(staleDir) ? fs.readdirSync(staleDir) : []
+    expect(staleFiles).toContain(firstFile)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Auto-hashing Uint8Array params
+// ---------------------------------------------------------------------------
+
+describe('Uint8Array auto-hashing', () => {
+  test('same bytes produce same cache key', async () => {
+    const { config, getCallCount } = makeTestConfig()
+    const fn = cachedGenerate(config)
+
+    const data = new Uint8Array([1, 2, 3])
+    const r1 = await fn({ prompt: 'with data', inputData: data })
+    const r2 = await fn({ prompt: 'with data', inputData: new Uint8Array([1, 2, 3]) })
+
+    expect(getCallCount()).toBe(1) // same key → cached
+    expect((r1 as { src: string }).src).toBe((r2 as { src: string }).src)
+  })
+
+  test('different bytes produce different cache keys', async () => {
+    const { config, getCallCount } = makeTestConfig()
+    const fn = cachedGenerate(config)
+
+    await fn({ prompt: 'with data', inputData: new Uint8Array([1, 2, 3]) })
+    await fn({ prompt: 'with data', inputData: new Uint8Array([4, 5, 6]) })
+
+    expect(getCallCount()).toBe(2)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// JSON serialization
+// ---------------------------------------------------------------------------
+
+describe('JSON serialization', () => {
+  test('json serialize writes .json and deserialize reads it back', async () => {
+    interface JsonResult { items: string[] }
+    const fn = cachedGenerate<{ query: string }, JsonResult, JsonResult>({
+      namespace: 'json-test',
+      prefixFrom: (p) => p.query,
+      generate: async (params) => ({ items: [params.query, 'b', 'c'] }),
+      serialize: (result) => ({
+        json: result,
+        extension: '.json' as const,
+      }),
+      deserialize: ({ filePath }) => JSON.parse(fs.readFileSync(filePath, 'utf-8')),
+    })
+
+    const r1 = await fn({ query: 'search term' })
+    expect(r1).not.toBeInstanceOf(Error)
+    expect((r1 as JsonResult).items).toEqual(['search term', 'b', 'c'])
+
+    // Second call reads from cache
+    const r2 = await fn({ query: 'search term' })
+    expect(r2).not.toBeInstanceOf(Error)
+    expect((r2 as JsonResult).items).toEqual(['search term', 'b', 'c'])
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Prefix override from serialize
+// ---------------------------------------------------------------------------
+
+describe('prefix override', () => {
+  test('serialize can return a prefix to override the filename', async () => {
+    const fn = cachedGenerate<{ id: string }, { text: string }, { src: string }>({
+      namespace: 'prefix-test',
+      prefixFrom: () => 'initial',
+      generate: async () => ({ text: 'the actual content is here' }),
+      serialize: (result) => ({
+        bytes: new Uint8Array(Buffer.from(result.text)),
+        extension: '.txt',
+        prefix: 'the actual content is here',
+      }),
+    })
+
+    const r = await fn({ id: '123' })
+    expect(r).not.toBeInstanceOf(Error)
+    // The filename should use the override prefix, not 'initial'
+    expect((r as { src: string }).src).toMatch(/the-actual-content-is-here/)
+    expect((r as { src: string }).src).not.toMatch(/initial/)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Progress tracking
+// ---------------------------------------------------------------------------
+
+describe('progress tracking', () => {
+  test('generation is registered and unregistered', async () => {
+    let resolveGenerate!: (v: { data: string }) => void
+    const fn = cachedGenerate<TestParams, { data: string }>({
+      namespace: 'progress-test',
+      prefixFrom: (p) => p.prompt,
+      modelFrom: (p) => `model-${p.seed}`,
+      generate: () => new Promise((resolve) => { resolveGenerate = resolve }),
+      serialize: (result) => ({
+        bytes: new Uint8Array(Buffer.from(result.data)),
+        extension: '.txt',
+      }),
+    })
+
+    const promise = fn({ prompt: 'tracking test', seed: 42 })
+
+    // While generating, progress should show the entry
+    const progress = getGenerationProgress()
+    expect(progress.summary.total).toBe(1)
+    expect(progress.summary.counts['progress-test']).toBe(1)
+    expect(progress.generations[0]?.namespace).toBe('progress-test')
+    expect(progress.generations[0]?.label).toBe('tracking test')
+    expect(progress.generations[0]?.model).toBe('model-42')
+
+    // Resolve the generation
+    resolveGenerate({ data: 'done' })
+    await promise
+
+    // After completion, progress should be empty
+    const after = getGenerationProgress()
+    expect(after.summary.total).toBe(0)
+  })
+
+  test('failed generation reports error in progress', async () => {
+    const fn = cachedGenerate<TestParams, { data: string }>({
+      namespace: 'error-progress',
+      prefixFrom: (p) => p.prompt,
+      generate: async () => { throw new Error('API failed') },
+      serialize: (result) => ({
+        bytes: new Uint8Array(Buffer.from(result.data)),
+        extension: '.txt',
+      }),
+    })
+
+    const result = await fn({ prompt: 'fail test' })
+    expect(result).toBeInstanceOf(Error)
+    expect((result as Error).message).toBe('API failed')
+
+    // Error should be in the progress drain
+    const progress = getGenerationProgress()
+    expect(progress.errors.length).toBe(1)
+    expect(progress.errors[0]?.error).toBe('API failed')
+    expect(progress.errors[0]?.namespace).toBe('error-progress')
+
+    // Errors drain on read — second call should have none
+    const progress2 = getGenerationProgress()
+    expect(progress2.errors.length).toBe(0)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Error handling
+// ---------------------------------------------------------------------------
+
+describe('error handling', () => {
+  test('generate throwing returns Error', async () => {
+    const fn = cachedGenerate<TestParams, { data: string }>({
+      namespace: 'error-test',
+      prefixFrom: (p) => p.prompt,
+      generate: async () => { throw new Error('boom') },
+      serialize: (result) => ({
+        bytes: new Uint8Array(Buffer.from(result.data)),
+        extension: '.txt',
+      }),
+    })
+
+    const result = await fn({ prompt: 'error test' })
+    expect(result).toBeInstanceOf(Error)
+    expect((result as Error).message).toBe('boom')
+  })
+
+  test('non-Error throw is wrapped in Error', async () => {
+    const fn = cachedGenerate<TestParams, { data: string }>({
+      namespace: 'error-test-2',
+      prefixFrom: (p) => p.prompt,
+      generate: async () => { throw 'string error' },
+      serialize: (result) => ({
+        bytes: new Uint8Array(Buffer.from(result.data)),
+        extension: '.txt',
+      }),
+    })
+
+    const result = await fn({ prompt: 'string error test' })
+    expect(result).toBeInstanceOf(Error)
+    expect((result as Error).message).toBe('string error')
+  })
+
+  test('failed call does not cache — retry regenerates', async () => {
+    let shouldFail = true
+    const fn = cachedGenerate<TestParams, { data: string }>({
+      namespace: 'retry-test',
+      prefixFrom: (p) => p.prompt,
+      generate: async (params) => {
+        if (shouldFail) throw new Error('temporary failure')
+        return { data: `ok-${params.prompt}` }
+      },
+      serialize: (result) => ({
+        bytes: new Uint8Array(Buffer.from(result.data)),
+        extension: '.txt',
+      }),
+    })
+
+    const r1 = await fn({ prompt: 'retry' })
+    expect(r1).toBeInstanceOf(Error)
+
+    shouldFail = false
+    const r2 = await fn({ prompt: 'retry' })
+    expect(r2).not.toBeInstanceOf(Error)
+    expect((r2 as { src: string }).src).toMatch(/\/generated\/retry-test\//)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Namespace isolation in dedup queue
+// ---------------------------------------------------------------------------
+
+describe('namespace isolation', () => {
+  test('same params in different namespaces generate independently', async () => {
+    let imageCallCount = 0
+    let videoCallCount = 0
+
+    const imageFn = cachedGenerate<{ prompt: string }, { data: string }>({
+      namespace: 'ns-image',
+      prefixFrom: (p) => p.prompt,
+      generate: async (params) => {
+        imageCallCount++
+        return { data: `image-${params.prompt}` }
+      },
+      serialize: (result) => ({
+        bytes: new Uint8Array(Buffer.from(result.data)),
+        extension: '.png',
+      }),
+    })
+
+    const videoFn = cachedGenerate<{ prompt: string }, { data: string }>({
+      namespace: 'ns-video',
+      prefixFrom: (p) => p.prompt,
+      generate: async (params) => {
+        videoCallCount++
+        return { data: `video-${params.prompt}` }
+      },
+      serialize: (result) => ({
+        bytes: new Uint8Array(Buffer.from(result.data)),
+        extension: '.mp4',
+      }),
+    })
+
+    const [imgResult, vidResult] = await Promise.all([
+      imageFn({ prompt: 'same params' }),
+      videoFn({ prompt: 'same params' }),
+    ])
+
+    expect(imgResult).not.toBeInstanceOf(Error)
+    expect(vidResult).not.toBeInstanceOf(Error)
+    expect(imageCallCount).toBe(1)
+    expect(videoCallCount).toBe(1)
+    // Different src paths
+    expect((imgResult as { src: string }).src).toMatch(/ns-image/)
+    expect((vidResult as { src: string }).src).toMatch(/ns-video/)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Recursive Uint8Array hashing
+// ---------------------------------------------------------------------------
+
+describe('recursive binary hashing', () => {
+  test('nested Uint8Array values produce stable cache keys', async () => {
+    const { config, getCallCount } = makeTestConfig()
+    const fn = cachedGenerate(config)
+
+    // Pass nested binary data inside an object
+    const r1 = await fn({ prompt: 'nested', inputData: new Uint8Array([10, 20, 30]) } as any)
+    const r2 = await fn({ prompt: 'nested', inputData: new Uint8Array([10, 20, 30]) } as any)
+
+    expect(getCallCount()).toBe(1) // same nested bytes → cached
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Serialize failure handling
+// ---------------------------------------------------------------------------
+
+describe('serialize failure', () => {
+  test('serialize throwing unregisters progress and returns Error', async () => {
+    // Drain any leftover errors from previous tests
+    getGenerationProgress()
+
+    const fn = cachedGenerate<TestParams, { data: string }>({
+      namespace: 'serialize-fail',
+      prefixFrom: (p) => p.prompt,
+      generate: async () => ({ data: 'ok' }),
+      serialize: () => { throw new Error('serialize exploded') },
+    })
+
+    const result = await fn({ prompt: 'serialize test' })
+    expect(result).toBeInstanceOf(Error)
+    expect((result as Error).message).toBe('serialize exploded')
+
+    // Progress should be clean — no stuck entries
+    const progress = getGenerationProgress()
+    expect(progress.summary.total).toBe(0)
+    // Error should be in the drain
+    expect(progress.errors.length).toBe(1)
+    expect(progress.errors[0]?.error).toBe('serialize exploded')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// cacheKey config excludes non-identity fields
+// ---------------------------------------------------------------------------
+
+describe('cacheKey config', () => {
+  test('excluded fields do not affect cache identity', async () => {
+    let callCount = 0
+    const fn = cachedGenerate<{ query: string; label?: string }, { data: string }>({
+      namespace: 'cachekey-test',
+      prefixFrom: (p) => p.label ?? p.query,
+      cacheKey: ({ label, ...rest }) => rest,
+      generate: async (params) => {
+        callCount++
+        return { data: `result-${params.query}` }
+      },
+      serialize: (result) => ({
+        bytes: new Uint8Array(Buffer.from(result.data)),
+        extension: '.txt',
+      }),
+    })
+
+    await fn({ query: 'search', label: 'label-a' })
+    await fn({ query: 'search', label: 'label-b' })
+
+    // Same query, different labels → should be same cache entry
+    expect(callCount).toBe(1)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// getCacheInfo helper
+// ---------------------------------------------------------------------------
+
+describe('getCacheInfo', () => {
+  test('returns cache miss before any generation', () => {
+    const info = getCacheInfo('test-ns', { prompt: 'hello' }, 'hello')
+    expect(info.cached).toBeUndefined()
+    expect(info.hash).toMatch(/^[a-f0-9]{8}$/)
+    expect(info.prefix).toBe('hello')
+  })
+
+  test('returns cache hit after generation', async () => {
+    const { config } = makeTestConfig()
+    const fn = cachedGenerate(config)
+
+    await fn({ prompt: 'cached info test' })
+
+    const info = getCacheInfo('test', { prompt: 'cached info test' }, 'cached info test')
+    expect(info.cached).toBeDefined()
+    expect(info.cached).toMatch(/cached-info-test-[a-f0-9]{8}\.txt/)
+  })
+
+  test('returns fallbackSrc when a previous generation exists', async () => {
+    const { config } = makeTestConfig()
+    const fn = cachedGenerate(config)
+
+    // Generate first version
+    await fn({ prompt: 'fallback test', seed: 1 })
+
+    // Query for a different version that doesn't exist yet
+    // Version 1 is in the main dir and should be found as fallback
+    const info = getCacheInfo('test', { prompt: 'fallback test', seed: 2 }, 'fallback test')
+    expect(info.cached).toBeUndefined()
+    expect(info.fallbackSrc).toBeDefined()
+    expect(info.fallbackSrc).toMatch(/\/generated\/test\/fallback-test-/)
+  })
+})