@iceinvein/agent-skills 0.1.39 → 0.2.0

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

@@ -2,7 +2,7 @@ import { beforeAll, expect, test } from 'bun:test'
 import type { Highlighter } from 'shiki'
 import { getHighlighter } from '../highlight.ts'
 import { renderFindingsHtml } from '../render-findings.ts'
-import type { ReviewFinding } from '../types.ts'
+import type { PrBrief, ReviewFinding } from '../types.ts'
 
 function f(p: Partial<ReviewFinding> & { id: string; title: string }): ReviewFinding {
   return {
@@ -200,3 +200,153 @@ test('renders pr meta when supplied', () => {
   expect(html).toContain('feat/x')
   expect(html).toContain('deadbeefdead')
 })
+
+const SAMPLE_BRIEF: PrBrief = {
+  purpose:
+    'Adds bounded retries to the upload path so transient S3 failures stop surfacing to users.',
+  changes: ['Wraps the S3 put in a bounded retry', 'Adds a jittered backoff helper'],
+  subsystems: [
+    { name: 'upload', role: 'owns the client-facing put path' },
+    { name: 'storage-client', role: 'wraps the S3 SDK' },
+  ],
+  watchItems: ['The PR body claims idempotency but no request key is sent'],
+  unclear: ['Whether the retry budget interacts with the outer request timeout'],
+}
+
+test('brief header renders purpose, changes, and subsystem chips', () => {
+  const html = renderFindingsHtml({
+    findings: SAMPLE_FINDINGS,
+    postStatus: {},
+    highlighter: hl,
+    brief: SAMPLE_BRIEF,
+  })
+  expect(html).toContain('class="pr-brief"')
+  expect(html).toContain('Adds bounded retries to the upload path')
+  expect(html).toContain('Wraps the S3 put in a bounded retry')
+  expect(html).toContain('class="brief-chip"')
+  expect(html).toContain('>upload<')
+  expect(html).toContain('>storage-client<')
+})
+
+test('brief header omits watchItems and unclear, which are prompt-only', () => {
+  const html = renderFindingsHtml({
+    findings: SAMPLE_FINDINGS,
+    postStatus: {},
+    highlighter: hl,
+    brief: SAMPLE_BRIEF,
+  })
+  expect(html).not.toContain('no request key is sent')
+  expect(html).not.toContain('outer request timeout')
+})
+
+test('no brief means no brief header at all', () => {
+  const html = renderFindingsHtml({ findings: SAMPLE_FINDINGS, postStatus: {}, highlighter: hl })
+  expect(html).not.toContain('class="pr-brief"')
+})
+
+test('an empty subsystem list renders no chip row', () => {
+  const html = renderFindingsHtml({
+    findings: SAMPLE_FINDINGS,
+    postStatus: {},
+    highlighter: hl,
+    brief: { ...SAMPLE_BRIEF, subsystems: [] },
+  })
+  expect(html).toContain('class="pr-brief"')
+  expect(html).not.toContain('brief-subsystems')
+})
+
+test('brief header renders on the empty-findings page too', () => {
+  const html = renderFindingsHtml({
+    findings: [],
+    postStatus: {},
+    highlighter: hl,
+    brief: SAMPLE_BRIEF,
+  })
+  expect(html).toContain('No findings')
+  expect(html).toContain('class="pr-brief"')
+})
+
+test('linked issues render as links when supplied', () => {
+  const html = renderFindingsHtml({
+    findings: SAMPLE_FINDINGS,
+    postStatus: {},
+    highlighter: hl,
+    brief: SAMPLE_BRIEF,
+    issues: [
+      { number: 42, title: 'Uploads fail intermittently', url: 'https://example.test/issues/42' },
+    ],
+  })
+  expect(html).toContain('https://example.test/issues/42')
+  expect(html).toContain('#42')
+})
+
+test('brief content is HTML-escaped', () => {
+  const html = renderFindingsHtml({
+    findings: SAMPLE_FINDINGS,
+    postStatus: {},
+    highlighter: hl,
+    brief: { ...SAMPLE_BRIEF, purpose: 'Fixes <script>alert(1)</script> handling' },
+  })
+  expect(html).not.toContain('<script>alert(1)</script>')
+  expect(html).toContain('&lt;script&gt;')
+})
+
+test('subsystem role and issue title escape quotes in their title="" attribute context', () => {
+  const html = renderFindingsHtml({
+    findings: SAMPLE_FINDINGS,
+    postStatus: {},
+    highlighter: hl,
+    brief: {
+      ...SAMPLE_BRIEF,
+      subsystems: [{ name: 'upload', role: 'owns the put path" onmouseover="alert(1)' }],
+    },
+    issues: [
+      {
+        number: 42,
+        title: 'fails intermittently" onmouseover="alert(2)',
+        url: 'https://example.test/issues/42',
+      },
+    ],
+  })
+  // Raw quote-breakout must never appear unescaped in either attribute.
+  expect(html).not.toContain('path" onmouseover="alert(1)')
+  expect(html).not.toContain('intermittently" onmouseover="alert(2)')
+  // Escaped form must appear instead.
+  expect(html).toContain('path&quot; onmouseover=&quot;alert(1)')
+  expect(html).toContain('intermittently&quot; onmouseover=&quot;alert(2)')
+  // 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)
+})

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

@@ -0,0 +1,165 @@
+import { afterEach, beforeEach, expect, test } from 'bun:test'
+import { existsSync } from 'node:fs'
+import { mkdir, mkdtemp, readdir, readFile, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { DEFAULT_SHARD_BUDGET, groupKey, planShards, shardDiff } from '../shard.ts'
+
+let runDir: string
+
+beforeEach(async () => {
+  runDir = await mkdtemp(join(tmpdir(), 'magpie-shard-'))
+})
+
+afterEach(async () => {
+  await rm(runDir, { recursive: true, force: true })
+})
+
+/** A file chunk with `bodyLines` added lines, shaped like a real patch. */
+function chunk(path: string, bodyLines: number): string {
+  const body = Array.from({ length: bodyLines }, (_, i) => `+line ${i}`).join('\n')
+  return [
+    `diff --git a/${path} b/${path}`,
+    'index 0000000..1111111 100644',
+    `--- a/${path}`,
+    `+++ b/${path}`,
+    `@@ -0,0 +1,${bodyLines} @@`,
+    body,
+    '',
+  ].join('\n')
+}
+
+test('groupKey caps the grouping directory at two segments', () => {
+  expect(groupKey('src/cli/commands/install.ts')).toBe('src/cli')
+  expect(groupKey('src/a.ts')).toBe('src')
+  expect(groupKey('README.md')).toBe('.')
+})
+
+test('planShards keeps a directory group together when it fits', () => {
+  const chunks = [
+    { path: 'src/cli/a.ts', text: '', lines: 100 },
+    { path: 'src/web/b.ts', text: '', lines: 100 },
+    { path: 'src/cli/c.ts', text: '', lines: 100 },
+  ]
+  const shards = planShards(chunks, 1000, 80)
+  expect(shards).toHaveLength(1)
+  // Grouping reorders: both src/cli files are adjacent.
+  expect(shards[0]?.map((c) => c.path)).toEqual(['src/cli/a.ts', 'src/cli/c.ts', 'src/web/b.ts'])
+})
+
+test('planShards splits when the line budget is exceeded', () => {
+  const chunks = [
+    { path: 'src/a/1.ts', text: '', lines: 600 },
+    { path: 'src/b/2.ts', text: '', lines: 600 },
+    { path: 'src/c/3.ts', text: '', lines: 600 },
+  ]
+  const shards = planShards(chunks, 1000, 80)
+  expect(shards).toHaveLength(3)
+})
+
+test('planShards splits when max-files is reached before the budget', () => {
+  const chunks = Array.from({ length: 5 }, (_, i) => ({
+    path: `src/g${i}/f.ts`,
+    text: '',
+    lines: 1,
+  }))
+  const shards = planShards(chunks, 10_000, 2)
+  expect(shards).toHaveLength(3)
+  expect(shards[0]).toHaveLength(2)
+  expect(shards[2]).toHaveLength(1)
+})
+
+test('planShards gives an over-budget file a shard to itself', () => {
+  const chunks = [
+    { path: 'src/a/small.ts', text: '', lines: 10 },
+    { path: 'src/b/huge.ts', text: '', lines: 9000 },
+    { path: 'src/c/other.ts', text: '', lines: 10 },
+  ]
+  const shards = planShards(chunks, 1000, 80)
+  expect(shards).toHaveLength(3)
+  expect(shards[1]?.map((c) => c.path)).toEqual(['src/b/huge.ts'])
+})
+
+test('shardDiff writes a single-shard manifest pointing at diff.patch', async () => {
+  await writeFile(join(runDir, 'diff.patch'), chunk('src/a.ts', 3))
+  const manifest = await shardDiff(runDir)
+  expect(manifest.shards).toHaveLength(1)
+  expect(manifest.shards[0]?.path).toBe('diff.patch')
+  expect(manifest.totalFiles).toBe(1)
+  expect(manifest.budget).toBe(DEFAULT_SHARD_BUDGET)
+  expect(existsSync(join(runDir, 'shards', 'shard-1.patch'))).toBe(false)
+  const onDisk = JSON.parse(await readFile(join(runDir, 'shards', 'manifest.json'), 'utf8'))
+  expect(onDisk.shards[0].files).toEqual(['src/a.ts'])
+})
+
+test('shardDiff writes one patch per shard when the budget forces a split', async () => {
+  const diff = chunk('src/a/one.ts', 200) + chunk('src/b/two.ts', 200)
+  await writeFile(join(runDir, 'diff.patch'), diff)
+  const manifest = await shardDiff(runDir, { budget: 150 })
+  expect(manifest.shards).toHaveLength(2)
+  expect(manifest.shards[0]?.path).toBe('shards/shard-1.patch')
+  const first = await readFile(join(runDir, 'shards', 'shard-1.patch'), 'utf8')
+  expect(first).toContain('diff --git a/src/a/one.ts')
+  expect(first).not.toContain('src/b/two.ts')
+  // diff.patch is a view source, never replaced.
+  const whole = await readFile(join(runDir, 'diff.patch'), 'utf8')
+  expect(whole).toContain('src/a/one.ts')
+  expect(whole).toContain('src/b/two.ts')
+})
+
+test('a re-split into fewer shards leaves no orphaned shard patches behind', async () => {
+  const diff =
+    chunk('src/a/one.ts', 200) + chunk('src/b/two.ts', 200) + chunk('src/c/three.ts', 200)
+  await writeFile(join(runDir, 'diff.patch'), diff)
+  const first = await shardDiff(runDir, { budget: 150 })
+  expect(first.shards).toHaveLength(3)
+  expect(existsSync(join(runDir, 'shards', 'shard-3.patch'))).toBe(true)
+
+  // Re-split with room for two shards. shard-3.patch describes a file set no
+  // shard id owns any more, so it must not survive the new split.
+  const second = await shardDiff(runDir, { budget: 450 })
+  expect(second.shards).toHaveLength(2)
+  const patches = (await readdir(join(runDir, 'shards'))).filter((n) => n.endsWith('.patch')).sort()
+  expect(patches).toEqual(['shard-1.patch', 'shard-2.patch'])
+  expect(existsSync(join(runDir, 'shards', 'manifest.json'))).toBe(true)
+})
+
+test('a re-split down to one shard clears every shard patch and keeps the manifest', async () => {
+  const diff = chunk('src/a/one.ts', 200) + chunk('src/b/two.ts', 200)
+  await writeFile(join(runDir, 'diff.patch'), diff)
+  expect((await shardDiff(runDir, { budget: 150 })).shards).toHaveLength(2)
+  const manifest = await shardDiff(runDir, { budget: 10_000 })
+  expect(manifest.shards).toHaveLength(1)
+  expect(manifest.shards[0]?.path).toBe('diff.patch')
+  // Only the manifest is left: the single-shard entry points at diff.patch, and
+  // diff.patch itself lives outside shards/ and is never touched.
+  expect(await readdir(join(runDir, 'shards'))).toEqual(['manifest.json'])
+  expect(existsSync(join(runDir, 'diff.patch'))).toBe(true)
+})
+
+test('shardDiff handles an empty diff without writing shard files', async () => {
+  await writeFile(join(runDir, 'diff.patch'), '')
+  const manifest = await shardDiff(runDir)
+  expect(manifest.shards).toEqual([])
+  expect(manifest.totalFiles).toBe(0)
+})
+
+test('shardDiff propagates a non-ENOENT read failure instead of treating it as an empty diff', async () => {
+  // Make diff.patch a directory: reading it as text is a real, portable I/O
+  // failure (EISDIR) that is not "file absent" and must not be swallowed.
+  await mkdir(join(runDir, 'diff.patch'))
+  await expect(shardDiff(runDir)).rejects.toThrow()
+})
+
+test('shardDiff treats a diff.patch that does not exist yet as an empty diff', async () => {
+  // No writeFile at all here: diff.patch is genuinely absent, the one case
+  // the ENOENT branch exists to tolerate. Task 4 wires shardDiff into
+  // runSetup and Task 6 reads the manifest unconditionally, so "no diff yet"
+  // must still leave a readable manifest rather than a missing file.
+  expect(existsSync(join(runDir, 'diff.patch'))).toBe(false)
+  const manifest = await shardDiff(runDir)
+  expect(manifest.shards).toEqual([])
+  expect(manifest.totalFiles).toBe(0)
+  expect(manifest.totalLines).toBe(0)
+  expect(existsSync(join(runDir, 'shards', 'manifest.json'))).toBe(true)
+})