@iceinvein/agent-skills 0.23.9 → 0.23.13

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

@@ -2,7 +2,8 @@ import { afterEach, beforeEach, expect, test } from 'bun:test'
 import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
-import { buildIncrementalContext, findPreviousRun } from '../incremental.ts'
+import { buildIncrementalContext, changedFilesSince, findPreviousRun } from '../incremental.ts'
+import { createGitFixtureRepo, git } from './helpers/git-fixture.ts'
 
 let home: string
 
@@ -14,15 +15,17 @@ afterEach(async () => {
   await rm(home, { recursive: true, force: true })
 })
 
+const PR_URL = 'https://github.com/octocat/Hello-World/pull/42'
+
 async function seedRun(id: string, prJson: Record<string, unknown>): Promise<string> {
   const dir = join(home, id)
   await mkdir(dir, { recursive: true })
-  await writeFile(join(dir, 'pr.json'), JSON.stringify(prJson))
+  await writeFile(join(dir, 'pr.json'), JSON.stringify({ url: PR_URL, ...prJson }))
   return dir
 }
 
 test('findPreviousRun returns null when no prior runs exist', async () => {
-  const result = await findPreviousRun(42, join(home, 'pr-42-100'), home)
+  const result = await findPreviousRun(42, PR_URL, join(home, 'pr-42-100'), home)
   expect(result).toBeNull()
 })
 
@@ -30,7 +33,7 @@ test('findPreviousRun returns the most recent prior run for the PR', async () =>
   await seedRun('pr-42-100', { headRefOid: 'aaa' })
   await seedRun('pr-42-200', { headRefOid: 'bbb' })
   const currentRun = join(home, 'pr-42-300')
-  const result = await findPreviousRun(42, currentRun, home)
+  const result = await findPreviousRun(42, PR_URL, currentRun, home)
   expect(result?.runId).toBe('pr-42-200')
 })
 
@@ -38,26 +41,43 @@ test('findPreviousRun excludes the current run from candidates', async () => {
   await seedRun('pr-42-100', { headRefOid: 'aaa' })
   const currentRun = join(home, 'pr-42-200')
   await mkdir(currentRun, { recursive: true })
-  const result = await findPreviousRun(42, currentRun, home)
+  const result = await findPreviousRun(42, PR_URL, currentRun, home)
   expect(result?.runId).toBe('pr-42-100')
 })
 
 test('findPreviousRun ignores other PR numbers', async () => {
   await seedRun('pr-99-100', { headRefOid: 'other' })
-  const result = await findPreviousRun(42, join(home, 'pr-42-200'), home)
+  const result = await findPreviousRun(42, PR_URL, join(home, 'pr-42-200'), home)
+  expect(result).toBeNull()
+})
+
+test('findPreviousRun ignores a run of the same PR number in another repository', async () => {
+  await seedRun('pr-42-100', { headRefOid: 'mine' })
+  await seedRun('pr-42-200', {
+    headRefOid: 'theirs',
+    url: 'https://github.com/someone/else/pull/42',
+  })
+  const result = await findPreviousRun(42, PR_URL, join(home, 'pr-42-300'), home)
+  expect(result?.runId).toBe('pr-42-100')
+})
+
+test('findPreviousRun skips a run whose pr.json has no url, since its repository is unknown', async () => {
+  await mkdir(join(home, 'pr-42-100'), { recursive: true })
+  await writeFile(join(home, 'pr-42-100', 'pr.json'), JSON.stringify({ headRefOid: 'aaa' }))
+  const result = await findPreviousRun(42, PR_URL, join(home, 'pr-42-200'), home)
   expect(result).toBeNull()
 })
 
 test('findPreviousRun matches archived runs', async () => {
   await seedRun('pr-42-100.archived-200', { headRefOid: 'old' })
-  const result = await findPreviousRun(42, join(home, 'pr-42-300'), home)
+  const result = await findPreviousRun(42, PR_URL, join(home, 'pr-42-300'), home)
   expect(result?.runId).toBe('pr-42-100.archived-200')
 })
 
 test('findPreviousRun skips candidates with missing pr.json', async () => {
   await mkdir(join(home, 'pr-42-100'), { recursive: true })
   await seedRun('pr-42-50', { headRefOid: 'older' })
-  const result = await findPreviousRun(42, join(home, 'pr-42-200'), home)
+  const result = await findPreviousRun(42, PR_URL, join(home, 'pr-42-200'), home)
   expect(result?.runId).toBe('pr-42-50')
 })
 
@@ -85,3 +105,34 @@ test('buildIncrementalContext returns null when either sha is missing', () => {
   const noCurr = buildIncrementalContext({}, { runId: 'x', prJson: { headRefOid: 'a' } })
   expect(noCurr).toBeNull()
 })
+
+test('changedFilesSince lists the files changed between the two shas', async () => {
+  const fixture = await createGitFixtureRepo()
+  try {
+    const base = await git(fixture.repoPath, 'rev-parse', 'feature-x~1')
+    const files = await changedFilesSince({
+      gitBin: 'git',
+      repoPath: fixture.repoPath,
+      fromSha: base,
+      toSha: fixture.head,
+    })
+    expect(files).toEqual(['a.ts'])
+  } finally {
+    await rm(fixture.repoPath, { recursive: true, force: true })
+  }
+})
+
+test('changedFilesSince is null when the earlier sha is not in the clone', async () => {
+  const fixture = await createGitFixtureRepo()
+  try {
+    const files = await changedFilesSince({
+      gitBin: 'git',
+      repoPath: fixture.repoPath,
+      fromSha: '0123456789abcdef0123456789abcdef01234567',
+      toSha: fixture.head,
+    })
+    expect(files).toBeNull()
+  } finally {
+    await rm(fixture.repoPath, { recursive: true, force: true })
+  }
+})

package/skills/magpie/scripts/__tests__/pipeline-e2e.test.ts

@@ -89,7 +89,7 @@ test('setup -> dedupe -> render(progress) -> render(findings) -> cleanup compose
   expect(findingsHtml.includes('class="annot-body')).toBe(true)
   expect(findingsHtml.includes('class="issue-card')).toBe(true)
 
-  expect(await runCleanup({ runDir, repoPath: repo, gitBin: 'git' })).toBe(0)
+  expect(await runCleanup({ runDir, repoPath: repo, gitBin: 'git', ghBin: FAKE_GH })).toBe(0)
   const parent = dirname(runDir)
   const entries = await readdir(parent)
   expect(entries.find((e) => e.startsWith(`${basename(runDir)}.archived-`))).toBeDefined()

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

@@ -381,6 +381,23 @@ test('formatReviewSummaryBody renders incremental trailer with new commits', ()
   expect(body).toContain('abcdef0')
 })
 
+test('formatReviewSummaryBody carries the previous-run line under the incremental trailer', () => {
+  const body = formatReviewSummaryBody([], {
+    incremental: { previousSha: 'abcdef0123456', sameSha: false },
+    previousRun: 'Last review: 3 posted · 2 on changed code · 1 on unchanged code',
+  })
+  expect(body).toContain(
+    '<sub>Incremental review since `abcdef0`</sub>\n\n<sub>Last review: 3 posted · 2 on changed code · 1 on unchanged code</sub>',
+  )
+})
+
+test('formatReviewSummaryBody says which shards went unreviewed', () => {
+  const body = formatReviewSummaryBody([], {
+    unreviewed: 'Not reviewed: shards 2, 3 (3 files)',
+  })
+  expect(body).toContain('<sub>Not reviewed: shards 2, 3 (3 files)</sub>')
+})
+
 test('formatReviewSummaryBody renders re-review trailer when sameSha', () => {
   const body = formatReviewSummaryBody([], {
     incremental: { previousSha: 'abcdef0123456', sameSha: true },
@@ -622,3 +639,44 @@ test('runPost writes the given via onto each successful post log entry', async (
   const ok = (await logEntries(runDir)).filter((e) => e.status === 'ok')
   expect(ok.map((e) => ({ id: e.id, via: e.via }))).toEqual([{ id: 'sec-1', via: 'cli' }])
 })
+
+test('formatInlineBody folds a reproduced finding repro into a details block', () => {
+  const body = formatInlineBody({
+    ...findingA,
+    line: 12,
+    proof: {
+      status: 'reproduced',
+      reason: 'fails as described',
+      repro: {
+        path: 'secret.test.ts',
+        command: 'bun test secret.test.ts',
+        source: 'expect(env).not.toContain("sk_")',
+        output: 'expected not to contain sk_',
+      },
+    },
+  } as never)
+  expect(body).toContain(
+    [
+      '<details><summary>Reproduced with <code>bun test secret.test.ts</code></summary>',
+      '',
+      '```',
+      'expect(env).not.toContain("sk_")',
+      '```',
+      '',
+      '```',
+      'expected not to contain sk_',
+      '```',
+      '',
+      '</details>',
+    ].join('\n'),
+  )
+})
+
+test('formatInlineBody leaves a not-proven note out of the posted comment', () => {
+  const body = formatInlineBody({
+    ...findingA,
+    line: 12,
+    proof: { status: 'not-proven', reason: 'needs a live database' },
+  } as never)
+  expect(body).not.toContain('needs a live database')
+})

package/skills/magpie/scripts/__tests__/pr-activity.test.ts

@@ -0,0 +1,281 @@
+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'
+import { fetchPrActivity } from '../pr-activity.ts'
+
+const PR_URL = 'https://github.com/octocat/Hello-World/pull/7'
+
+const VIEW = {
+  statusCheckRollup: [
+    {
+      __typename: 'CheckRun',
+      name: 'build',
+      status: 'COMPLETED',
+      conclusion: 'FAILURE',
+      detailsUrl: 'https://ci.example/1',
+    },
+    {
+      __typename: 'StatusContext',
+      context: 'lint',
+      state: 'SUCCESS',
+      targetUrl: 'https://ci.example/2',
+    },
+    { __typename: 'CheckRun', name: 'e2e', status: 'IN_PROGRESS', conclusion: '', detailsUrl: '' },
+  ],
+  comments: [
+    { author: { login: 'alice' }, body: 'Does this retry past three attempts?' },
+    { author: { login: 'octocat' }, body: '<!-- magpie:summary -->\n**Magpie review**' },
+  ],
+  reviews: [
+    { author: { login: 'bob' }, body: '', state: 'APPROVED' },
+    { author: { login: 'carol' }, body: 'Please add a test for the timeout.', state: 'COMMENTED' },
+  ],
+}
+
+function threadPage(nodes: unknown[], endCursor: string | null): unknown {
+  return {
+    data: {
+      repository: {
+        pullRequest: {
+          reviewThreads: { pageInfo: { hasNextPage: endCursor !== null, endCursor }, nodes },
+        },
+      },
+    },
+  }
+}
+
+const THREAD_OPEN = {
+  path: 'src/upload.ts',
+  line: 42,
+  originalLine: 40,
+  isResolved: false,
+  isOutdated: false,
+  comments: {
+    totalCount: 3,
+    nodes: [{ author: { login: 'dave' }, body: 'This swallows the timeout error.' }],
+  },
+}
+
+const THREAD_MAGPIE = {
+  path: 'src/cache.ts',
+  line: null,
+  originalLine: 9,
+  isResolved: true,
+  isOutdated: true,
+  comments: {
+    totalCount: 1,
+    nodes: [
+      {
+        author: { login: 'octocat' },
+        body: '### High\nCache never evicts\n<!-- magpie:finding id=perf-1 hash=abc -->',
+      },
+    ],
+  },
+}
+
+let dir: string
+
+beforeEach(async () => {
+  dir = await mkdtemp(join(tmpdir(), 'magpie-activity-'))
+})
+
+afterEach(async () => {
+  await rm(dir, { recursive: true, force: true })
+})
+
+/**
+ * A fake gh that answers the activity `pr view` from view.json and each
+ * `api graphql` page from page-<cursor>.json (page-start.json with no cursor),
+ * recording every invocation's arguments to calls.log.
+ */
+async function fakeGh(view: unknown, pages: Record<string, unknown>): Promise<string> {
+  await writeFile(join(dir, 'view.json'), JSON.stringify(view))
+  for (const [cursor, page] of Object.entries(pages)) {
+    await writeFile(join(dir, `page-${cursor}.json`), JSON.stringify(page))
+  }
+  const script = join(dir, 'gh.sh')
+  await writeFile(
+    script,
+    [
+      '#!/usr/bin/env bash',
+      // One line per call: the query argument spans several lines.
+      `printf '%s\\n' "$(echo "$*" | tr '\\n' ' ')" >> "${dir}/calls.log"`,
+      'if [[ "$1 $2" == "pr view" ]]; then',
+      `  cat "${dir}/view.json"; exit 0`,
+      'fi',
+      'if [[ "$1 $2" == "api graphql" ]]; then',
+      '  cursor=start',
+      '  for arg in "$@"; do',
+      '    case "$arg" in after=*) cursor=$(echo "$arg" | sed "s/^after=//") ;; esac',
+      '  done',
+      `  cat "${dir}/page-$cursor.json"; exit 0`,
+      'fi',
+      'echo "unsupported: $*" >&2; exit 1',
+    ].join('\n'),
+  )
+  await Bun.spawn(['chmod', '+x', script]).exited
+  return script
+}
+
+test('checks are normalised to name, conclusion and url, in-progress ones as their status', async () => {
+  const gh = await fakeGh(VIEW, { start: threadPage([], null) })
+  const result = await fetchPrActivity({ ghBin: gh, prNumber: 7, prUrl: PR_URL, runDir: dir })
+  expect(result.ok).toBe(true)
+  if (!result.ok) return
+  expect(result.activity.checks).toEqual([
+    { name: 'build', conclusion: 'FAILURE', url: 'https://ci.example/1' },
+    { name: 'lint', conclusion: 'SUCCESS', url: 'https://ci.example/2' },
+    { name: 'e2e', conclusion: 'IN_PROGRESS', url: null },
+  ])
+})
+
+test('top-level comments and non-empty review bodies are kept, magpie summary excluded', async () => {
+  const gh = await fakeGh(VIEW, { start: threadPage([], null) })
+  const result = await fetchPrActivity({ ghBin: gh, prNumber: 7, prUrl: PR_URL, runDir: dir })
+  if (!result.ok) throw new Error(result.error)
+  expect(result.activity.comments).toEqual([
+    { author: 'alice', body: 'Does this retry past three attempts?', magpie: false },
+    { author: 'carol', body: 'Please add a test for the timeout.', magpie: false },
+  ])
+})
+
+test('review threads carry file, line, state, first comment and reply count, flagging magpie', async () => {
+  const gh = await fakeGh(VIEW, { start: threadPage([THREAD_OPEN, THREAD_MAGPIE], null) })
+  const result = await fetchPrActivity({ ghBin: gh, prNumber: 7, prUrl: PR_URL, runDir: dir })
+  if (!result.ok) throw new Error(result.error)
+  expect(result.activity.threads).toEqual([
+    {
+      file: 'src/upload.ts',
+      line: 42,
+      resolved: false,
+      outdated: false,
+      author: 'dave',
+      body: 'This swallows the timeout error.',
+      replies: 2,
+      magpie: false,
+    },
+    {
+      file: 'src/cache.ts',
+      line: 9,
+      resolved: true,
+      outdated: true,
+      author: 'octocat',
+      body: '### High\nCache never evicts\n<!-- magpie:finding id=perf-1 hash=abc -->',
+      replies: 0,
+      magpie: true,
+    },
+  ])
+})
+
+test('every page of review threads is fetched', async () => {
+  const second = { ...THREAD_OPEN, path: 'src/second.ts' }
+  const gh = await fakeGh(VIEW, {
+    start: threadPage([THREAD_OPEN], 'CURSOR1'),
+    CURSOR1: threadPage([second], null),
+  })
+  const result = await fetchPrActivity({ ghBin: gh, prNumber: 7, prUrl: PR_URL, runDir: dir })
+  if (!result.ok) throw new Error(result.error)
+  expect(result.activity.threads.map((t) => t.file)).toEqual(['src/upload.ts', 'src/second.ts'])
+})
+
+test('the activity is written to pr-activity.json in the run dir', async () => {
+  const gh = await fakeGh(VIEW, { start: threadPage([THREAD_OPEN], null) })
+  const result = await fetchPrActivity({ ghBin: gh, prNumber: 7, prUrl: PR_URL, runDir: dir })
+  if (!result.ok) throw new Error(result.error)
+  const written = JSON.parse(await readFile(join(dir, 'pr-activity.json'), 'utf8'))
+  expect(written.threads[0].file).toBe('src/upload.ts')
+  expect(written.checks[0].name).toBe('build')
+})
+
+test('the thread query targets the owner, repo and number from the PR url', async () => {
+  const gh = await fakeGh(VIEW, { start: threadPage([], null) })
+  await fetchPrActivity({ ghBin: gh, prNumber: 7, prUrl: PR_URL, runDir: dir })
+  const calls = await readFile(join(dir, 'calls.log'), 'utf8')
+  const graphql = calls.split('\n').find((l) => l.startsWith('api graphql')) ?? ''
+  expect(graphql).toContain('owner=octocat')
+  expect(graphql).toContain('repo=Hello-World')
+  expect(graphql).toContain('number=7')
+})
+
+test('a failing gh call fails the fetch with its stderr', async () => {
+  const script = join(dir, 'gh.sh')
+  await writeFile(script, '#!/usr/bin/env bash\necho "HTTP 403: rate limited" >&2\nexit 1\n')
+  await Bun.spawn(['chmod', '+x', script]).exited
+  const result = await fetchPrActivity({ ghBin: script, prNumber: 7, prUrl: PR_URL, runDir: dir })
+  expect(result.ok).toBe(false)
+  if (result.ok) return
+  expect(result.error).toContain('HTTP 403: rate limited')
+})
+
+test('a graphql response with errors fails the fetch, naming them', async () => {
+  const gh = await fakeGh(VIEW, {
+    start: { data: null, errors: [{ message: 'Could not resolve to a Repository' }] },
+  })
+  const result = await fetchPrActivity({ ghBin: gh, prNumber: 7, prUrl: PR_URL, runDir: dir })
+  expect(result.ok).toBe(false)
+  if (result.ok) return
+  expect(result.error).toContain('Could not resolve to a Repository')
+})
+
+test('a PR url that names no owner and repo fails the fetch', async () => {
+  const gh = await fakeGh(VIEW, { start: threadPage([], null) })
+  const result = await fetchPrActivity({
+    ghBin: gh,
+    prNumber: 7,
+    prUrl: 'not a url',
+    runDir: dir,
+  })
+  expect(result.ok).toBe(false)
+})
+
+test('a deleted user reads as ghost, the name GitHub shows for one', async () => {
+  const view = {
+    statusCheckRollup: [],
+    comments: [{ author: null, body: 'Old question' }],
+    reviews: [],
+  }
+  const gh = await fakeGh(view, { start: threadPage([], null) })
+  const result = await fetchPrActivity({ ghBin: gh, prNumber: 7, prUrl: PR_URL, runDir: dir })
+  if (!result.ok) throw new Error(result.error)
+  expect(result.activity.comments).toEqual([
+    { author: 'ghost', body: 'Old question', magpie: false },
+  ])
+})
+
+test('a thread whose first comment was deleted is left out', async () => {
+  const emptied = { ...THREAD_OPEN, comments: { totalCount: 0, nodes: [] } }
+  const gh = await fakeGh(VIEW, { start: threadPage([emptied, THREAD_MAGPIE], null) })
+  const result = await fetchPrActivity({ ghBin: gh, prNumber: 7, prUrl: PR_URL, runDir: dir })
+  if (!result.ok) throw new Error(result.error)
+  expect(result.activity.threads.map((t) => t.file)).toEqual(['src/cache.ts'])
+})
+
+test('a review body holding several magpie findings is split into one comment each', async () => {
+  const body = [
+    'Overall fine.',
+    '**First finding**\n<!-- magpie:finding id=bugs-1 hash=a -->',
+    '**Second finding**\n<!-- magpie:finding id=bugs-2 hash=b -->',
+  ].join('\n\n---\n\n')
+  const view = {
+    statusCheckRollup: [],
+    comments: [],
+    reviews: [{ author: { login: 'octocat' }, body, state: 'COMMENTED' }],
+  }
+  const gh = await fakeGh(view, { start: threadPage([], null) })
+  const result = await fetchPrActivity({ ghBin: gh, prNumber: 7, prUrl: PR_URL, runDir: dir })
+  if (!result.ok) throw new Error(result.error)
+  expect(result.activity.comments).toEqual([
+    { author: 'octocat', body: 'Overall fine.', magpie: false },
+    {
+      author: 'octocat',
+      body: '**First finding**\n<!-- magpie:finding id=bugs-1 hash=a -->',
+      magpie: true,
+    },
+    {
+      author: 'octocat',
+      body: '**Second finding**\n<!-- magpie:finding id=bugs-2 hash=b -->',
+      magpie: true,
+    },
+  ])
+})

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

@@ -53,9 +53,9 @@ test('renders both pages by default from the bundled fixture', async () => {
   expect(findings).toContain('medium')
   expect(findings).toContain('low')
   expect(progress).toContain('PR #1337')
-  // Default stage is report-done so the connector should fill 7/7 segments
+  // Default stage is report-done so the connector should fill 8/8 segments
   // before the final post stage.
-  expect(progress).toContain('--done-count: 7')
+  expect(progress).toContain('--done-count: 8')
 })
 
 test('honors --page findings: progress is not rendered', async () => {
@@ -154,8 +154,8 @@ test('--done-count in the progress page reflects the chosen preset', async () =>
     { stage: 'setup-done', expectedDone: 1 },
     { stage: 'specialists-done', expectedDone: 3 },
     { stage: 'critic-done', expectedDone: 5 },
-    { stage: 'report-done', expectedDone: 7 },
-    { stage: 'post-done', expectedDone: 8 },
+    { stage: 'report-done', expectedDone: 8 },
+    { stage: 'post-done', expectedDone: 9 },
   ]
   for (const { stage, expectedDone } of cases) {
     const stageDir = join(workDir, stage)