@iceinvein/agent-skills 0.1.39 → 0.2.0

package/skills/migrate/scripts/__tests__/phase-cmd.test.ts

@@ -0,0 +1,151 @@
+import { afterEach, beforeEach, expect, test } from 'bun:test'
+import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+const CLI = join(import.meta.dir, '..', '..', 'bin', 'migrate.ts')
+
+let target: string
+let source: string
+
+async function migrate(args: string[]): Promise<{ code: number; out: string; err: string }> {
+  const proc = Bun.spawn(['bun', CLI, ...args], { cwd: target, stdout: 'pipe', stderr: 'pipe' })
+  const [out, err] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+  ])
+  await proc.exited
+  return { code: proc.exitCode ?? -1, out, err }
+}
+
+beforeEach(async () => {
+  target = await mkdtemp(join(tmpdir(), 'migrate-phase-'))
+  source = join(target, 'legacy')
+  await Bun.write(join(source, 'app.js'), '// legacy\n')
+  const init = await migrate(['init', '--source', source, '--scope', 'x', '--name', 'target'])
+  expect(init.code).toBe(0)
+})
+
+afterEach(async () => {
+  await rm(target, { recursive: true, force: true })
+})
+
+test('phase with no arguments prints every phase and its status', async () => {
+  const result = await migrate(['phase'])
+  expect(result.code).toBe(0)
+  for (const p of [
+    'probe',
+    'enumerate',
+    'seam',
+    'extract',
+    'parity',
+    'queue',
+    'adjudicate',
+    'handoff',
+  ]) {
+    expect(result.out).toContain(p)
+  }
+  expect(result.out).toContain('pending')
+})
+
+test('phase <name> --status done persists to phases.json', async () => {
+  const set = await migrate(['phase', 'probe', '--status', 'done'])
+  expect(set.code).toBe(0)
+  expect(set.out).toContain('probe is now done')
+  const phases = JSON.parse(await readFile(join(target, '.migrate', 'phases.json'), 'utf8'))
+  expect(phases.phases.probe.status).toBe('done')
+})
+
+test('phase <name> with no status prints just that phase', async () => {
+  await migrate(['phase', 'seam', '--status', 'running'])
+  const result = await migrate(['phase', 'seam'])
+  expect(result.code).toBe(0)
+  expect(result.out).toContain('seam')
+  expect(result.out).toContain('running')
+  expect(result.out).not.toContain('probe')
+})
+
+test('an unknown phase name is a usage error naming the valid set', async () => {
+  const result = await migrate(['phase', 'nonsense', '--status', 'done'])
+  expect(result.code).toBe(2)
+  expect(result.err).toContain('nonsense')
+  expect(result.err).toContain('enumerate')
+})
+
+test('an unknown status is a usage error naming the valid set', async () => {
+  const result = await migrate(['phase', 'probe', '--status', 'finished'])
+  expect(result.code).toBe(2)
+  expect(result.err).toContain('finished')
+  expect(result.err).toContain('blocked')
+})
+
+// Final-review finding, Minor 3: `phase --force-unlock <name> --status <s>`
+// put a flag in the slot the phase name is read from, so the name came back
+// undefined, the write silently became a read, and the command exited 0
+// having moved nothing. `import` and `census` both reject the identical
+// flag-ordering mistake at 2, because their first positional is load-bearing
+// too.
+test('a write-intent flag before the phase name is a usage error, not a silent listing', async () => {
+  // Set a status the correct way first, so phases.json exists and carries a
+  // value the mis-ordered invocation below would visibly overwrite if it were
+  // still being serviced as a write.
+  expect((await migrate(['phase', 'probe', '--status', 'running'])).code).toBe(0)
+
+  const result = await migrate(['phase', '--force-unlock', 'probe', '--status', 'done'])
+  expect(result.code).toBe(2)
+  expect(result.err).toContain('want <name> before --status/--force-unlock')
+  const phases = JSON.parse(await readFile(join(target, '.migrate', 'phases.json'), 'utf8'))
+  expect(phases.phases.probe.status).toBe('running')
+})
+
+test('--status with no phase name at all is the same usage error', async () => {
+  const result = await migrate(['phase', '--status', 'done'])
+  expect(result.code).toBe(2)
+  expect(result.err).toContain('want <name> before --status/--force-unlock')
+})
+
+test('recording a census commits its batch under the record phase', async () => {
+  const record = join(target, 'census.json')
+  await writeFile(
+    record,
+    JSON.stringify({
+      kind: 'lens',
+      surface: 'routes',
+      phase: 'enumerate',
+      directions: {
+        code: { count: 2, evidence: 'rg -n "app.(get|post)" app.js' },
+        nav: { count: 2, evidence: 'read views/index.html link targets' },
+      },
+      total: 2,
+      in_ledger: 0,
+      added: 2,
+      skipped: [],
+      queued: [],
+      batch: 'b-routes-census-001',
+    }),
+  )
+  const result = await migrate(['census', record])
+  expect(result.code).toBe(0)
+  const phases = JSON.parse(await readFile(join(target, '.migrate', 'phases.json'), 'utf8'))
+  const ids = (phases.phases.enumerate.batches as { id: string }[]).map((b) => b.id)
+  expect(ids).toContain('b-routes-census-001')
+})
+
+test('a closer census without a phase is rejected', async () => {
+  const record = join(target, 'closer.json')
+  await writeFile(
+    record,
+    JSON.stringify({
+      kind: 'closer',
+      closer: 'scope-injection',
+      batch: 'b-closer-001',
+      checked: 3,
+      findings: 0,
+      fixed: 0,
+      queued: [],
+    }),
+  )
+  const result = await migrate(['census', record])
+  expect(result.code).toBe(2)
+  expect(result.err).toContain('phase is required')
+})

package/skills/migrate/scripts/__tests__/phases.test.ts

@@ -0,0 +1,70 @@
+import { afterEach, beforeEach, expect, test } from 'bun:test'
+import { mkdir, mkdtemp, readdir, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { isPhase, loadPhases, recordBatch, savePhases, setPhaseStatus } from '../phases.ts'
+
+let root: string
+const NO_SOURCE = '/nonexistent-source'
+
+beforeEach(async () => {
+  root = await mkdtemp(join(tmpdir(), 'migrate-phases-'))
+  await mkdir(join(root, '.migrate'), { recursive: true })
+})
+
+afterEach(async () => {
+  await rm(root, { recursive: true, force: true })
+})
+
+test('loadPhases defaults every phase to pending', async () => {
+  const state = await loadPhases(root)
+  expect(state.enumerate.status).toBe('pending')
+  expect(state.handoff.batches).toEqual([])
+})
+
+test('recordBatch appends and flips the phase to running', async () => {
+  await recordBatch(root, 'enumerate', { id: 'b-routes-code-001', count: 10 }, NO_SOURCE)
+  await recordBatch(root, 'enumerate', { id: 'b-routes-code-002', count: 7 }, NO_SOURCE)
+  const state = await loadPhases(root)
+  expect(state.enumerate.status).toBe('running')
+  expect(state.enumerate.batches.map((b) => b.id)).toEqual([
+    'b-routes-code-001',
+    'b-routes-code-002',
+  ])
+})
+
+test('recordBatch is idempotent on a repeated batch id', async () => {
+  await recordBatch(root, 'enumerate', { id: 'b-1', count: 10 }, NO_SOURCE)
+  await recordBatch(root, 'enumerate', { id: 'b-1', count: 10 }, NO_SOURCE)
+  const state = await loadPhases(root)
+  expect(state.enumerate.batches).toHaveLength(1)
+})
+
+test('recordBatch does not reopen a done phase', async () => {
+  await setPhaseStatus(root, 'enumerate', 'done', NO_SOURCE)
+  await recordBatch(root, 'enumerate', { id: 'b-late', count: 1 }, NO_SOURCE)
+  const state = await loadPhases(root)
+  expect(state.enumerate.status).toBe('done')
+  expect(state.enumerate.batches).toHaveLength(1)
+})
+
+test('isPhase rejects an unknown phase name', () => {
+  expect(isPhase('seam')).toBe(true)
+  expect(isPhase('seams')).toBe(false)
+})
+
+test('loadPhases names the file on malformed JSON', async () => {
+  const path = join(root, '.migrate', 'phases.json')
+  await writeFile(path, '{ this is not json')
+  await expect(loadPhases(root)).rejects.toThrow(/phases.json: malformed JSON/)
+})
+
+test('savePhases cleans up temp file on failure', async () => {
+  const emptyState = await loadPhases(root)
+  const phaseFile = join(root, '.migrate', 'phases.json')
+  await mkdir(phaseFile)
+  await expect(savePhases(root, emptyState, NO_SOURCE)).rejects.toThrow()
+  const migrateFiles = await readdir(join(root, '.migrate'))
+  const tmpFiles = migrateFiles.filter((f) => f.endsWith('.tmp'))
+  expect(tmpFiles.length).toBe(0)
+})