@iceinvein/agent-skills 0.1.40 → 0.2.0

package/skills/magpie/scripts/__tests__/gh.test.ts

@@ -3,10 +3,13 @@ import { mkdtemp, readFile, rm } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import { fetchPr } from '../gh.ts'
+import { createGitFixtureRepo } from './helpers/git-fixture.ts'
 
 const FAKE_GH = new URL('../../fixtures/fake-gh.sh', import.meta.url).pathname
+const FAKE_GH_NODIFF = new URL('../../fixtures/fake-gh-nodiff.sh', import.meta.url).pathname
 
 let runDir: string
+let repo = ''
 
 beforeEach(async () => {
   runDir = await mkdtemp(join(tmpdir(), 'magpie-gh-'))
@@ -14,6 +17,10 @@ beforeEach(async () => {
 
 afterEach(async () => {
   await rm(runDir, { recursive: true, force: true })
+  if (repo) {
+    await rm(repo, { recursive: true, force: true })
+    repo = ''
+  }
 })
 
 test('fetchPr writes pr.json and diff.patch', async () => {
@@ -66,3 +73,65 @@ test('fetchPr carries commits and linked issues into pr.json', async () => {
   expect(Array.isArray(pr.closingIssuesReferences)).toBe(true)
   expect(pr.closingIssuesReferences[0]).toMatchObject({ number: 42 })
 })
+
+test('fetchPr falls back to local git when gh pr diff fails', async () => {
+  const { repoPath, head } = await createGitFixtureRepo()
+  repo = repoPath
+  const result = await fetchPr({
+    ghBin: FAKE_GH_NODIFF,
+    gitBin: 'git',
+    prNumber: 7,
+    runDir,
+    cwd: repo,
+    env: { MAGPIE_FAKE_HEAD_OID: head },
+  })
+  expect(result.ok).toBe(true)
+  if (!result.ok) return
+  expect(result.source).toBe('git')
+  expect(result.mergeBase).toMatch(/^[0-9a-f]{40}$/)
+  const diff = await readFile(join(runDir, 'diff.patch'), 'utf8')
+  expect(diff).toContain('export const x = 2')
+})
+
+test('fetchPr falls back when gh returns an empty diff for a non-empty PR', async () => {
+  const { repoPath, head } = await createGitFixtureRepo()
+  repo = repoPath
+  const result = await fetchPr({
+    ghBin: FAKE_GH_NODIFF,
+    gitBin: 'git',
+    prNumber: 7,
+    runDir,
+    cwd: repo,
+    env: { MAGPIE_FAKE_HEAD_OID: head, MAGPIE_FAKE_DIFF_MODE: 'empty' },
+  })
+  expect(result.ok).toBe(true)
+  if (!result.ok) return
+  expect(result.source).toBe('git')
+  const diff = await readFile(join(runDir, 'diff.patch'), 'utf8')
+  expect(diff).toContain('export const x = 2')
+})
+
+test('fetchPr reports source gh when gh succeeds', async () => {
+  const result = await fetchPr({ ghBin: FAKE_GH, prNumber: 1234, runDir })
+  expect(result.ok).toBe(true)
+  if (!result.ok) return
+  expect(result.source).toBe('gh')
+  expect(result.mergeBase).toBeUndefined()
+})
+
+test('fetchPr fails when gh refuses and the head SHA is not local', async () => {
+  const { repoPath } = await createGitFixtureRepo()
+  repo = repoPath
+  const result = await fetchPr({
+    ghBin: FAKE_GH_NODIFF,
+    gitBin: 'git',
+    prNumber: 7,
+    runDir,
+    cwd: repo,
+    // No MAGPIE_FAKE_HEAD_OID, so pr.json carries a SHA this repo has never seen.
+  })
+  expect(result.ok).toBe(false)
+  if (result.ok) return
+  expect(result.error).toContain('cannot resolve PR head')
+  expect(result.error).toContain('406')
+})

package/skills/magpie/scripts/__tests__/git-diff.test.ts

@@ -0,0 +1,83 @@
+import { afterEach, expect, test } from 'bun:test'
+import { rm } from 'node:fs/promises'
+import { localPrDiff } from '../git-diff.ts'
+import { createGitFixtureRepo, git } from './helpers/git-fixture.ts'
+
+let repo = ''
+
+afterEach(async () => {
+  if (repo) {
+    await rm(repo, { recursive: true, force: true })
+    repo = ''
+  }
+})
+
+test('localPrDiff produces the three-dot diff from the merge base', async () => {
+  const { repoPath, head } = await createGitFixtureRepo()
+  repo = repoPath
+  const result = await localPrDiff({
+    gitBin: 'git',
+    repoPath,
+    prNumber: 7,
+    baseRefName: 'main',
+    headRefOid: head,
+  })
+  expect(result.ok).toBe(true)
+  if (!result.ok) return
+  expect(result.diff).toContain('export const x = 2')
+  // b.ts landed on main after the branch point. A two-dot diff against the
+  // base tip would show it as a deletion; the three-dot diff must not.
+  expect(result.diff).not.toContain('b.ts')
+})
+
+test('localPrDiff errors when the head SHA is not present locally', async () => {
+  const { repoPath } = await createGitFixtureRepo()
+  repo = repoPath
+  const result = await localPrDiff({
+    gitBin: 'git',
+    repoPath,
+    prNumber: 7,
+    baseRefName: 'main',
+    headRefOid: '0'.repeat(40),
+  })
+  expect(result.ok).toBe(false)
+  if (result.ok) return
+  expect(result.error).toContain('cannot resolve PR head')
+})
+
+test('localPrDiff errors when the base branch is not present locally', async () => {
+  const { repoPath, head } = await createGitFixtureRepo()
+  repo = repoPath
+  const result = await localPrDiff({
+    gitBin: 'git',
+    repoPath,
+    prNumber: 7,
+    baseRefName: 'no-such-branch',
+    headRefOid: head,
+  })
+  expect(result.ok).toBe(false)
+  if (result.ok) return
+  expect(result.error).toContain('cannot resolve base branch')
+})
+
+test('localPrDiff errors when a stale refs/magpie/pr-<n> ref points at an older commit', async () => {
+  const { repoPath, head } = await createGitFixtureRepo()
+  repo = repoPath
+  // Simulate a previous run's fetch having landed an older commit under the
+  // PR ref, with no origin remote configured to refresh it from. head~1 is
+  // the pre-branch "base" commit: a valid, resolvable, genuinely older commit.
+  const staleSha = await git(repoPath, 'rev-parse', `${head}~1`)
+  await git(repoPath, 'update-ref', 'refs/magpie/pr-7', staleSha)
+  const result = await localPrDiff({
+    gitBin: 'git',
+    repoPath,
+    prNumber: 7,
+    baseRefName: 'main',
+    headRefOid: head,
+  })
+  expect(result.ok).toBe(false)
+  if (result.ok) return
+  expect(result.error).toContain('stale')
+  expect(result.error).toContain(staleSha)
+  expect(result.error).toContain(head)
+})

package/skills/magpie/scripts/__tests__/helpers/git-fixture.ts

@@ -0,0 +1,47 @@
+import { mkdtemp, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+/** Spawn `git` in `cwd` and return trimmed stdout, throwing on a non-zero exit. */
+export async function git(cwd: string, ...args: string[]): Promise<string> {
+  const proc = Bun.spawn(['git', ...args], { cwd, stdout: 'pipe', stderr: 'pipe' })
+  const stdout = await new Response(proc.stdout).text()
+  const exit = await proc.exited
+  if (exit !== 0) {
+    const stderr = await new Response(proc.stderr).text()
+    throw new Error(`git ${args.join(' ')} exit ${exit}: ${stderr}`)
+  }
+  return stdout.trim()
+}
+
+export type GitFixtureRepo = {
+  repoPath: string
+  head: string
+  baseTip: string
+}
+
+/**
+ * A fresh repo with `main` and a `feature-x` branch one commit ahead, plus a
+ * commit on `main` after the branch point so a two-dot diff would differ
+ * from a three-dot one. Shared by gh.test.ts and git-diff.test.ts, which both
+ * exercise the local-git PR-diff fallback against a real clone.
+ */
+export async function createGitFixtureRepo(): Promise<GitFixtureRepo> {
+  const repoPath = await mkdtemp(join(tmpdir(), 'magpie-git-fixture-'))
+  await git(repoPath, 'init', '-b', 'main')
+  await git(repoPath, 'config', 'user.email', 'test@example.com')
+  await git(repoPath, 'config', 'user.name', 'Test')
+  await writeFile(join(repoPath, 'a.ts'), 'export const x = 1\n')
+  await git(repoPath, 'add', '.')
+  await git(repoPath, 'commit', '-m', 'base')
+  await git(repoPath, 'checkout', '-b', 'feature-x')
+  await writeFile(join(repoPath, 'a.ts'), 'export const x = 2\n')
+  await git(repoPath, 'commit', '-am', 'change x')
+  const head = await git(repoPath, 'rev-parse', 'HEAD')
+  await git(repoPath, 'checkout', 'main')
+  await writeFile(join(repoPath, 'b.ts'), 'export const y = 9\n')
+  await git(repoPath, 'add', '.')
+  await git(repoPath, 'commit', '-m', 'unrelated base commit')
+  const baseTip = await git(repoPath, 'rev-parse', 'HEAD')
+  return { repoPath, head, baseTip }
+}

package/skills/magpie/scripts/__tests__/path-filter.test.ts

@@ -159,3 +159,30 @@ test('filterDiff: include records not-in-include reason', () => {
   })
   expect(excluded.find((e) => e.path === 'bun.lock')?.pattern).toBe('not-in-include')
 })
+
+test('DEFAULT_EXCLUDES covers generated .NET sources', () => {
+  const generated = [
+    'src/Data/Migrations/20260801_AddUsers.Designer.cs',
+    'src/Data/Migrations/AppDbContextModelSnapshot.cs',
+    'src/Generated/Api.g.cs',
+    'src/Generated/Api.g.i.cs',
+    'src/Forms/MainForm.designer.vb',
+  ]
+  for (const path of generated) {
+    expect(matchesAny(path, DEFAULT_EXCLUDES)).not.toBeNull()
+  }
+})
+
+test('DEFAULT_EXCLUDES leaves hand-written C# and docs alone', () => {
+  // The migration itself is reviewable; only its generated designer is not.
+  const reviewable = [
+    'src/Data/Migrations/20260801_AddUsers.cs',
+    'src/Services/UserService.cs',
+    'docs/architecture.md',
+    'docs/work/notes.md',
+    'README.md',
+  ]
+  for (const path of reviewable) {
+    expect(matchesAny(path, DEFAULT_EXCLUDES)).toBeNull()
+  }
+})

package/skills/magpie/scripts/__tests__/render-cmd.test.ts

@@ -192,3 +192,98 @@ test('issue entries with a missing, zero, or negative number are dropped, not de
   expect(html).not.toContain('https://example.test/issues/zero')
   expect(html).not.toContain('https://example.test/issues/negative')
 })
+
+test('progress sums specialist counts across shards', async () => {
+  await mkdir(join(runDir, 'shards'), { recursive: true })
+  await writeFile(
+    join(runDir, 'shards', 'manifest.json'),
+    JSON.stringify({
+      budget: 6000,
+      maxFiles: 80,
+      totalFiles: 2,
+      totalLines: 20,
+      shards: [
+        { id: 1, path: 'shards/shard-1.patch', files: ['a.ts'], lines: 10 },
+        { id: 2, path: 'shards/shard-2.patch', files: ['b.ts'], lines: 10 },
+      ],
+    }),
+  )
+  await writeFile(
+    join(runDir, 'log.jsonl'),
+    [
+      JSON.stringify({ stage: 'specialists', status: 'running' }),
+      JSON.stringify({
+        stage: 'specialist',
+        focus: 'security',
+        shard: 1,
+        status: 'done',
+        findings: 2,
+      }),
+      JSON.stringify({
+        stage: 'specialist',
+        focus: 'security',
+        shard: 2,
+        status: 'done',
+        findings: 3,
+      }),
+      JSON.stringify({ stage: 'specialist', focus: 'bugs', shard: 1, status: 'done', findings: 1 }),
+    ].join('\n'),
+  )
+  const exit = await runRender(runDir, 'progress')
+  expect(exit).toBe(0)
+  const html = await readFile(join(runDir, 'screen', 'progress.html'), 'utf8')
+  expect(html).toContain('Five reviewers across 2 shards')
+  // security is 2 + 3, not 3.
+  expect(html).toContain('security <span class="count">5</span>')
+})
+
+/** Log with the specialists stage in flight, which is the only state where the
+ *  shard count reaches the rendered wording. */
+async function specialistsRunning(): Promise<void> {
+  await writeFile(
+    join(runDir, 'log.jsonl'),
+    JSON.stringify({ stage: 'specialists', status: 'running' }),
+  )
+}
+
+test('a malformed shards/manifest.json degrades to the unsharded progress wording', async () => {
+  await mkdir(join(runDir, 'shards'), { recursive: true })
+  await writeFile(join(runDir, 'shards', 'manifest.json'), '{ "shards": [ truncated')
+  await specialistsRunning()
+  expect(await runRender(runDir, 'progress')).toBe(0)
+  const html = await readFile(join(runDir, 'screen', 'progress.html'), 'utf8')
+  expect(html).toContain('Five reviewers reading the diff in parallel')
+  expect(html).not.toMatch(/across \S+ shards/)
+})
+
+test('a manifest with shards: [] renders the unsharded progress wording', async () => {
+  // A lockfile-only PR filters down to nothing, and shardDiff writes an
+  // otherwise-normal manifest with no shards. Zero must not read as "across 0
+  // shards"; stage 4 treats it as the unsharded path.
+  await mkdir(join(runDir, 'shards'), { recursive: true })
+  await writeFile(
+    join(runDir, 'shards', 'manifest.json'),
+    JSON.stringify({ budget: 6000, maxFiles: 80, totalFiles: 0, totalLines: 0, shards: [] }),
+  )
+  await specialistsRunning()
+  expect(await runRender(runDir, 'progress')).toBe(0)
+  const html = await readFile(join(runDir, 'screen', 'progress.html'), 'utf8')
+  expect(html).toContain('Five reviewers reading the diff in parallel')
+  expect(html).not.toContain('across 0 shards')
+  expect(html).not.toMatch(/across \S+ shards/)
+})
+
+test('progress re-dispatch of one shard replaces rather than doubles its count', async () => {
+  await writeFile(
+    join(runDir, 'log.jsonl'),
+    [
+      JSON.stringify({ stage: 'specialists', status: 'running' }),
+      JSON.stringify({ stage: 'specialist', focus: 'bugs', shard: 1, status: 'done', findings: 4 }),
+      JSON.stringify({ stage: 'specialist', focus: 'bugs', shard: 1, status: 'done', findings: 2 }),
+    ].join('\n'),
+  )
+  const exit = await runRender(runDir, 'progress')
+  expect(exit).toBe(0)
+  const html = await readFile(join(runDir, 'screen', 'progress.html'), 'utf8')
+  expect(html).toContain('bugs <span class="count">2</span>')
+})

package/skills/magpie/scripts/__tests__/render-findings.test.ts

@@ -317,3 +317,36 @@ test('subsystem role and issue title escape quotes in their title="" attribute c
   // purpose escaping (already covered above) must remain intact alongside this.
   expect(html).toContain('Adds bounded retries to the upload path')
 })
+
+test('findings header notes a locally-built diff', () => {
+  const html = renderFindingsHtml({
+    findings: [],
+    postStatus: {},
+    pr: { number: 7, branch: 'feature-x', headSha: 'abc123abc123' },
+    diffSource: { source: 'git', mergeBase: 'a'.repeat(40) },
+    highlighter: hl,
+  })
+  expect(html).toContain('local clone')
+  expect(html).toContain('aaaaaaaaaaaa')
+})
+
+test('findings header stays quiet when the diff came from gh', () => {
+  const html = renderFindingsHtml({
+    findings: [],
+    postStatus: {},
+    pr: { number: 7, branch: 'feature-x', headSha: 'abc123abc123' },
+    diffSource: { source: 'gh', mergeBase: null },
+    highlighter: hl,
+  })
+  expect(html).not.toContain('local clone')
+})
+
+test('findings header stays quiet when there is no diff source at all', () => {
+  const html = renderFindingsHtml({
+    findings: [],
+    postStatus: {},
+    pr: { number: 7, branch: 'feature-x', headSha: 'abc123abc123' },
+    highlighter: hl,
+  })
+  expect(html).not.toContain('local clone')
+})

package/skills/magpie/scripts/__tests__/render-progress.test.ts

@@ -157,3 +157,45 @@ test('progress-pane block replaces diff-pane on the progress page', () => {
   expect(html).toContain('data-role="progress-pane"')
   expect(html).toContain('Indexing repo symbols')
 })
+
+test('progress names the shard count while specialists run', () => {
+  const html = renderProgressHtml({
+    prNumber: 7,
+    headSha: 'abc123abc123',
+    branch: 'feature-x',
+    stages: {
+      setup: 'done',
+      context: 'done',
+      specialists: 'running',
+      dedupe: 'pending',
+      critic: 'pending',
+      'peer-review': 'pending',
+      report: 'pending',
+      post: 'pending',
+    },
+    specialistCounts: {},
+    shardCount: 6,
+  })
+  expect(html).toContain('Five reviewers across 6 shards')
+})
+
+test('progress keeps the single-shard wording when there is one shard', () => {
+  const html = renderProgressHtml({
+    prNumber: 7,
+    headSha: 'abc123abc123',
+    branch: 'feature-x',
+    stages: {
+      setup: 'done',
+      context: 'done',
+      specialists: 'running',
+      dedupe: 'pending',
+      critic: 'pending',
+      'peer-review': 'pending',
+      report: 'pending',
+      post: 'pending',
+    },
+    specialistCounts: {},
+    shardCount: 1,
+  })
+  expect(html).toContain('Five reviewers reading the diff in parallel')
+})

package/skills/magpie/scripts/__tests__/setup-cmd.test.ts

@@ -1,5 +1,5 @@
 import { afterEach, beforeEach, expect, test } from 'bun:test'
-import { mkdtemp, readdir, readFile, rm, writeFile } from 'node:fs/promises'
+import { mkdir, mkdtemp, readdir, readFile, rm, writeFile } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import { runSetup } from '../setup-cmd.ts'
@@ -179,3 +179,85 @@ test('runSetup with failing gh removes any partial state', async () => {
   expect(contents).not.toContain('worktree')
   expect(contents).not.toContain('pr.json')
 })
+
+test('runSetup shards the filtered diff and logs the result', async () => {
+  const exit = await runSetup({
+    runDir,
+    prNumber: 1234,
+    repoPath: repo,
+    deps: { bun: 'bun', gh: FAKE_GH, codex: 'echo', git: 'git' },
+  })
+  expect(exit).toBe(0)
+  const manifest = JSON.parse(await readFile(join(runDir, 'shards', 'manifest.json'), 'utf8'))
+  expect(manifest.shards.length).toBeGreaterThanOrEqual(1)
+  // The fake PR is one small file, so it stays a single-shard passthrough.
+  expect(manifest.shards[0].path).toBe('diff.patch')
+  const log = await readFile(join(runDir, 'log.jsonl'), 'utf8')
+  const shardEntry = log
+    .split('\n')
+    .filter(Boolean)
+    .map((l) => JSON.parse(l))
+    .find((e) => e.stage === 'shard')
+  expect(shardEntry).toMatchObject({ status: 'done', shards: 1 })
+})
+
+test('runSetup cleans up a populated shards/ when worktree creation fails after sharding', async () => {
+  // `git worktree add` refuses a target path that already exists and is
+  // non-empty, which forces the worktree step to fail *after* fetchPr,
+  // applyPathFilter, and runShard have already run successfully, without
+  // needing a fake git binary.
+  await mkdir(join(runDir, 'worktree'), { recursive: true })
+  await writeFile(join(runDir, 'worktree', 'occupied'), 'x')
+
+  const exit = await runSetup({
+    runDir,
+    prNumber: 1234,
+    repoPath: repo,
+    deps: { bun: 'bun', gh: FAKE_GH, codex: 'echo', git: 'git' },
+  })
+  expect(exit).toBe(5)
+
+  const log = await readFile(join(runDir, 'log.jsonl'), 'utf8')
+  const entries = log
+    .split('\n')
+    .filter(Boolean)
+    .map((l) => JSON.parse(l))
+  // Sharding really did happen before the worktree failure: this isn't a
+  // false pass from the worktree step failing before shard ever ran.
+  expect(entries.find((e) => e.stage === 'shard')).toMatchObject({ status: 'done', shards: 1 })
+  expect(entries.find((e) => e.stage === 'worktree')).toMatchObject({ status: 'error' })
+
+  const contents = await readdir(runDir).catch(() => [])
+  expect(contents).not.toContain('shards')
+  expect(contents).not.toContain('worktree')
+})
+
+test('runSetup treats a shardDiff throw as a hard stop: logs, cleans up, exits 6', async () => {
+  // shardDiff creates $RUN_DIR/shards via a plain recursive mkdir. Seeding
+  // 'shards' as a regular file ahead of time forces that mkdir to throw
+  // EEXIST, a genuine non-ENOENT failure out of shardDiff. diff.patch itself
+  // can't be used for this: fetchPr and applyPathFilter both write it earlier
+  // in the pipeline, so pre-seeding it as something unreadable would fail
+  // before the shard step is ever reached.
+  await writeFile(join(runDir, 'shards'), 'not a directory')
+
+  const exit = await runSetup({
+    runDir,
+    prNumber: 1234,
+    repoPath: repo,
+    deps: { bun: 'bun', gh: FAKE_GH, codex: 'echo', git: 'git' },
+  })
+  expect(exit).toBe(6)
+
+  const log = await readFile(join(runDir, 'log.jsonl'), 'utf8')
+  const entries = log
+    .split('\n')
+    .filter(Boolean)
+    .map((l) => JSON.parse(l))
+  const shardEntry = entries.find((e) => e.stage === 'shard')
+  expect(shardEntry).toMatchObject({ status: 'error' })
+  expect(typeof (shardEntry as { error: unknown }).error).toBe('string')
+
+  const contents = await readdir(runDir).catch(() => [])
+  expect(contents.filter((c) => c !== 'log.jsonl')).toHaveLength(0)
+})