opencastle 0.8.2 → 0.9.0

package/src/cli/detect.test.ts

@@ -0,0 +1,337 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import { mkdtemp, writeFile, mkdir, rm } from 'node:fs/promises'
+import { join } from 'node:path'
+import { tmpdir } from 'node:os'
+import { detectRepoInfo, mergeStackIntoRepoInfo, formatRepoInfo } from './detect.js'
+import type { StackConfig, RepoInfo } from './types.js'
+
+// ── detectRepoInfo (filesystem-backed) ─────────────────────────
+
+describe('detectRepoInfo', () => {
+  let tempDir: string
+
+  beforeEach(async () => {
+    tempDir = await mkdtemp(join(tmpdir(), 'opencastle-test-'))
+  })
+
+  afterEach(async () => {
+    await rm(tempDir, { recursive: true, force: true })
+  })
+
+  it('detects npm from package-lock.json', async () => {
+    await writeFile(join(tempDir, 'package-lock.json'), '{}')
+    const info = await detectRepoInfo(tempDir)
+    expect(info.packageManager).toBe('npm')
+  })
+
+  it('detects pnpm from pnpm-lock.yaml', async () => {
+    await writeFile(join(tempDir, 'pnpm-lock.yaml'), '')
+    const info = await detectRepoInfo(tempDir)
+    expect(info.packageManager).toBe('pnpm')
+  })
+
+  it('detects yarn from yarn.lock', async () => {
+    await writeFile(join(tempDir, 'yarn.lock'), '')
+    const info = await detectRepoInfo(tempDir)
+    expect(info.packageManager).toBe('yarn')
+  })
+
+  it('detects TypeScript from tsconfig.json', async () => {
+    await writeFile(join(tempDir, 'tsconfig.json'), '{}')
+    const info = await detectRepoInfo(tempDir)
+    expect(info.language).toBe('typescript')
+  })
+
+  it('detects JavaScript from jsconfig.json', async () => {
+    await writeFile(join(tempDir, 'jsconfig.json'), '{}')
+    const info = await detectRepoInfo(tempDir)
+    expect(info.language).toBe('javascript')
+  })
+
+  it('detects Next.js from next.config.mjs', async () => {
+    await writeFile(join(tempDir, 'next.config.mjs'), 'export default {}')
+    const info = await detectRepoInfo(tempDir)
+    expect(info.frameworks).toContain('next')
+  })
+
+  it('detects Astro from astro.config.mjs', async () => {
+    await writeFile(join(tempDir, 'astro.config.mjs'), 'export default {}')
+    const info = await detectRepoInfo(tempDir)
+    expect(info.frameworks).toContain('astro')
+  })
+
+  it('detects NX monorepo from nx.json', async () => {
+    await writeFile(join(tempDir, 'nx.json'), '{}')
+    const info = await detectRepoInfo(tempDir)
+    expect(info.monorepo).toBe('nx')
+  })
+
+  it('detects Supabase from supabase/config.toml', async () => {
+    await mkdir(join(tempDir, 'supabase'), { recursive: true })
+    await writeFile(join(tempDir, 'supabase', 'config.toml'), '')
+    const info = await detectRepoInfo(tempDir)
+    expect(info.databases).toContain('supabase')
+  })
+
+  it('detects Prisma from prisma/schema.prisma', async () => {
+    await mkdir(join(tempDir, 'prisma'), { recursive: true })
+    await writeFile(join(tempDir, 'prisma', 'schema.prisma'), '')
+    const info = await detectRepoInfo(tempDir)
+    expect(info.databases).toContain('prisma')
+  })
+
+  it('detects Vercel from vercel.json', async () => {
+    await writeFile(join(tempDir, 'vercel.json'), '{}')
+    const info = await detectRepoInfo(tempDir)
+    expect(info.deployment).toContain('vercel')
+  })
+
+  it('detects Docker from Dockerfile', async () => {
+    await writeFile(join(tempDir, 'Dockerfile'), 'FROM node:22')
+    const info = await detectRepoInfo(tempDir)
+    expect(info.deployment).toContain('docker')
+  })
+
+  it('detects Playwright from playwright.config.ts', async () => {
+    await writeFile(join(tempDir, 'playwright.config.ts'), 'export default {}')
+    const info = await detectRepoInfo(tempDir)
+    expect(info.testing).toContain('playwright')
+  })
+
+  it('detects GitHub Actions from .github/workflows/', async () => {
+    await mkdir(join(tempDir, '.github', 'workflows'), { recursive: true })
+    const info = await detectRepoInfo(tempDir)
+    expect(info.cicd).toContain('github-actions')
+  })
+
+  it('detects Tailwind from tailwind.config.js', async () => {
+    await writeFile(join(tempDir, 'tailwind.config.js'), 'module.exports = {}')
+    const info = await detectRepoInfo(tempDir)
+    expect(info.styling).toContain('tailwind')
+  })
+
+  it('detects MCP config from .vscode/mcp.json', async () => {
+    await mkdir(join(tempDir, '.vscode'), { recursive: true })
+    await writeFile(join(tempDir, '.vscode', 'mcp.json'), '{}')
+    const info = await detectRepoInfo(tempDir)
+    expect(info.mcpConfig).toBe(true)
+  })
+
+  it('detects packages from package.json dependencies', async () => {
+    await writeFile(
+      join(tempDir, 'package.json'),
+      JSON.stringify({
+        dependencies: { next: '^14.0.0', '@supabase/supabase-js': '^2.0.0' },
+        devDependencies: { vitest: '^1.0.0', tailwindcss: '^3.0.0' },
+      })
+    )
+    const info = await detectRepoInfo(tempDir)
+    expect(info.frameworks).toContain('next')
+    expect(info.databases).toContain('supabase')
+    expect(info.testing).toContain('vitest')
+    expect(info.styling).toContain('tailwind')
+  })
+
+  it('detects corepack packageManager field', async () => {
+    await writeFile(
+      join(tempDir, 'package.json'),
+      JSON.stringify({ packageManager: 'pnpm@9.0.0' })
+    )
+    const info = await detectRepoInfo(tempDir)
+    expect(info.packageManager).toBe('pnpm')
+  })
+
+  it('returns clean object for empty directory', async () => {
+    const info = await detectRepoInfo(tempDir)
+    expect(info).toBeDefined()
+    // No undefined values — only populated fields
+    for (const value of Object.values(info)) {
+      expect(value).not.toBeUndefined()
+    }
+  })
+
+  it('deduplicates config files', async () => {
+    await writeFile(join(tempDir, 'package-lock.json'), '{}')
+    await writeFile(join(tempDir, 'tsconfig.json'), '{}')
+    const info = await detectRepoInfo(tempDir)
+    const unique = new Set(info.configFiles)
+    expect(info.configFiles?.length).toBe(unique.size)
+  })
+
+  it('sorts arrays for stable output', async () => {
+    await writeFile(
+      join(tempDir, 'package.json'),
+      JSON.stringify({
+        dependencies: { next: '1', express: '1' },
+      })
+    )
+    const info = await detectRepoInfo(tempDir)
+    if (info.frameworks && info.frameworks.length > 1) {
+      const sorted = [...info.frameworks].sort()
+      expect(info.frameworks).toEqual(sorted)
+    }
+  })
+
+  it('detects Sanity CMS from sanity.config.ts', async () => {
+    await writeFile(join(tempDir, 'sanity.config.ts'), 'export default {}')
+    const info = await detectRepoInfo(tempDir)
+    expect(info.cms).toContain('sanity')
+  })
+
+  it('auto-adds supabase-auth when supabase is detected', async () => {
+    await mkdir(join(tempDir, 'supabase'), { recursive: true })
+    await writeFile(join(tempDir, 'supabase', 'config.toml'), '')
+    const info = await detectRepoInfo(tempDir)
+    expect(info.auth).toContain('supabase-auth')
+  })
+
+  it('detects multiple tools simultaneously', async () => {
+    await writeFile(join(tempDir, 'next.config.mjs'), '')
+    await writeFile(join(tempDir, 'vercel.json'), '{}')
+    await writeFile(join(tempDir, 'tsconfig.json'), '{}')
+    await writeFile(join(tempDir, 'tailwind.config.js'), '')
+    const info = await detectRepoInfo(tempDir)
+    expect(info.frameworks).toContain('next')
+    expect(info.deployment).toContain('vercel')
+    expect(info.language).toBe('typescript')
+    expect(info.styling).toContain('tailwind')
+  })
+})
+
+// ── mergeStackIntoRepoInfo ─────────────────────────────────────
+
+describe('mergeStackIntoRepoInfo', () => {
+  const emptyStack: StackConfig = { ides: [], techTools: [], teamTools: [] }
+
+  it('returns original info when stack is empty', () => {
+    const info: RepoInfo = { language: 'typescript' }
+    const merged = mergeStackIntoRepoInfo(info, emptyStack)
+    expect(merged.language).toBe('typescript')
+  })
+
+  it('adds CMS tools from techTools', () => {
+    const merged = mergeStackIntoRepoInfo(
+      {},
+      { ides: [], techTools: ['sanity'], teamTools: [] }
+    )
+    expect(merged.cms).toContain('sanity')
+  })
+
+  it('adds database tools from techTools', () => {
+    const merged = mergeStackIntoRepoInfo(
+      {},
+      { ides: [], techTools: ['supabase'], teamTools: [] }
+    )
+    expect(merged.databases).toContain('supabase')
+  })
+
+  it('adds deployment tools from techTools', () => {
+    const merged = mergeStackIntoRepoInfo(
+      {},
+      { ides: [], techTools: ['vercel'], teamTools: [] }
+    )
+    expect(merged.deployment).toContain('vercel')
+  })
+
+  it('sets NX monorepo from techTools', () => {
+    const merged = mergeStackIntoRepoInfo(
+      {},
+      { ides: [], techTools: ['nx'], teamTools: [] }
+    )
+    expect(merged.monorepo).toBe('nx')
+  })
+
+  it('does not overwrite existing monorepo with NX', () => {
+    const merged = mergeStackIntoRepoInfo(
+      { monorepo: 'turborepo' },
+      { ides: [], techTools: ['nx'], teamTools: [] }
+    )
+    expect(merged.monorepo).toBe('turborepo')
+  })
+
+  it('adds PM tools from teamTools', () => {
+    const merged = mergeStackIntoRepoInfo(
+      {},
+      { ides: [], techTools: [], teamTools: ['linear'] }
+    )
+    expect(merged.pm).toContain('linear')
+  })
+
+  it('adds notification tools from teamTools', () => {
+    const merged = mergeStackIntoRepoInfo(
+      {},
+      { ides: [], techTools: [], teamTools: ['slack'] }
+    )
+    expect(merged.notifications).toContain('slack')
+  })
+
+  it('deduplicates when tool already exists', () => {
+    const merged = mergeStackIntoRepoInfo(
+      { cms: ['sanity'] },
+      { ides: [], techTools: ['sanity'], teamTools: [] }
+    )
+    expect(merged.cms).toEqual(['sanity'])
+  })
+
+  it('preserves existing values while adding new ones', () => {
+    const merged = mergeStackIntoRepoInfo(
+      { databases: ['prisma'], language: 'typescript' },
+      { ides: [], techTools: ['supabase'], teamTools: ['linear'] }
+    )
+    expect(merged.databases).toContain('prisma')
+    expect(merged.databases).toContain('supabase')
+    expect(merged.language).toBe('typescript')
+    expect(merged.pm).toContain('linear')
+  })
+})
+
+// ── formatRepoInfo ─────────────────────────────────────────────
+
+describe('formatRepoInfo', () => {
+  it('formats empty info as empty string', () => {
+    expect(formatRepoInfo({})).toBe('')
+  })
+
+  it('includes package manager', () => {
+    const output = formatRepoInfo({ packageManager: 'pnpm' })
+    expect(output).toContain('pnpm')
+  })
+
+  it('includes frameworks', () => {
+    const output = formatRepoInfo({ frameworks: ['next', 'astro'] })
+    expect(output).toContain('next')
+    expect(output).toContain('astro')
+  })
+
+  it('includes all populated fields', () => {
+    const output = formatRepoInfo({
+      packageManager: 'npm',
+      monorepo: 'nx',
+      language: 'typescript',
+      frameworks: ['next'],
+      databases: ['supabase'],
+      cms: ['sanity'],
+      deployment: ['vercel'],
+      testing: ['vitest'],
+      cicd: ['github-actions'],
+      styling: ['tailwind'],
+      auth: ['clerk'],
+    })
+    expect(output).toContain('npm')
+    expect(output).toContain('nx')
+    expect(output).toContain('typescript')
+    expect(output).toContain('next')
+    expect(output).toContain('supabase')
+    expect(output).toContain('sanity')
+    expect(output).toContain('vercel')
+    expect(output).toContain('vitest')
+    expect(output).toContain('github-actions')
+    expect(output).toContain('tailwind')
+    expect(output).toContain('clerk')
+  })
+
+  it('indents lines with 4 spaces', () => {
+    const output = formatRepoInfo({ packageManager: 'npm' })
+    expect(output).toMatch(/^ {4}/)
+  })
+})

package/src/cli/run/executor.test.ts

@@ -0,0 +1,338 @@
+import { describe, it, expect, vi } from 'vitest'
+import { buildPhases, createExecutor, formatDuration } from './executor.js'
+import type { Task, TaskSpec, AgentAdapter, Reporter, TaskResult, RunReport } from '../types.js'
+
+// ── Helpers ────────────────────────────────────────────────────
+
+function makeTask(overrides: Partial<Task> & { id: string; prompt: string }): Task {
+  return {
+    agent: 'developer',
+    timeout: '10m',
+    depends_on: [],
+    files: [],
+    description: overrides.id,
+    ...overrides,
+  }
+}
+
+function makeAdapter(results?: Record<string, { success: boolean; exitCode: number }>): AgentAdapter {
+  return {
+    name: 'test-adapter',
+    isAvailable: async () => true,
+    execute: async (task) => {
+      const r = results?.[task.id] ?? { success: true, exitCode: 0 }
+      return { success: r.success, output: `output-${task.id}`, exitCode: r.exitCode }
+    },
+  }
+}
+
+function makeReporter(): Reporter & {
+  started: string[]; done: TaskResult[]; skipped: string[]; phases: number[]; report: RunReport | null
+} {
+  const tracker = {
+    started: [] as string[],
+    done: [] as TaskResult[],
+    skipped: [] as string[],
+    phases: [] as number[],
+    report: null as RunReport | null,
+    onTaskStart(task: Task) { tracker.started.push(task.id) },
+    onTaskDone(_task: Task, result: TaskResult) { tracker.done.push(result) },
+    onTaskSkipped(task: Task, _reason: string) { tracker.skipped.push(task.id) },
+    onPhaseStart(phase: number) { tracker.phases.push(phase) },
+    onComplete: async (report: RunReport) => { tracker.report = report },
+  }
+  return tracker
+}
+
+// ── buildPhases ────────────────────────────────────────────────
+
+describe('buildPhases', () => {
+  it('puts independent tasks in the same phase', () => {
+    const tasks = [
+      makeTask({ id: 'a', prompt: 'x' }),
+      makeTask({ id: 'b', prompt: 'y' }),
+      makeTask({ id: 'c', prompt: 'z' }),
+    ]
+    const phases = buildPhases(tasks)
+    expect(phases).toHaveLength(1)
+    expect(phases[0]).toHaveLength(3)
+  })
+
+  it('orders dependent tasks into separate phases', () => {
+    const tasks = [
+      makeTask({ id: 'a', prompt: 'x' }),
+      makeTask({ id: 'b', prompt: 'y', depends_on: ['a'] }),
+      makeTask({ id: 'c', prompt: 'z', depends_on: ['b'] }),
+    ]
+    const phases = buildPhases(tasks)
+    expect(phases).toHaveLength(3)
+    expect(phases[0].map((t) => t.id)).toEqual(['a'])
+    expect(phases[1].map((t) => t.id)).toEqual(['b'])
+    expect(phases[2].map((t) => t.id)).toEqual(['c'])
+  })
+
+  it('handles diamond dependency pattern', () => {
+    const tasks = [
+      makeTask({ id: 'a', prompt: 'x' }),
+      makeTask({ id: 'b', prompt: 'y', depends_on: ['a'] }),
+      makeTask({ id: 'c', prompt: 'z', depends_on: ['a'] }),
+      makeTask({ id: 'd', prompt: 'w', depends_on: ['b', 'c'] }),
+    ]
+    const phases = buildPhases(tasks)
+    expect(phases).toHaveLength(3)
+    expect(phases[0].map((t) => t.id)).toEqual(['a'])
+    expect(phases[1].map((t) => t.id).sort()).toEqual(['b', 'c'])
+    expect(phases[2].map((t) => t.id)).toEqual(['d'])
+  })
+
+  it('handles single task', () => {
+    const phases = buildPhases([makeTask({ id: 'solo', prompt: 'x' })])
+    expect(phases).toHaveLength(1)
+    expect(phases[0]).toHaveLength(1)
+  })
+
+  it('handles complex fan-out/fan-in', () => {
+    const tasks = [
+      makeTask({ id: 'root', prompt: 'x' }),
+      makeTask({ id: 'b1', prompt: 'y', depends_on: ['root'] }),
+      makeTask({ id: 'b2', prompt: 'y', depends_on: ['root'] }),
+      makeTask({ id: 'b3', prompt: 'y', depends_on: ['root'] }),
+      makeTask({ id: 'join', prompt: 'z', depends_on: ['b1', 'b2', 'b3'] }),
+    ]
+    const phases = buildPhases(tasks)
+    expect(phases).toHaveLength(3)
+    expect(phases[1]).toHaveLength(3)
+  })
+})
+
+// ── createExecutor ─────────────────────────────────────────────
+
+describe('createExecutor', () => {
+  it('executes all tasks and reports success', async () => {
+    const spec: TaskSpec = {
+      name: 'test-run',
+      concurrency: 2,
+      on_failure: 'continue',
+      adapter: 'test',
+      tasks: [
+        makeTask({ id: 'a', prompt: 'x' }),
+        makeTask({ id: 'b', prompt: 'y' }),
+      ],
+    }
+    const reporter = makeReporter()
+    const executor = createExecutor(spec, makeAdapter(), reporter)
+    const report = await executor.run()
+
+    expect(report.summary.total).toBe(2)
+    expect(report.summary.done).toBe(2)
+    expect(report.summary.failed).toBe(0)
+    expect(reporter.started).toEqual(['a', 'b'])
+  })
+
+  it('skips dependents when a task fails (on_failure: continue)', async () => {
+    const spec: TaskSpec = {
+      name: 'test-run',
+      concurrency: 1,
+      on_failure: 'continue',
+      adapter: 'test',
+      tasks: [
+        makeTask({ id: 'a', prompt: 'x' }),
+        makeTask({ id: 'b', prompt: 'y', depends_on: ['a'] }),
+      ],
+    }
+    const adapter = makeAdapter({ a: { success: false, exitCode: 1 } })
+    const reporter = makeReporter()
+    const executor = createExecutor(spec, adapter, reporter)
+    const report = await executor.run()
+
+    expect(report.summary.failed).toBe(1)
+    expect(report.summary.skipped).toBe(1)
+    expect(reporter.skipped).toContain('b')
+  })
+
+  it('halts all tasks on failure when on_failure: stop', async () => {
+    const spec: TaskSpec = {
+      name: 'test-run',
+      concurrency: 1,
+      on_failure: 'stop',
+      adapter: 'test',
+      tasks: [
+        makeTask({ id: 'a', prompt: 'x' }),
+        makeTask({ id: 'b', prompt: 'y' }),
+        makeTask({ id: 'c', prompt: 'z' }),
+      ],
+    }
+    const adapter = makeAdapter({ a: { success: false, exitCode: 1 } })
+    const reporter = makeReporter()
+    const executor = createExecutor(spec, adapter, reporter)
+    const report = await executor.run()
+
+    expect(report.summary.failed).toBe(1)
+    expect(report.summary.skipped).toBe(2)
+  })
+
+  it('respects concurrency limit', async () => {
+    let maxConcurrent = 0
+    let currentConcurrent = 0
+
+    const adapter: AgentAdapter = {
+      name: 'test',
+      isAvailable: async () => true,
+      execute: async (task) => {
+        currentConcurrent++
+        maxConcurrent = Math.max(maxConcurrent, currentConcurrent)
+        await new Promise((r) => setTimeout(r, 50))
+        currentConcurrent--
+        return { success: true, output: '', exitCode: 0 }
+      },
+    }
+
+    const spec: TaskSpec = {
+      name: 'test',
+      concurrency: 2,
+      on_failure: 'continue',
+      adapter: 'test',
+      tasks: [
+        makeTask({ id: 'a', prompt: 'x' }),
+        makeTask({ id: 'b', prompt: 'y' }),
+        makeTask({ id: 'c', prompt: 'z' }),
+        makeTask({ id: 'd', prompt: 'w' }),
+      ],
+    }
+
+    const executor = createExecutor(spec, adapter, makeReporter())
+    await executor.run()
+
+    expect(maxConcurrent).toBeLessThanOrEqual(2)
+  })
+
+  it('reports phase starts', async () => {
+    const spec: TaskSpec = {
+      name: 'test',
+      concurrency: 1,
+      on_failure: 'continue',
+      adapter: 'test',
+      tasks: [
+        makeTask({ id: 'a', prompt: 'x' }),
+        makeTask({ id: 'b', prompt: 'y', depends_on: ['a'] }),
+      ],
+    }
+    const reporter = makeReporter()
+    const executor = createExecutor(spec, reporter as unknown as AgentAdapter, reporter)
+    // Actually use the adapter
+    const executor2 = createExecutor(spec, makeAdapter(), reporter)
+    await executor2.run()
+
+    expect(reporter.phases).toContain(1)
+    expect(reporter.phases).toContain(2)
+  })
+
+  it('records duration on the report', async () => {
+    const spec: TaskSpec = {
+      name: 'test',
+      concurrency: 1,
+      on_failure: 'continue',
+      adapter: 'test',
+      tasks: [makeTask({ id: 'a', prompt: 'x' })],
+    }
+    const executor = createExecutor(spec, makeAdapter(), makeReporter())
+    const report = await executor.run()
+
+    expect(report.duration).toBeDefined()
+    expect(report.startedAt).toBeDefined()
+    expect(report.completedAt).toBeDefined()
+    expect(report.name).toBe('test')
+  })
+
+  it('handles adapter throwing errors', async () => {
+    const adapter: AgentAdapter = {
+      name: 'failing',
+      isAvailable: async () => true,
+      execute: async () => { throw new Error('Adapter crashed') },
+    }
+    const spec: TaskSpec = {
+      name: 'test',
+      concurrency: 1,
+      on_failure: 'continue',
+      adapter: 'test',
+      tasks: [makeTask({ id: 'a', prompt: 'x' })],
+    }
+    const reporter = makeReporter()
+    const executor = createExecutor(spec, adapter, reporter)
+    const report = await executor.run()
+
+    expect(report.summary.failed).toBe(1)
+    expect(report.tasks[0].output).toContain('Adapter crashed')
+  })
+
+  it('getPhases returns the computed phases', () => {
+    const spec: TaskSpec = {
+      name: 'test',
+      concurrency: 1,
+      on_failure: 'continue',
+      adapter: 'test',
+      tasks: [
+        makeTask({ id: 'a', prompt: 'x' }),
+        makeTask({ id: 'b', prompt: 'y', depends_on: ['a'] }),
+      ],
+    }
+    const executor = createExecutor(spec, makeAdapter(), makeReporter())
+    const phases = executor.getPhases()
+    expect(phases).toHaveLength(2)
+  })
+
+  it('skips transitive dependents on failure', async () => {
+    const spec: TaskSpec = {
+      name: 'test',
+      concurrency: 1,
+      on_failure: 'continue',
+      adapter: 'test',
+      tasks: [
+        makeTask({ id: 'a', prompt: 'x' }),
+        makeTask({ id: 'b', prompt: 'y', depends_on: ['a'] }),
+        makeTask({ id: 'c', prompt: 'z', depends_on: ['b'] }),
+      ],
+    }
+    const adapter = makeAdapter({ a: { success: false, exitCode: 1 } })
+    const reporter = makeReporter()
+    const executor = createExecutor(spec, adapter, reporter)
+    const report = await executor.run()
+
+    expect(report.summary.failed).toBe(1)
+    expect(report.summary.skipped).toBe(2)
+    expect(reporter.skipped).toContain('b')
+    expect(reporter.skipped).toContain('c')
+  })
+})
+
+// ── formatDuration ─────────────────────────────────────────────
+
+describe('formatDuration', () => {
+  it('formats milliseconds', () => {
+    expect(formatDuration(500)).toBe('500ms')
+  })
+
+  it('formats seconds', () => {
+    expect(formatDuration(5000)).toBe('5s')
+  })
+
+  it('formats minutes', () => {
+    expect(formatDuration(120_000)).toBe('2m')
+  })
+
+  it('formats minutes and seconds', () => {
+    expect(formatDuration(125_000)).toBe('2m 5s')
+  })
+
+  it('formats hours', () => {
+    expect(formatDuration(3_600_000)).toBe('1h')
+  })
+
+  it('formats hours and minutes', () => {
+    expect(formatDuration(5_400_000)).toBe('1h 30m')
+  })
+
+  it('handles zero', () => {
+    expect(formatDuration(0)).toBe('0ms')
+  })
+})