@iceinvein/agent-skills 0.1.39 → 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 () => {
@@ -45,3 +52,86 @@ test('fetchPr returns ok=false when gh exits non-zero', async () => {
     expect(result.error).toBeDefined()
   }
 })
+
+test('PR_VIEW_FIELDS requests commit messages and linked issues', async () => {
+  const { PR_VIEW_FIELDS } = await import('../gh.ts')
+  const fields = PR_VIEW_FIELDS.split(',')
+  expect(fields).toContain('commits')
+  expect(fields).toContain('closingIssuesReferences')
+  // The pre-existing fields must survive the edit.
+  for (const field of ['number', 'title', 'body', 'url', 'files', 'headRefOid']) {
+    expect(fields).toContain(field)
+  }
+})
+
+test('fetchPr carries commits and linked issues into pr.json', async () => {
+  const result = await fetchPr({ ghBin: FAKE_GH, prNumber: 1234, runDir })
+  expect(result.ok).toBe(true)
+  const pr = JSON.parse(await readFile(join(runDir, 'pr.json'), 'utf8'))
+  expect(Array.isArray(pr.commits)).toBe(true)
+  expect(pr.commits[0].messageHeadline).toBe('Add retry handling to the upload path')
+  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__/preview-cmd.test.ts

@@ -208,3 +208,19 @@ test('bundled fixture covers all five focus domains', async () => {
     expect(html).toContain(`data-domain="${domain}"`)
   }
 })
+
+test('bundled fixture brief.json renders the PR brief header', async () => {
+  await runPreview({
+    page: 'findings',
+    stage: DEFAULT_STAGE,
+    outDir: workDir,
+    openInBrowser: false,
+  })
+  const html = await readFile(join(workDir, 'findings.html'), 'utf8')
+  expect(html).toContain('class="pr-brief"')
+  // Unique to fixtures/example-pr/brief.json; would not appear from any other
+  // part of the fixture or the page shell.
+  expect(html).toContain(
+    'Adds bounded retries to the upload path so transient S3 failures stop surfacing to end users as hard errors.',
+  )
+})

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

@@ -84,3 +84,48 @@ test('refreshFindings sets data-run-id from the run directory basename', async (
   const expectedId = runDir.split('/').pop()
   expect(fresh).toContain(`data-run-id="${expectedId}"`)
 })
+
+test('refreshFindings carries the brief header through, so archives keep it on re-render', async () => {
+  await writeFile(join(runDir, 'findings.final.json'), JSON.stringify([]))
+  await writeFile(
+    join(runDir, 'brief.json'),
+    JSON.stringify({
+      purpose: 'Adds bounded retries to the upload path.',
+      changes: ['Wraps the S3 put in a bounded retry'],
+      subsystems: [{ name: 'upload', role: 'owns the put path' }],
+      watchItems: [],
+      unclear: [],
+    }),
+  )
+  const result = await refreshFindings(runDir)
+  expect(result.refreshed).toBe(true)
+  const fresh = await readFile(join(runDir, 'screen', 'findings.html'), 'utf8')
+  expect(fresh).toContain('class="pr-brief"')
+  expect(fresh).toContain('Adds bounded retries to the upload path.')
+})
+
+test('refreshFindings omits the brief header when brief.json is absent', async () => {
+  await writeFile(join(runDir, 'findings.final.json'), JSON.stringify([]))
+  await refreshFindings(runDir)
+  const fresh = await readFile(join(runDir, 'screen', 'findings.html'), 'utf8')
+  expect(fresh).not.toContain('class="pr-brief"')
+})
+
+test('refreshFindings carries linked issues from pr.json through the brief header', async () => {
+  await writeFile(join(runDir, 'findings.final.json'), JSON.stringify([]))
+  await writeFile(
+    join(runDir, 'pr.json'),
+    JSON.stringify({
+      number: 1234,
+      headRefName: 'feature-x',
+      headRefOid: 'deadbeef',
+      closingIssuesReferences: [
+        { number: 42, title: 'Uploads fail', url: 'https://example.test/issues/42' },
+      ],
+    }),
+  )
+  await writeFile(join(runDir, 'brief.json'), JSON.stringify({ purpose: 'Fixes uploads.' }))
+  await refreshFindings(runDir)
+  const fresh = await readFile(join(runDir, 'screen', 'findings.html'), 'utf8')
+  expect(fresh).toContain('https://example.test/issues/42')
+})

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

@@ -1,5 +1,5 @@
 import { afterEach, beforeEach, expect, test } from 'bun:test'
-import { mkdir, mkdtemp, readdir, 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 { runRender } from '../render-cmd.ts'
@@ -115,3 +115,175 @@ test('findings render includes files and diff when provided', async () => {
   expect(html).toContain('data-file-pane="src/app.ts"')
   expect(html).toContain('data-file-pane="src/util.ts"')
 })
+
+test('findings render includes the brief header when brief.json is present', async () => {
+  await writeFile(join(runDir, 'findings.final.json'), JSON.stringify([]))
+  await writeFile(
+    join(runDir, 'brief.json'),
+    JSON.stringify({
+      purpose: 'Adds bounded retries to the upload path.',
+      changes: ['Wraps the S3 put in a bounded retry'],
+      subsystems: [{ name: 'upload', role: 'owns the put path' }],
+      watchItems: [],
+      unclear: [],
+    }),
+  )
+  expect(await runRender(runDir, 'findings')).toBe(0)
+  const html = await readFile(join(runDir, 'screen', 'findings.html'), 'utf8')
+  expect(html).toContain('class="pr-brief"')
+  expect(html).toContain('Adds bounded retries to the upload path.')
+})
+
+test('findings render omits the brief header when brief.json is absent', async () => {
+  await writeFile(join(runDir, 'findings.final.json'), JSON.stringify([]))
+  expect(await runRender(runDir, 'findings')).toBe(0)
+  const html = await readFile(join(runDir, 'screen', 'findings.html'), 'utf8')
+  expect(html).not.toContain('class="pr-brief"')
+})
+
+test('a malformed brief.json degrades to no header instead of failing the render', async () => {
+  await writeFile(join(runDir, 'findings.final.json'), JSON.stringify([]))
+  await writeFile(join(runDir, 'brief.json'), '{ this is not json')
+  expect(await runRender(runDir, 'findings')).toBe(0)
+  const html = await readFile(join(runDir, 'screen', 'findings.html'), 'utf8')
+  expect(html).not.toContain('class="pr-brief"')
+})
+
+test('linked issues from pr.json render in the brief header', async () => {
+  await writeFile(join(runDir, 'findings.final.json'), JSON.stringify([]))
+  await writeFile(
+    join(runDir, 'pr.json'),
+    JSON.stringify({
+      number: 1234,
+      headRefName: 'feature-x',
+      headRefOid: 'deadbeef',
+      closingIssuesReferences: [
+        { number: 42, title: 'Uploads fail', url: 'https://example.test/issues/42' },
+      ],
+    }),
+  )
+  await writeFile(join(runDir, 'brief.json'), JSON.stringify({ purpose: 'Fixes uploads.' }))
+  expect(await runRender(runDir, 'findings')).toBe(0)
+  const html = await readFile(join(runDir, 'screen', 'findings.html'), 'utf8')
+  expect(html).toContain('https://example.test/issues/42')
+})
+
+test('issue entries with a missing, zero, or negative number are dropped, not defaulted to 0', async () => {
+  await writeFile(join(runDir, 'findings.final.json'), JSON.stringify([]))
+  await writeFile(
+    join(runDir, 'pr.json'),
+    JSON.stringify({
+      number: 1234,
+      headRefName: 'feature-x',
+      headRefOid: 'deadbeef',
+      closingIssuesReferences: [
+        { number: 42, title: 'Uploads fail', url: 'https://example.test/issues/42' },
+        { title: 'Missing number', url: 'https://example.test/issues/missing' },
+        { number: 0, title: 'Zero number', url: 'https://example.test/issues/zero' },
+        { number: -1, title: 'Negative number', url: 'https://example.test/issues/negative' },
+      ],
+    }),
+  )
+  await writeFile(join(runDir, 'brief.json'), JSON.stringify({ purpose: 'Fixes uploads.' }))
+  expect(await runRender(runDir, 'findings')).toBe(0)
+  const html = await readFile(join(runDir, 'screen', 'findings.html'), 'utf8')
+  expect(html).toContain('https://example.test/issues/42')
+  expect(html).not.toContain('https://example.test/issues/missing')
+  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>')
+})