@iceinvein/agent-skills 0.1.29 → 0.1.31

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iceinvein/agent-skills",
-  "version": "0.1.29",
+  "version": "0.1.31",
   "description": "Install agent skills into AI coding tools",
   "author": "iceinvein",
   "license": "MIT",

package/skills/index.json

@@ -197,7 +197,7 @@
     "name": "magpie",
     "description": "Interactive PR review pipeline. Runs five parallel specialist subagents (security, bugs, performance, code-smells, architecture), dedupes findings, applies a critic rubric, peer-reviews via codex exec, and serves an interactive HTML report for selecting findings to post via gh. Bundles a Bun CLI installed onto PATH via the skill's postinstall step. Use when the user asks to review a GitHub pull request.",
     "type": "prompt",
-    "version": "0.3.0"
+    "version": "0.4.1"
   },
   {
     "name": "module-secret-auditor",

package/skills/magpie/SKILL.md

@@ -32,6 +32,12 @@ magpie setup "$RUN_DIR" --pr $PR_NUMBER --repo "$REPO"
 
 If exit is non-zero, surface stderr verbatim and stop. The CLI removes the worktree and subdirs on failure; the run directory itself plus `log.jsonl` are kept for diagnostics.
 
+Setup automatically filters lockfiles, build output, generated source, and snapshot fixtures from `diff.patch` before specialists see it. Users can override by placing `.magpie.json` at the repo root: `{"exclude": [...glob], "include": [...glob], "useDefaults": true|false}`. When anything is filtered, the raw diff is preserved as `$RUN_DIR/diff.full.patch` and the exclusion list as `$RUN_DIR/excluded-files.json`.
+
+When a prior run exists for the same PR (active or archived under `~/.magpie/`), setup writes `$RUN_DIR/incremental.json` with `{previousRunId, previousSha, currentSha, sameSha}`. The post stage surfaces this as a "Incremental review since `<sha>`" trailer on the summary comment.
+
+Setup also runs a deterministic test-coverage check: when the diff contains zero test or spec files anywhere, each non-test source file with `>= 10` added code lines gets a `domain: "tests"` finding written to `$RUN_DIR/findings/tests.json`. This is a sixth domain that flows through dedupe/critic/peer-review alongside the five LLM specialists. No specialist subagent is dispatched for it.
+
 ### 2. Serve
 
 Start the HTML server in the background using the Bash tool with `run_in_background: true`:
@@ -48,35 +54,7 @@ Render the first progress paint:
 magpie render "$RUN_DIR" progress
 ```
 
-### 3. Context (optional)
-
-If the `mcp__code-intelligence__search_code` tool is available in this conversation, build the context bundle by calling code-intelligence MCP tools for each changed file and writing the result to `$RUN_DIR/pr-context.json`. If MCP is not available, log `{stage: context, status: skipped, reason: mcp-unavailable}` to `$RUN_DIR/log.jsonl` and continue. Re-render progress.
-
-Expected shape of `pr-context.json`:
-
-```json
-{
-  "symbols": [
-    {
-      "name": "createProject",
-      "kind": "function",
-      "file": "apps/server/src/resolvers/Mutation/createProject.ts",
-      "line": 8,
-      "definition": "<source of the symbol, trimmed>",
-      "references": [
-        { "file": "apps/server/src/resolvers/Mutation/index.ts", "line": 5, "context": "<one-line snippet>" }
-      ],
-      "tests": [
-        { "file": "apps/server/src/resolvers/Mutation/__tests__/createProject.test.ts", "line": 12, "context": "<one-line snippet>" }
-      ]
-    }
-  ]
-}
-```
-
-Cap `references` at 20 per symbol; include only tests that import or call the symbol.
-
-### 4. Specialists
+### 3. Specialists
 
 Dispatch the five specialist subagents in a single message using five Agent tool calls in parallel. For each focus in (security, bugs, performance, code-smells, architecture), the prompt is:
 
@@ -86,7 +64,6 @@ Dispatch the five specialist subagents in a single message using five Agent tool
 You are reviewing PR #<PR_NUMBER>.
 Working directory: $RUN_DIR/worktree
 Diff: $RUN_DIR/diff.patch
-Code context (if exists): $RUN_DIR/pr-context.json
 
 ## Output Contract
 
@@ -129,19 +106,23 @@ After each subagent returns, append `{stage: specialist, focus: <focus>, status:
 
 If all five specialists fail (no findings files written), log `{stage: specialists, status: error}` and stop. Otherwise mark `{stage: specialists, status: done}`.
 
-### 5. Dedupe
+### 4. Dedupe
 
 ```
-magpie dedupe "$RUN_DIR"
+magpie dedupe "$RUN_DIR" [--threshold <0-10>]
 ```
 
+`magpie dedupe` also runs a deterministic evidence check against the worktree: findings whose `file` is missing or whose `line` is out of range are dropped. Drops are logged and recorded to `$RUN_DIR/evidence-dropped.json`. The check is skipped if the worktree is no longer present (archived run replay).
+
+Each finding receives a derived 0-10 `score` from its risk fields. Findings below `--threshold` (default 3) are dropped before the critic LLM runs and recorded to `$RUN_DIR/threshold-dropped.json`. Pass `--threshold 0` to keep everything.
+
 Re-render progress.
 
-### 6. Critic
+### 5. Critic
 
 Read `$RUN_DIR/findings.deduped.json`. Apply the critic rubric from this SKILL.md verbatim (one verdict per finding). Write the kept subset to `$RUN_DIR/findings.kept.json`. Append `{stage: critic, status: done}` and re-render progress.
 
-### 7. Peer review
+### 6. Peer review
 
 Build the peer-review prompt by taking the `magpie-peer-review` block from this SKILL.md and substituting the placeholders listed in its `## Substitute before use` preamble. Write the substituted prompt to `$RUN_DIR/peer-prompt.md`. Then run codex with the prompt piped on stdin:
 
@@ -155,7 +136,7 @@ If codex returns non-zero, ask the user once: "Codex peer-review failed: <stderr
 
 Otherwise parse the verdicts JSON, apply them (drop / downgrade), and write `findings.final.json`. Append `{stage: peer-review, status: done}` and re-render progress.
 
-### 8. Report
+### 7. Report
 
 ```
 magpie render "$RUN_DIR" findings
@@ -165,7 +146,7 @@ Print to the terminal: "Findings ready at <url>. Click checkboxes to select what
 
 End the turn.
 
-### 9. Post
+### 8. Post
 
 Most users will tick the checkboxes in the served report and click "Post to PR"; the report server handles the rest. The agent only handles posts when the user explicitly types `post` (optionally `post 1,3,7` for indices) in the conversation.
 
@@ -188,7 +169,7 @@ Pass `--dry-run` to record the would-be gh commands without invoking gh. After p
 magpie render "$RUN_DIR" findings
 ```
 
-### 10. Cleanup
+### 9. Cleanup
 
 ```
 magpie cleanup "$RUN_DIR" --repo "$REPO"

package/skills/magpie/bin/magpie.ts

@@ -99,11 +99,22 @@ const HANDLERS: Record<string, Handler> = {
   dedupe: async (args) => {
     const runDir = args[0]
     if (!runDir) {
-      process.stderr.write('dedupe: missing <run-dir>\n')
+      process.stderr.write('dedupe: missing <run-dir> [--threshold <0-10>]\n')
       return 2
     }
+    const thresholdFlag = args.indexOf('--threshold')
+    const thresholdRaw = thresholdFlag !== -1 ? args[thresholdFlag + 1] : undefined
+    let threshold: number | undefined
+    if (thresholdRaw !== undefined) {
+      const n = Number(thresholdRaw)
+      if (!Number.isFinite(n) || n < 0 || n > 10) {
+        process.stderr.write(`dedupe: invalid --threshold ${thresholdRaw} (want 0-10)\n`)
+        return 2
+      }
+      threshold = n
+    }
     const { runDedupe } = await import('../scripts/dedupe-cmd.ts')
-    return runDedupe(runDir)
+    return runDedupe(runDir, threshold !== undefined ? { threshold } : {})
   },
   render: async (args) => {
     const runDir = args[0]

package/skills/magpie/fixtures/fake-gh-with-lockfile.sh

@@ -0,0 +1,52 @@
+#!/usr/bin/env bash
+case "$1 $2" in
+  "pr view")
+    cat <<'JSON'
+{
+  "number": 1234,
+  "title": "Fake PR",
+  "headRefName": "feature-x",
+  "baseRefName": "main",
+  "headRefOid": "deadbeefdeadbeefdeadbeefdeadbeefdeadbeef",
+  "baseRefOid": "cafebabecafebabecafebabecafebabecafebabe",
+  "author": { "login": "octocat" },
+  "body": "Fake body",
+  "url": "https://github.com/octocat/Hello-World/pull/1234",
+  "files": [
+    { "path": "src/a.ts",  "additions": 1, "deletions": 0, "changeType": "modified" },
+    { "path": "bun.lock",  "additions": 1, "deletions": 0, "changeType": "modified" },
+    { "path": "dist/x.js", "additions": 1, "deletions": 0, "changeType": "modified" }
+  ]
+}
+JSON
+    ;;
+  "pr diff")
+    cat <<'DIFF'
+diff --git a/src/a.ts b/src/a.ts
+index 1111111..2222222 100644
+--- a/src/a.ts
++++ b/src/a.ts
+@@ -1 +1 @@
+-export const x = 1
++export const x = 2
+diff --git a/bun.lock b/bun.lock
+index 3333333..4444444 100644
+--- a/bun.lock
++++ b/bun.lock
+@@ -1 +1 @@
+-{}
++{"a":1}
+diff --git a/dist/x.js b/dist/x.js
+index 5555555..6666666 100644
+--- a/dist/x.js
++++ b/dist/x.js
+@@ -1 +1 @@
+-1
++2
+DIFF
+    ;;
+  *)
+    echo "fake-gh: unsupported args: $*" >&2
+    exit 1
+    ;;
+esac

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

@@ -77,3 +77,48 @@ test('runDedupe with no findings files writes empty array', async () => {
   const out = JSON.parse(await readFile(join(runDir, 'findings.deduped.json'), 'utf8'))
   expect(out).toHaveLength(0)
 })
+
+test('runDedupe attaches score to each finding', async () => {
+  await writeFile(
+    join(runDir, 'findings', 'bugs.json'),
+    JSON.stringify([f('1', 'a.ts', 10, 'mid title', 'bugs')]),
+  )
+  const exit = await runDedupe(runDir)
+  expect(exit).toBe(0)
+  const out = JSON.parse(await readFile(join(runDir, 'findings.deduped.json'), 'utf8'))
+  expect(out[0]?.score).toBeGreaterThan(0)
+  expect(out[0]?.score).toBeLessThanOrEqual(10)
+})
+
+test('runDedupe drops findings below threshold and writes sidecar', async () => {
+  const low: ReviewFinding = {
+    ...f('low-1', 'a.ts', 10, 'tiny cleanup', 'code-smells'),
+    severity: 'low',
+    risk: { impact: 'low', likelihood: 'edge-case', confidence: 'low', action: 'optional' },
+  }
+  const high: ReviewFinding = {
+    ...f('high-1', 'b.ts', 10, 'serious bug', 'bugs'),
+    severity: 'blocker',
+    risk: { impact: 'critical', likelihood: 'likely', confidence: 'high', action: 'must-fix' },
+  }
+  await writeFile(join(runDir, 'findings', 'bugs.json'), JSON.stringify([low, high]))
+  const exit = await runDedupe(runDir, { threshold: 5 })
+  expect(exit).toBe(0)
+  const kept = JSON.parse(await readFile(join(runDir, 'findings.deduped.json'), 'utf8'))
+  expect(kept.map((x: ReviewFinding) => x.id)).toEqual(['high-1'])
+  const dropped = JSON.parse(await readFile(join(runDir, 'threshold-dropped.json'), 'utf8'))
+  expect(dropped[0]?.id).toBe('low-1')
+})
+
+test('runDedupe with threshold 0 keeps everything', async () => {
+  const low: ReviewFinding = {
+    ...f('low-1', 'a.ts', 10, 'tiny cleanup', 'code-smells'),
+    severity: 'low',
+    risk: { impact: 'low', likelihood: 'edge-case', confidence: 'low', action: 'optional' },
+  }
+  await writeFile(join(runDir, 'findings', 'bugs.json'), JSON.stringify([low]))
+  const exit = await runDedupe(runDir, { threshold: 0 })
+  expect(exit).toBe(0)
+  const kept = JSON.parse(await readFile(join(runDir, 'findings.deduped.json'), 'utf8'))
+  expect(kept).toHaveLength(1)
+})

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

@@ -0,0 +1,83 @@
+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 { verifyEvidence } from '../evidence-filter.ts'
+import type { ReviewFinding } from '../types.ts'
+
+let worktree: string
+
+function finding(overrides: Partial<ReviewFinding>): ReviewFinding {
+  return {
+    id: 'x-1',
+    file: 'src/a.ts',
+    line: 1,
+    severity: 'medium',
+    risk: { impact: 'medium', likelihood: 'possible', confidence: 'medium', action: 'should-fix' },
+    title: 't',
+    description: 'd',
+    domain: 'bugs',
+    ...overrides,
+  }
+}
+
+beforeEach(async () => {
+  worktree = await mkdtemp(join(tmpdir(), 'magpie-evidence-'))
+  await mkdir(join(worktree, 'src'), { recursive: true })
+  await writeFile(join(worktree, 'src/a.ts'), 'line1\nline2\nline3\n')
+})
+
+afterEach(async () => {
+  await rm(worktree, { recursive: true, force: true })
+})
+
+test('keeps finding with valid file and line', async () => {
+  const result = await verifyEvidence([finding({ line: 2 })], worktree)
+  expect(result.kept).toHaveLength(1)
+  expect(result.dropped).toHaveLength(0)
+  expect(result.skipped).toBe(false)
+})
+
+test('drops finding referencing missing file', async () => {
+  const result = await verifyEvidence([finding({ file: 'src/ghost.ts', line: 1 })], worktree)
+  expect(result.kept).toHaveLength(0)
+  expect(result.dropped[0]?.reason).toBe('hallucinated-file')
+})
+
+test('drops finding when line exceeds file length', async () => {
+  const result = await verifyEvidence([finding({ line: 999 })], worktree)
+  expect(result.kept).toHaveLength(0)
+  expect(result.dropped[0]?.reason).toBe('invented-line')
+})
+
+test('drops finding when line is < 1', async () => {
+  const result = await verifyEvidence([finding({ line: 0 })], worktree)
+  expect(result.kept).toHaveLength(0)
+  expect(result.dropped[0]?.reason).toBe('invented-line')
+})
+
+test('keeps unanchored finding (line=null) without checking file', async () => {
+  const result = await verifyEvidence([finding({ file: 'src/ghost.ts', line: null })], worktree)
+  expect(result.kept).toHaveLength(1)
+  expect(result.dropped).toHaveLength(0)
+})
+
+test('skips verification when worktree is missing', async () => {
+  await rm(worktree, { recursive: true, force: true })
+  const result = await verifyEvidence([finding({ line: 999 })], worktree)
+  expect(result.skipped).toBe(true)
+  expect(result.kept).toHaveLength(1)
+  expect(result.dropped).toHaveLength(0)
+})
+
+test('caches line counts across findings in the same file', async () => {
+  const findings = [finding({ id: 'a', line: 1 }), finding({ id: 'b', line: 3 })]
+  const result = await verifyEvidence(findings, worktree)
+  expect(result.kept.map((f) => f.id)).toEqual(['a', 'b'])
+})
+
+test('rejects directory paths', async () => {
+  const result = await verifyEvidence([finding({ file: 'src', line: 1 })], worktree)
+  expect(result.kept).toHaveLength(0)
+  expect(result.dropped[0]?.reason).toBe('hallucinated-file')
+})

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

@@ -0,0 +1,87 @@
+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'
+
+let home: string
+
+beforeEach(async () => {
+  home = await mkdtemp(join(tmpdir(), 'magpie-incremental-home-'))
+})
+
+afterEach(async () => {
+  await rm(home, { recursive: true, force: true })
+})
+
+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))
+  return dir
+}
+
+test('findPreviousRun returns null when no prior runs exist', async () => {
+  const result = await findPreviousRun(42, join(home, 'pr-42-100'), home)
+  expect(result).toBeNull()
+})
+
+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)
+  expect(result?.runId).toBe('pr-42-200')
+})
+
+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)
+  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)
+  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)
+  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)
+  expect(result?.runId).toBe('pr-42-50')
+})
+
+test('buildIncrementalContext detects new commits', () => {
+  const ctx = buildIncrementalContext(
+    { headRefOid: 'newsha' },
+    { runId: 'pr-42-100', prJson: { headRefOid: 'oldsha' } },
+  )
+  expect(ctx?.previousSha).toBe('oldsha')
+  expect(ctx?.currentSha).toBe('newsha')
+  expect(ctx?.sameSha).toBe(false)
+})
+
+test('buildIncrementalContext flags same-sha re-review', () => {
+  const ctx = buildIncrementalContext(
+    { headRefOid: 'samesha' },
+    { runId: 'pr-42-100', prJson: { headRefOid: 'samesha' } },
+  )
+  expect(ctx?.sameSha).toBe(true)
+})
+
+test('buildIncrementalContext returns null when either sha is missing', () => {
+  const noPrev = buildIncrementalContext({ headRefOid: 'new' }, { runId: 'x', prJson: {} })
+  expect(noPrev).toBeNull()
+  const noCurr = buildIncrementalContext({}, { runId: 'x', prJson: { headRefOid: 'a' } })
+  expect(noCurr).toBeNull()
+})

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

@@ -0,0 +1,161 @@
+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 {
+  DEFAULT_EXCLUDES,
+  filterDiff,
+  globToRegex,
+  loadPathFilterConfig,
+  matchesAny,
+} from '../path-filter.ts'
+
+let cwd: string
+
+beforeEach(async () => {
+  cwd = await mkdtemp(join(tmpdir(), 'magpie-pathfilter-'))
+})
+
+afterEach(async () => {
+  await rm(cwd, { recursive: true, force: true })
+})
+
+test('globToRegex: * does not cross path segments', () => {
+  expect(globToRegex('*.lock').test('bun.lock')).toBe(true)
+  expect(globToRegex('*.lock').test('a/bun.lock')).toBe(false)
+})
+
+test('globToRegex: ** matches across segments', () => {
+  expect(globToRegex('**/*.lock').test('bun.lock')).toBe(true)
+  expect(globToRegex('**/*.lock').test('a/b/bun.lock')).toBe(true)
+  expect(globToRegex('dist/**').test('dist/index.js')).toBe(true)
+  expect(globToRegex('dist/**').test('dist/sub/index.js')).toBe(true)
+  expect(globToRegex('dist/**').test('src/index.js')).toBe(false)
+})
+
+test('globToRegex: dot is literal', () => {
+  expect(globToRegex('*.generated.*').test('user.generated.ts')).toBe(true)
+  expect(globToRegex('*.generated.*').test('usergeneratedts')).toBe(false)
+})
+
+test('matchesAny returns the matched pattern or null', () => {
+  expect(matchesAny('bun.lock', ['**/*.lock'])).toBe('**/*.lock')
+  expect(matchesAny('src/a.ts', ['**/*.lock', 'dist/**'])).toBeNull()
+})
+
+test('DEFAULT_EXCLUDES covers common targets', () => {
+  const cases = [
+    'package-lock.json',
+    'pnpm-lock.yaml',
+    'bun.lock',
+    'dist/index.js',
+    'node_modules/foo/index.js',
+    'coverage/lcov.info',
+    'src/types.generated.ts',
+    'src/types.pb.go',
+    'src/__snapshots__/foo.test.ts.snap',
+  ]
+  for (const c of cases) {
+    expect(matchesAny(c, DEFAULT_EXCLUDES)).not.toBeNull()
+  }
+})
+
+test('DEFAULT_EXCLUDES keeps normal source', () => {
+  for (const c of ['src/index.ts', 'apps/server/src/main.ts', 'README.md']) {
+    expect(matchesAny(c, DEFAULT_EXCLUDES)).toBeNull()
+  }
+})
+
+test('loadPathFilterConfig: missing file returns defaults', async () => {
+  const cfg = await loadPathFilterConfig(cwd)
+  expect(cfg.useDefaults).toBe(true)
+  expect(cfg.exclude).toEqual([...DEFAULT_EXCLUDES])
+  expect(cfg.include).toEqual([])
+})
+
+test('loadPathFilterConfig: user exclude appends to defaults', async () => {
+  await writeFile(join(cwd, '.magpie.json'), JSON.stringify({ exclude: ['fixtures/**'] }))
+  const cfg = await loadPathFilterConfig(cwd)
+  expect(cfg.exclude).toContain('fixtures/**')
+  expect(cfg.exclude.length).toBe(DEFAULT_EXCLUDES.length + 1)
+})
+
+test('loadPathFilterConfig: useDefaults false drops defaults', async () => {
+  await writeFile(
+    join(cwd, '.magpie.json'),
+    JSON.stringify({ useDefaults: false, exclude: ['fixtures/**'] }),
+  )
+  const cfg = await loadPathFilterConfig(cwd)
+  expect(cfg.exclude).toEqual(['fixtures/**'])
+})
+
+test('loadPathFilterConfig: malformed JSON falls back to defaults', async () => {
+  await writeFile(join(cwd, '.magpie.json'), 'not json {')
+  const cfg = await loadPathFilterConfig(cwd)
+  expect(cfg.useDefaults).toBe(true)
+  expect(cfg.exclude).toEqual([...DEFAULT_EXCLUDES])
+})
+
+const DIFF = `diff --git a/src/a.ts b/src/a.ts
+index 1..2 100644
+--- a/src/a.ts
++++ b/src/a.ts
+@@ -1 +1 @@
+-x
++y
+diff --git a/bun.lock b/bun.lock
+index 1..2 100644
+--- a/bun.lock
++++ b/bun.lock
+@@ -1 +1 @@
+-{}
++{"a":1}
+diff --git a/dist/index.js b/dist/index.js
+index 1..2 100644
+--- a/dist/index.js
++++ b/dist/index.js
+@@ -1 +1 @@
+-1
++2
+`
+
+test('filterDiff: keeps source, drops lockfile and dist/', () => {
+  const { filtered, excluded } = filterDiff(DIFF, {
+    exclude: [...DEFAULT_EXCLUDES],
+    include: [],
+    useDefaults: true,
+  })
+  expect(filtered).toContain('src/a.ts')
+  expect(filtered).not.toContain('bun.lock')
+  expect(filtered).not.toContain('dist/index.js')
+  expect(excluded.map((e) => e.path).sort()).toEqual(['bun.lock', 'dist/index.js'])
+})
+
+test('filterDiff: empty diff', () => {
+  const { filtered, excluded } = filterDiff('', {
+    exclude: ['**/*'],
+    include: [],
+    useDefaults: false,
+  })
+  expect(filtered).toBe('')
+  expect(excluded).toEqual([])
+})
+
+test('filterDiff: include overrides excludes', () => {
+  const { filtered, excluded } = filterDiff(DIFF, {
+    exclude: ['**/*'],
+    include: ['src/**'],
+    useDefaults: false,
+  })
+  expect(filtered).toContain('src/a.ts')
+  expect(excluded.map((e) => e.path).sort()).toEqual(['bun.lock', 'dist/index.js'])
+})
+
+test('filterDiff: include records not-in-include reason', () => {
+  const { excluded } = filterDiff(DIFF, {
+    exclude: [],
+    include: ['src/**'],
+    useDefaults: false,
+  })
+  expect(excluded.find((e) => e.path === 'bun.lock')?.pattern).toBe('not-in-include')
+})