@iceinvein/agent-skills 0.23.9 → 0.23.13

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

@@ -55,6 +55,7 @@ const TEMPLATE_DOC = [
   'Candidates: <<CANDIDATES>>',
   'Groups: <<MERGE_CANDIDATES>>',
   'Rules: <<REVIEW_RULES>>',
+  'Raised: <<ALREADY_RAISED>>',
   'Worktree: <<WORKTREE>>',
   'Diff: <<DIFF_PATH>>',
   'Write to: <<OUTPUT_PATH>>',
@@ -90,6 +91,51 @@ test('critic-prompt writes the prompt file from the magpie-critic block and prin
   expect(prompt).toContain(`Write to: ${outputPath}`)
 })
 
+test('critic-prompt fills <<ALREADY_RAISED>> from the PR activity and previous dismissals', async () => {
+  const templatePath = join(runDir, 'critic.md')
+  await writeFile(templatePath, TEMPLATE_DOC)
+  await writeDeduped([finding('a', 'bugs')])
+  await writeFile(
+    join(runDir, 'pr-activity.json'),
+    JSON.stringify({
+      checks: [{ name: 'build', conclusion: 'FAILURE', url: null }],
+      threads: [
+        {
+          file: 'src/a.ts',
+          line: 10,
+          resolved: false,
+          outdated: false,
+          author: 'dave',
+          body: 'Off by one here.',
+          replies: 0,
+          magpie: false,
+        },
+      ],
+      comments: [],
+    }),
+  )
+
+  const exit = await runCriticPrompt(runDir, { templatePath })
+
+  expect(exit).toBe(0)
+  const prompt = await readFile(join(runDir, 'critic-prompt.md'), 'utf8')
+  expect(prompt).toContain(
+    'Raised: Open review threads:\n- src/a.ts:10 (dave, 0 replies): Off by one here.\nWorktree',
+  )
+})
+
+test('critic-prompt fills <<ALREADY_RAISED>> with (none) on a run with no history', async () => {
+  const templatePath = join(runDir, 'critic.md')
+  await writeFile(templatePath, TEMPLATE_DOC)
+  await writeDeduped([finding('a', 'bugs')])
+
+  const exit = await runCriticPrompt(runDir, { templatePath })
+
+  expect(exit).toBe(0)
+  const prompt = await readFile(join(runDir, 'critic-prompt.md'), 'utf8')
+  expect(prompt).toContain('Raised: (none)\n')
+})
+
 test('critic-prompt points <<WORKTREE>> at the review root named in target.json', async () => {
   const templatePath = join(runDir, 'critic.md')
   await writeFile(templatePath, TEMPLATE_DOC)

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

@@ -214,6 +214,7 @@ const ALL_PLACEHOLDERS = [
   'C=<<CANDIDATES>>',
   'M=<<MERGE_CANDIDATES>>',
   'R=<<REVIEW_RULES>>',
+  'A=<<ALREADY_RAISED>>',
   'W=<<WORKTREE>>',
   'D=<<DIFF_PATH>>',
   'O=<<OUTPUT_PATH>>',
@@ -240,6 +241,7 @@ test('three candidates yield one prompt with every placeholder replaced and crit
     ],
     mergeCandidates: [['c1', 'c2']],
     reviewRules: [{ rule: 'no default exports', source: 'CLAUDE.md' }],
+    alreadyRaised: 'Open review threads:\n- src/a.ts:10 (dave, 0 replies): off by one',
     worktree: '/run/worktree',
     diffPath: '/run/diff.patch',
     runDir: '/run',
@@ -265,6 +267,9 @@ test('three candidates yield one prompt with every placeholder replaced and crit
   })
   expect(section(only.prompt, 'M', 'R')).toEqual([['c1', 'c2']])
   expect(only.prompt).toContain('R=- no default exports (CLAUDE.md)\n')
+  expect(only.prompt).toContain(
+    'A=Open review threads:\n- src/a.ts:10 (dave, 0 replies): off by one\n',
+  )
   expect(only.prompt).toContain('W=/run/worktree\n')
   expect(only.prompt).toContain('D=/run/diff.patch\n')
   expect(only.prompt.endsWith('O=/run/critic.json')).toBe(true)
@@ -276,6 +281,7 @@ test('sixty-five candidates at batch size thirty yield three numbered prompts',
     candidates: candidates(65),
     mergeCandidates: [],
     reviewRules: [],
+    alreadyRaised: '(none)',
     worktree: '/run/worktree',
     diffPath: '/run/diff.patch',
     runDir: '/run',
@@ -298,6 +304,7 @@ test('a merge group straddling a batch boundary is placed whole in the batch of
     candidates: candidates(35),
     mergeCandidates: [['c30', 'c31']],
     reviewRules: [],
+    alreadyRaised: '(none)',
     worktree: '/run/worktree',
     diffPath: '/run/diff.patch',
     runDir: '/run',
@@ -319,10 +326,13 @@ test('a template missing placeholders throws naming each missing one', () => {
       candidates: candidates(1),
       mergeCandidates: [],
       reviewRules: [],
+      alreadyRaised: '(none)',
       worktree: '/run/worktree',
       diffPath: '/run/diff.patch',
       runDir: '/run',
       batchSize: 30,
     }),
-  ).toThrow('<<MERGE_CANDIDATES>>, <<REVIEW_RULES>>, <<WORKTREE>>, <<DIFF_PATH>>')
+  ).toThrow(
+    '<<MERGE_CANDIDATES>>, <<REVIEW_RULES>>, <<ALREADY_RAISED>>, <<WORKTREE>>, <<DIFF_PATH>>',
+  )
 })

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

@@ -1,5 +1,5 @@
 import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
-import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises'
+import { appendFile, mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import { runDedupe } from '../dedupe-cmd.ts'
@@ -337,6 +337,25 @@ test('runDedupe names the (focus, shard) pairs that have no findings file', asyn
   })
 })
 
+test('runDedupe does not count a shard skipped at the gate as missing', async () => {
+  await writeManifest(2)
+  for (const focus of LLM_FOCUSES) {
+    await writeFile(
+      join(runDir, 'findings', `${focus}.shard-1.json`),
+      JSON.stringify([f(`${focus}-1`, 'a.ts', 1, `${focus} on shard 1`, focus)]),
+    )
+  }
+  await appendFile(
+    join(runDir, 'log.jsonl'),
+    `${JSON.stringify({ stage: 'shard-coverage', status: 'partial', reviewed: [1], skipped: [2] })}\n`,
+  )
+  const { exit, stdout } = await dedupeCapturingStdout()
+  expect(exit).toBe(0)
+  expect(stdout).not.toContain('missing')
+  const done = await dedupeLogEntry('done')
+  expect(done?.coverage).toEqual({ expected: 5, missing: [] })
+})
+
 test('a single-shard manifest expects the unsharded findings filenames', async () => {
   await writeManifest(1)
   for (const focus of ['security', 'bugs', 'performance', 'code-smells']) {

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

@@ -60,7 +60,7 @@ test('localPrDiff errors when the base branch is not present locally', async ()
   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 () => {
+test('localPrDiff uses the PR head SHA when it is local, whatever a stale refs/magpie/pr-<n> says', async () => {
   const { repoPath, head } = await createGitFixtureRepo()
   repo = repoPath
   // Simulate a previous run's fetch having landed an older commit under the
@@ -75,9 +75,28 @@ test('localPrDiff errors when a stale refs/magpie/pr-<n> ref points at an older
     baseRefName: 'main',
     headRefOid: head,
   })
+  expect(result.ok).toBe(true)
+  if (!result.ok) return
+  expect(result.mergeBase).toBe(staleSha)
+  expect(result.diff).toContain('+export const x = 2')
+})
+
+test('localPrDiff errors when the PR head SHA is missing and refs/magpie/pr-<n> points elsewhere', async () => {
+  const { repoPath, head } = await createGitFixtureRepo()
+  repo = repoPath
+  const staleSha = await git(repoPath, 'rev-parse', `${head}~1`)
+  await git(repoPath, 'update-ref', 'refs/magpie/pr-7', staleSha)
+  const missing = 'deadbeefdeadbeefdeadbeefdeadbeefdeadbeef'
+  const result = await localPrDiff({
+    gitBin: 'git',
+    repoPath,
+    prNumber: 7,
+    baseRefName: 'main',
+    headRefOid: missing,
+  })
   expect(result.ok).toBe(false)
   if (result.ok) return
-  expect(result.error).toContain('stale')
-  expect(result.error).toContain(staleSha)
-  expect(result.error).toContain(head)
+  expect(result.error).toBe(
+    `local PR head ${staleSha} does not match the PR head ${missing}; the local ref is stale`,
+  )
 })

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

@@ -317,3 +317,71 @@ test('runHandoff still prints, stale, when the review root is gone', async () =>
   expect(stdout).toContain(WARNING)
   expect(stderr).toContain('magpie: handoff: could not recompute the diff: ')
 })
+
+test('formatHandoff shows a reproduced finding with its command and repro source', () => {
+  const out = formatHandoff({
+    target: 't',
+    findings: [
+      {
+        ...mustFix,
+        suggestion: undefined,
+        proof: {
+          status: 'reproduced',
+          reason: 'fails as described',
+          repro: {
+            path: 'a.test.ts',
+            command: 'bun test a.test.ts',
+            source: "expect(log).not.toContain('tok')",
+            output: 'received tok',
+          },
+        },
+      },
+    ],
+    stale: false,
+  })
+  expect(out).toContain(
+    "Reproduced with `bun test a.test.ts`:\n```\nexpect(log).not.toContain('tok')\n```",
+  )
+})
+
+test('formatHandoff says why a finding is not proven', () => {
+  const out = formatHandoff({
+    target: 't',
+    findings: [{ ...shouldFix, proof: { status: 'not-proven', reason: 'needs a live database' } }],
+    stale: false,
+  })
+  expect(out).toContain('Not proven: needs a live database')
+})
+
+test('formatHandoff warns which files went unreviewed', () => {
+  const out = formatHandoff({
+    target: 't',
+    findings: [],
+    stale: false,
+    unreviewed: { skipped: [{ id: 3, files: ['docs/d.md', 'src/e.ts'] }] },
+  })
+  expect(out).toBe(
+    '# magpie local review: t\nWarning: Not reviewed: shard 3 (2 files):\n- docs/d.md\n- src/e.ts\n\nNo findings.\n',
+  )
+})
+
+test('formatHandoff lists findings a passing test disproved after the rest', () => {
+  const out = formatHandoff({
+    target: 't',
+    findings: [],
+    stale: false,
+    disproved: [
+      {
+        id: 'bugs-2',
+        file: 'src/cache.ts',
+        line: null,
+        title: 'Cache never evicts',
+        reason: 'evict() runs on every put',
+        repro: { path: 'p', command: 'bun test p', source: 's', output: 'o' },
+      },
+    ],
+  })
+  expect(out).toBe(
+    '# magpie local review: t\n\nNo findings.\n\nDropped because a passing test disproved them:\n- src/cache.ts: Cache never evicts (evict() runs on every put; `bun test p`)\n',
+  )
+})

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

@@ -0,0 +1,232 @@
+import { afterEach, beforeEach, expect, test } from 'bun:test'
+import { mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { readHistory, renderAlreadyRaised, renderHistory } from '../history.ts'
+import type { PrActivity } from '../pr-activity.ts'
+import type { PreviousFindings } from '../previous-findings.ts'
+
+const ACTIVITY: PrActivity = {
+  checks: [
+    { name: 'build', conclusion: 'FAILURE', url: 'https://ci.example/1' },
+    { name: 'lint', conclusion: 'SUCCESS', url: null },
+    { name: 'deploy', conclusion: 'TIMED_OUT', url: null },
+  ],
+  threads: [
+    {
+      file: 'src/upload.ts',
+      line: 42,
+      resolved: false,
+      outdated: false,
+      author: 'dave',
+      body: 'This swallows\n\nthe timeout error.',
+      replies: 2,
+      magpie: false,
+    },
+    {
+      file: 'src/cache.ts',
+      line: 9,
+      resolved: false,
+      outdated: true,
+      author: 'octocat',
+      body: '### High\nCache never evicts\n<!-- magpie:finding id=perf-1 hash=abc -->',
+      replies: 0,
+      magpie: true,
+    },
+    {
+      file: 'src/done.ts',
+      line: 1,
+      resolved: true,
+      outdated: false,
+      author: 'erin',
+      body: 'Fixed already.',
+      replies: 1,
+      magpie: false,
+    },
+  ],
+  comments: [{ author: 'alice', body: 'Does this retry past three attempts?', magpie: false }],
+}
+
+const PREVIOUS: PreviousFindings = {
+  previousRunId: 'pr-7-100',
+  findings: [
+    {
+      id: 'perf-3',
+      fromRunId: 'pr-7-50',
+      file: 'src/cache.ts',
+      line: 9,
+      title: 'Cache never evicts',
+      domain: 'performance',
+      label: 'dismissed',
+      reason: 'not-worth-it',
+    },
+    {
+      id: 'bugs-1',
+      fromRunId: 'pr-7-100',
+      file: 'src/upload.ts',
+      line: 4,
+      title: 'Swallowed error',
+      domain: 'bugs',
+      label: 'posted',
+      anchor: 'unchanged',
+    },
+  ],
+}
+
+test('already-raised lists open threads, comments and dismissals, skipping resolved threads', () => {
+  expect(renderAlreadyRaised({ activity: ACTIVITY, previous: PREVIOUS })).toBe(
+    [
+      'Open review threads:',
+      '- src/upload.ts:42 (dave, 2 replies): This swallows the timeout error.',
+      '- src/cache.ts:9 (magpie, earlier run) [outdated]: ### High Cache never evicts',
+      '',
+      'PR comments:',
+      '- alice: Does this retry past three attempts?',
+      '',
+      'Dismissed by the reviewer in an earlier magpie run:',
+      '- src/cache.ts:9 [not-worth-it]: Cache never evicts',
+    ].join('\n'),
+  )
+})
+
+test('already-raised is (none) when nothing is on the PR and nothing was dismissed', () => {
+  expect(renderAlreadyRaised({ activity: null, previous: null })).toBe('(none)')
+})
+
+test('a long comment is cut to 280 characters with an ellipsis', () => {
+  const long = 'a'.repeat(400)
+  const out = renderAlreadyRaised({
+    activity: { checks: [], threads: [], comments: [{ author: 'bot', body: long, magpie: false }] },
+    previous: null,
+  })
+  expect(out).toBe(`PR comments:\n- bot: ${'a'.repeat(280)}…`)
+})
+
+test('history adds failing checks and the files changed since the last review', () => {
+  const out = renderHistory({
+    activity: ACTIVITY,
+    previous: PREVIOUS,
+    incremental: { previousSha: 'abc1234def', changedSincePrevious: ['src/upload.ts'] },
+  })
+  expect(out).toBe(
+    [
+      '## Already on this PR',
+      '',
+      'The threads, comments and dismissals below were raised before this review. Do not report a finding that repeats one of them: the critic drops repeats. Report it again only when you have something material it lacks, and say what that is.',
+      '',
+      'Open review threads:',
+      '- src/upload.ts:42 (dave, 2 replies): This swallows the timeout error.',
+      '- src/cache.ts:9 (magpie, earlier run) [outdated]: ### High Cache never evicts',
+      '',
+      'PR comments:',
+      '- alice: Does this retry past three attempts?',
+      '',
+      'Dismissed by the reviewer in an earlier magpie run:',
+      '- src/cache.ts:9 [not-worth-it]: Cache never evicts',
+      '',
+      'Leads, not repeats: a finding that explains one of these is wanted.',
+      '',
+      'Failing CI checks (a lead to investigate, not a finding in itself):',
+      '- build: FAILURE (https://ci.example/1)',
+      '- deploy: TIMED_OUT',
+      '',
+      'Files changed since the last review at abc1234 (the whole diff is still your scope):',
+      '- src/upload.ts',
+    ].join('\n'),
+  )
+})
+
+test('history is empty when the run has no activity, no previous run and no incremental', () => {
+  expect(renderHistory({ activity: null, previous: null, incremental: null })).toBe('')
+})
+
+let dir: string
+
+beforeEach(async () => {
+  dir = await mkdtemp(join(tmpdir(), 'magpie-history-'))
+})
+
+afterEach(async () => {
+  await rm(dir, { recursive: true, force: true })
+})
+
+test('readHistory reads the three sidecars from a run dir', async () => {
+  await writeFile(join(dir, 'pr-activity.json'), JSON.stringify(ACTIVITY))
+  await writeFile(join(dir, 'previous-findings.json'), JSON.stringify(PREVIOUS))
+  await writeFile(
+    join(dir, 'incremental.json'),
+    JSON.stringify({
+      previousRunId: 'pr-7-100',
+      previousSha: 'abc1234def',
+      currentSha: 'fff',
+      sameSha: false,
+      changedSincePrevious: ['src/upload.ts'],
+    }),
+  )
+  const history = await readHistory(dir)
+  expect(history.activity?.threads).toHaveLength(3)
+  expect(history.previous?.previousRunId).toBe('pr-7-100')
+  expect(history.incremental).toEqual({
+    previousSha: 'abc1234def',
+    changedSincePrevious: ['src/upload.ts'],
+  })
+})
+
+test('readHistory reads a run with none of the sidecars as empty', async () => {
+  expect(await readHistory(dir)).toEqual({ activity: null, previous: null, incremental: null })
+})
+
+test('readHistory fails on a sidecar that does not parse, naming it', async () => {
+  await writeFile(join(dir, 'pr-activity.json'), '{not json')
+  await expect(readHistory(dir)).rejects.toThrow('pr-activity.json')
+})
+
+test('history with only leads carries the leads heading and no repeats preamble', () => {
+  const out = renderHistory({
+    activity: {
+      checks: [{ name: 'build', conclusion: 'FAILURE', url: null }],
+      threads: [],
+      comments: [],
+    },
+    previous: null,
+    incremental: null,
+  })
+  expect(out).toBe(
+    [
+      '## Already on this PR',
+      '',
+      'Leads, not repeats: a finding that explains one of these is wanted.',
+      '',
+      'Failing CI checks (a lead to investigate, not a finding in itself):',
+      '- build: FAILURE',
+    ].join('\n'),
+  )
+})
+
+test('already-raised leaves out comments from github-actions, which posts CI output', () => {
+  const out = renderAlreadyRaised({
+    activity: {
+      checks: [],
+      threads: [],
+      comments: [
+        { author: 'github-actions', body: '<h2>Coverage Report</h2>', magpie: false },
+        { author: 'coderabbitai', body: 'This retry never backs off.', magpie: false },
+      ],
+    },
+    previous: null,
+  })
+  expect(out).toBe('PR comments:\n- coderabbitai: This retry never backs off.')
+})
+
+test('already-raised is (none) when the only comments are CI output', () => {
+  expect(
+    renderAlreadyRaised({
+      activity: {
+        checks: [],
+        threads: [],
+        comments: [{ author: 'github-actions', body: '<h2>Coverage Report</h2>', magpie: false }],
+      },
+      previous: null,
+    }),
+  ).toBe('(none)')
+})