@iceinvein/agent-skills 0.1.28 → 0.1.30

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

@@ -0,0 +1,150 @@
+import { existsSync } from 'node:fs'
+import { readFile } from 'node:fs/promises'
+import { join } from 'node:path'
+
+export type PathFilterConfig = {
+  exclude: string[]
+  include: string[]
+  useDefaults: boolean
+}
+
+export const DEFAULT_EXCLUDES: readonly string[] = [
+  // Lockfiles
+  '**/package-lock.json',
+  '**/yarn.lock',
+  '**/pnpm-lock.yaml',
+  '**/bun.lock',
+  '**/bun.lockb',
+  '**/Cargo.lock',
+  '**/Pipfile.lock',
+  '**/poetry.lock',
+  '**/composer.lock',
+  '**/Gemfile.lock',
+  '**/uv.lock',
+  // Build / vendored / dependency dirs
+  'dist/**',
+  'build/**',
+  'out/**',
+  '.next/**',
+  '.nuxt/**',
+  '.svelte-kit/**',
+  '.turbo/**',
+  '.cache/**',
+  'coverage/**',
+  'node_modules/**',
+  'vendor/**',
+  // Generated source
+  '**/*.generated.*',
+  '**/*.gen.*',
+  '**/*.pb.go',
+  '**/*.pb.ts',
+  '**/*.pb.js',
+  '**/*_pb2.py',
+  '**/*.min.js',
+  '**/*.min.css',
+  '**/*.map',
+  // Snapshot fixtures
+  '**/*.snap',
+  '**/__snapshots__/**',
+  '**/.snapshots/**',
+]
+
+export function globToRegex(pattern: string): RegExp {
+  let re = ''
+  let i = 0
+  while (i < pattern.length) {
+    const ch = pattern[i]
+    if (ch === '*') {
+      if (pattern[i + 1] === '*') {
+        re += '.*'
+        i += 2
+        if (pattern[i] === '/') i += 1
+      } else {
+        re += '[^/]*'
+        i += 1
+      }
+    } else if (ch === '?') {
+      re += '[^/]'
+      i += 1
+    } else if (ch && /[.+^$()|[\]\\{}]/.test(ch)) {
+      re += `\\${ch}`
+      i += 1
+    } else {
+      re += ch ?? ''
+      i += 1
+    }
+  }
+  return new RegExp(`^${re}$`)
+}
+
+export function matchesAny(path: string, patterns: readonly string[]): string | null {
+  for (const pat of patterns) {
+    if (globToRegex(pat).test(path)) return pat
+  }
+  return null
+}
+
+export async function loadPathFilterConfig(cwd: string): Promise<PathFilterConfig> {
+  const cfgPath = join(cwd, '.magpie.json')
+  if (!existsSync(cfgPath)) {
+    return { exclude: [...DEFAULT_EXCLUDES], include: [], useDefaults: true }
+  }
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(await readFile(cfgPath, 'utf8'))
+  } catch {
+    return { exclude: [...DEFAULT_EXCLUDES], include: [], useDefaults: true }
+  }
+  const obj = (parsed ?? {}) as Record<string, unknown>
+  const userExclude = Array.isArray(obj.exclude)
+    ? obj.exclude.filter((s): s is string => typeof s === 'string')
+    : []
+  const userInclude = Array.isArray(obj.include)
+    ? obj.include.filter((s): s is string => typeof s === 'string')
+    : []
+  const useDefaults = obj.useDefaults !== false
+  return {
+    exclude: useDefaults ? [...DEFAULT_EXCLUDES, ...userExclude] : userExclude,
+    include: userInclude,
+    useDefaults,
+  }
+}
+
+export type ExcludedFile = { path: string; pattern: string }
+export type FilterDiffResult = { filtered: string; excluded: ExcludedFile[] }
+
+const FILE_HEADER = /^diff --git a\/(.+?) b\/(.+?)$/m
+
+export function filterDiff(rawDiff: string, config: PathFilterConfig): FilterDiffResult {
+  if (!rawDiff) return { filtered: '', excluded: [] }
+  const chunks = rawDiff.split(/^(?=diff --git )/m)
+  const kept: string[] = []
+  const excluded: ExcludedFile[] = []
+  for (const chunk of chunks) {
+    if (!chunk.startsWith('diff --git ')) {
+      if (chunk.trim()) kept.push(chunk)
+      continue
+    }
+    const m = chunk.match(FILE_HEADER)
+    const path = m?.[2] ?? m?.[1]
+    if (!path) {
+      kept.push(chunk)
+      continue
+    }
+    if (config.include.length > 0) {
+      if (matchesAny(path, config.include)) {
+        kept.push(chunk)
+        continue
+      }
+      excluded.push({ path, pattern: 'not-in-include' })
+      continue
+    }
+    const hit = matchesAny(path, config.exclude)
+    if (hit) {
+      excluded.push({ path, pattern: hit })
+      continue
+    }
+    kept.push(chunk)
+  }
+  return { filtered: kept.join(''), excluded }
+}

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

@@ -3,7 +3,13 @@ import { appendFile, readFile, writeFile } from 'node:fs/promises'
 import { join } from 'node:path'
 import { parseUnifiedDiffToHunks, splitDiffByFile } from './diff-utils.ts'
 import { formatFindingDescriptionMarkdown } from './finding-description.ts'
-import { type FocusId, parseFinding, type ReviewFinding, type Severity } from './types.ts'
+import {
+  type FocusId,
+  type PrFileEntry,
+  parseFinding,
+  type ReviewFinding,
+  type Severity,
+} from './types.ts'
 
 /**
  * Build a per-file set of RIGHT-side line numbers that GitHub's PR Reviews API
@@ -37,9 +43,9 @@ export type PostInput = {
   /**
    * Whether to also post a top-level review-summary comment before the
    * per-finding posts.
-   * - 'auto' (default): post when this batch will newly post 2+ findings and
-   *   no summary has been posted before.
-   * - 'always': post even for single-finding batches.
+   * - 'auto' (default): post when this batch has at least one finding and no
+   *   summary has been posted before. Always-on UX.
+   * - 'always': post even on empty batches (clean-review comment).
    * - 'never': skip the summary entirely.
    */
   includeSummary?: 'auto' | 'always' | 'never'
@@ -87,6 +93,7 @@ const FOCUS_LABEL: Record<FocusId, string> = {
   performance: 'Performance',
   'code-smells': 'Code Smells',
   architecture: 'Architecture',
+  tests: 'Tests',
 }
 
 function formatFocus(f: ReviewFinding): string | null {
@@ -213,6 +220,81 @@ function formatLocation(f: ReviewFinding): string {
 export type ReviewSummaryOptions = {
   /** Optional commit SHA. When present, surfaces a "Reviewed at <sha>" trailer. */
   commitId?: string
+  /** PR files changed (from pr.json). Used for the walkthrough table and effort score. */
+  files?: PrFileEntry[]
+  /** Incremental review context. When present, surfaces "since <prev-sha>" trailer. */
+  incremental?: { previousSha: string; sameSha: boolean }
+}
+
+/** Effort score 1 (trivial) to 5 (substantial), derived from changed files and lines. */
+export function computeEffortScore(files: PrFileEntry[]): number {
+  if (files.length === 0) return 1
+  const lines = files.reduce((acc, f) => acc + f.additions + f.deletions, 0)
+  if (files.length <= 2 && lines <= 50) return 1
+  if (files.length <= 5 && lines <= 200) return 2
+  if (files.length <= 10 && lines <= 500) return 3
+  if (files.length <= 20 && lines <= 1000) return 4
+  return 5
+}
+
+function renderEffortBar(score: number): string {
+  const filled = '●'.repeat(score)
+  const empty = '○'.repeat(Math.max(0, 5 - score))
+  return `${filled}${empty}`
+}
+
+function findingsByFile(findings: ReviewFinding[]): Map<string, ReviewFinding[]> {
+  const map = new Map<string, ReviewFinding[]>()
+  for (const f of findings) {
+    if (!f.file) continue
+    const list = map.get(f.file)
+    if (list) list.push(f)
+    else map.set(f.file, [f])
+  }
+  return map
+}
+
+function renderWalkthroughTable(
+  files: PrFileEntry[],
+  byFile: Map<string, ReviewFinding[]>,
+): string[] {
+  if (files.length === 0) return []
+  const sorted = [...files].sort((a, b) => b.additions + b.deletions - (a.additions + a.deletions))
+  const top = sorted.slice(0, 20)
+  const lines = [
+    '',
+    `<details>`,
+    `<summary><b>Files changed</b> (${plural(files.length, 'file')}${files.length > top.length ? `, showing top ${top.length}` : ''})</summary>`,
+    '',
+    '| File | +/- | Findings |',
+    '|---|---|---|',
+  ]
+  for (const f of top) {
+    const finds = byFile.get(f.path)?.length ?? 0
+    const stats = `+${f.additions} / -${f.deletions}`
+    lines.push(`| \`${f.path}\` | ${stats} | ${finds || ''} |`)
+  }
+  lines.push('', '</details>')
+  return lines
+}
+
+function renderRiskHotspots(byFile: Map<string, ReviewFinding[]>): string[] {
+  const entries = [...byFile.entries()]
+    .map(([file, finds]) => ({ file, finds }))
+    .filter((e) => e.finds.length >= 2)
+    .sort((a, b) => b.finds.length - a.finds.length)
+    .slice(0, 3)
+  if (entries.length === 0) return []
+  const lines = ['', '### Risk hotspots', '']
+  for (const e of entries) {
+    const counts: Record<Severity, number> = { blocker: 0, high: 0, medium: 0, low: 0 }
+    for (const f of e.finds) counts[f.severity] += 1
+    const tally = SEVERITY_ORDER.filter((s) => counts[s] > 0)
+      .map((s) => `${SEVERITY_ICON[s]} ${counts[s]}`)
+      .join(' · ')
+    lines.push(`- \`${e.file}\` · ${plural(e.finds.length, 'finding')} · ${tally}`)
+  }
+  return lines
 }
 
 /**
@@ -233,6 +315,9 @@ export function formatReviewSummaryBody(
 
   const fileCount = new Set(inlineFindings.map((f) => f.file)).size
   const shortSha = options.commitId ? options.commitId.slice(0, 7) : ''
+  const files = options.files ?? []
+  const effort = computeEffortScore(files)
+  const byFile = findingsByFile(findings)
 
   let verdict: string
   if (counts.blocker > 0) {
@@ -251,6 +336,18 @@ export function formatReviewSummaryBody(
 
   const lines: string[] = [header]
 
+  if (files.length > 0) {
+    lines.push('', `<sub>Review effort · ${renderEffortBar(effort)} (${effort}/5)</sub>`)
+  }
+
+  if (options.incremental) {
+    const prevShort = options.incremental.previousSha.slice(0, 7)
+    const msg = options.incremental.sameSha
+      ? `Re-review (no new commits since \`${prevShort}\`)`
+      : `Incremental review since \`${prevShort}\``
+    lines.push('', `<sub>${msg}</sub>`)
+  }
+
   if (findings.length > 0) {
     const inlineText =
       inlineFindings.length > 0
@@ -282,6 +379,9 @@ export function formatReviewSummaryBody(
     }
   }
 
+  lines.push(...renderRiskHotspots(byFile))
+  lines.push(...renderWalkthroughTable(files, byFile))
+
   if (findings.length > 0) {
     lines.push(
       '',
@@ -680,20 +780,44 @@ export async function runPost(input: PostInput): Promise<PostOutcome> {
 
   // Decide whether to post the review summary up front. It is one extra
   // top-level PR comment that gives the conversation a coherent overview
-  // before the per-finding threads land.
+  // before the per-finding threads land. Default 'auto' fires for any
+  // non-empty batch; 'always' fires even on empty batches (clean-review).
   const summaryMode = input.includeSummary ?? 'auto'
   const selectedFindings = input.findingIds
     .map((id) => byId.get(id))
     .filter((f): f is ReviewFinding => Boolean(f))
-  const pendingCount = selectedFindings.filter((f) => status[f.id] !== 'posted').length
   const summaryAlreadyPosted = status.__summary__ === 'posted'
   const shouldPostSummary =
     !summaryAlreadyPosted &&
-    selectedFindings.length > 0 &&
-    (summaryMode === 'always' || (summaryMode === 'auto' && pendingCount >= 2))
+    summaryMode !== 'never' &&
+    (summaryMode === 'always' || selectedFindings.length >= 1)
+
+  const prFiles = Array.isArray(prJson.files)
+    ? (prJson.files as PrFileEntry[]).filter(
+        (f): f is PrFileEntry =>
+          typeof f?.path === 'string' &&
+          typeof f?.additions === 'number' &&
+          typeof f?.deletions === 'number',
+      )
+    : []
+
+  let incremental: ReviewSummaryOptions['incremental']
+  try {
+    const raw = await readFile(join(input.runDir, 'incremental.json'), 'utf8')
+    const parsed = JSON.parse(raw) as { previousSha?: string; sameSha?: boolean }
+    if (typeof parsed.previousSha === 'string') {
+      incremental = { previousSha: parsed.previousSha, sameSha: Boolean(parsed.sameSha) }
+    }
+  } catch {
+    // No incremental sidecar; first run for this PR.
+  }
 
   if (shouldPostSummary) {
-    const summaryBody = formatReviewSummaryBody(selectedFindings, { commitId: headSha })
+    const summaryBody = formatReviewSummaryBody(selectedFindings, {
+      commitId: headSha,
+      files: prFiles,
+      ...(incremental ? { incremental } : {}),
+    })
     const summaryCmd = buildPrCommentCommand(repo, prNumber, summaryBody)
     if (input.dryRun) {
       results.push({ id: '__summary__', status: 'posted', command: summaryCmd })

package/skills/magpie/scripts/score.ts

@@ -0,0 +1,39 @@
+import type { Action, Confidence, Impact, Likelihood, Risk } from './types.ts'
+
+const IMPACT_WEIGHT: Record<Impact, number> = {
+  critical: 10,
+  high: 7,
+  medium: 4,
+  low: 1,
+}
+
+const LIKELIHOOD_WEIGHT: Record<Likelihood, number> = {
+  likely: 10,
+  possible: 6,
+  'edge-case': 3,
+  unknown: 4,
+}
+
+const CONFIDENCE_WEIGHT: Record<Confidence, number> = {
+  high: 10,
+  medium: 5,
+  low: 2,
+}
+
+const ACTION_WEIGHT: Record<Action, number> = {
+  'must-fix': 10,
+  'should-fix': 7,
+  consider: 4,
+  optional: 1,
+}
+
+export const DEFAULT_THRESHOLD = 3
+
+export function scoreRisk(risk: Risk): number {
+  const raw =
+    IMPACT_WEIGHT[risk.impact] * 0.4 +
+    LIKELIHOOD_WEIGHT[risk.likelihood] * 0.25 +
+    CONFIDENCE_WEIGHT[risk.confidence] * 0.2 +
+    ACTION_WEIGHT[risk.action] * 0.15
+  return Math.round(raw * 10) / 10
+}

package/skills/magpie/scripts/setup-cmd.ts

@@ -1,7 +1,10 @@
-import { appendFile, mkdir, rm } from 'node:fs/promises'
+import { appendFile, mkdir, rm, writeFile } from 'node:fs/promises'
 import { join } from 'node:path'
 import { fetchPr } from './gh.ts'
+import { buildIncrementalContext, findPreviousRun } from './incremental.ts'
+import { filterDiff, loadPathFilterConfig } from './path-filter.ts'
 import { type Deps, defaultDeps, preflight, renderInstallHint } from './preflight.ts'
+import { detectMissingTests } from './tests-check.ts'
 import { createWorktree } from './worktree.ts'
 
 export type RunSetupInput = {
@@ -45,6 +48,12 @@ export async function runSetup(input: RunSetupInput): Promise<number> {
   }
   await logLine(input.runDir, { stage: 'fetch-pr', status: 'done' })
 
+  await applyPathFilter(input.runDir, input.repoPath)
+
+  await runTestsCheck(input.runDir)
+
+  await detectIncrementalReview(input.runDir, input.prNumber)
+
   const prJson = (await Bun.file(join(input.runDir, 'pr.json')).json()) as { headRefName: string }
   const branch = prJson.headRefName
 
@@ -65,7 +74,69 @@ export async function runSetup(input: RunSetupInput): Promise<number> {
 }
 
 async function cleanup(runDir: string): Promise<void> {
-  for (const name of ['worktree', 'pr.json', 'diff.patch', 'findings', 'screen', 'state']) {
+  for (const name of [
+    'worktree',
+    'pr.json',
+    'diff.patch',
+    'diff.full.patch',
+    'excluded-files.json',
+    'incremental.json',
+    'findings',
+    'screen',
+    'state',
+  ]) {
     await rm(join(runDir, name), { recursive: true, force: true }).catch(() => {})
   }
 }
+
+async function runTestsCheck(runDir: string): Promise<void> {
+  const diff = await Bun.file(join(runDir, 'diff.patch')).text()
+  const findings = detectMissingTests(diff)
+  if (findings.length === 0) {
+    await logLine(runDir, { stage: 'tests-check', status: 'done', findings: 0 })
+    return
+  }
+  await writeFile(join(runDir, 'findings', 'tests.json'), `${JSON.stringify(findings, null, 2)}\n`)
+  await logLine(runDir, { stage: 'tests-check', status: 'done', findings: findings.length })
+}
+
+async function detectIncrementalReview(runDir: string, prNumber: number): Promise<void> {
+  const previous = await findPreviousRun(prNumber, runDir)
+  if (!previous) {
+    await logLine(runDir, { stage: 'incremental', status: 'first-run' })
+    return
+  }
+  const currentPr = (await Bun.file(join(runDir, 'pr.json')).json()) as Record<string, unknown>
+  const context = buildIncrementalContext(currentPr, previous)
+  if (!context) {
+    await logLine(runDir, { stage: 'incremental', status: 'missing-sha' })
+    return
+  }
+  await writeFile(join(runDir, 'incremental.json'), `${JSON.stringify(context, null, 2)}\n`)
+  await logLine(runDir, {
+    stage: 'incremental',
+    status: 'done',
+    previousRunId: context.previousRunId,
+    sameSha: context.sameSha,
+  })
+}
+
+async function applyPathFilter(runDir: string, repoPath: string): Promise<void> {
+  const diffPath = join(runDir, 'diff.patch')
+  const rawDiff = await Bun.file(diffPath).text()
+  const config = await loadPathFilterConfig(repoPath)
+  const { filtered, excluded } = filterDiff(rawDiff, config)
+  if (excluded.length === 0) {
+    await logLine(runDir, { stage: 'filter', status: 'done', excluded: 0 })
+    return
+  }
+  await writeFile(join(runDir, 'diff.full.patch'), rawDiff)
+  await writeFile(diffPath, filtered)
+  await writeFile(join(runDir, 'excluded-files.json'), `${JSON.stringify(excluded, null, 2)}\n`)
+  await logLine(runDir, {
+    stage: 'filter',
+    status: 'done',
+    excluded: excluded.length,
+    patterns: Array.from(new Set(excluded.map((e) => e.pattern))),
+  })
+}

package/skills/magpie/scripts/tests-check.ts

@@ -0,0 +1,118 @@
+import { splitDiffByFile } from './diff-utils.ts'
+import type { ReviewFinding } from './types.ts'
+
+const TEST_FILE_PATTERNS: RegExp[] = [
+  /\.test\.[jt]sx?$/, // foo.test.ts
+  /\.spec\.[jt]sx?$/, // foo.spec.ts
+  /(^|\/)__tests__\//, // __tests__/foo.ts
+  /(^|\/)tests?\//, // tests/foo.ts, test/foo.ts
+  /(^|\/)test_[^/]+\.py$/, // test_foo.py
+  /_test\.(go|py|rb)$/, // foo_test.go
+  /(^|\/)spec\//, // spec/foo_spec.rb
+  /Tests?\.(java|kt|cs)$/, // FooTest.java
+]
+
+const NON_CODE_EXTENSIONS = new Set([
+  '.md',
+  '.txt',
+  '.json',
+  '.yaml',
+  '.yml',
+  '.toml',
+  '.lock',
+  '.svg',
+  '.png',
+  '.jpg',
+  '.jpeg',
+  '.gif',
+  '.ico',
+  '.css',
+  '.scss',
+  '.html',
+])
+
+export function isTestFile(path: string): boolean {
+  return TEST_FILE_PATTERNS.some((p) => p.test(path))
+}
+
+function fileExt(path: string): string {
+  const dot = path.lastIndexOf('.')
+  return dot === -1 ? '' : path.slice(dot)
+}
+
+function looksLikeSourceCode(path: string): boolean {
+  return !NON_CODE_EXTENSIONS.has(fileExt(path).toLowerCase())
+}
+
+const COMMENT_PREFIXES = ['//', '#', '*', '/*', '"""', "'''"]
+
+function isLikelyCodeLine(content: string): boolean {
+  const trimmed = content.trim()
+  if (trimmed.length === 0) return false
+  if (COMMENT_PREFIXES.some((p) => trimmed.startsWith(p))) return false
+  // Strip leading import statements; they're common churn that doesn't warrant tests.
+  if (/^(import|from|require\()/.test(trimmed)) return false
+  return /[A-Za-z]/.test(trimmed)
+}
+
+function countAddedCodeLines(chunk: string): number {
+  let n = 0
+  for (const line of chunk.split('\n')) {
+    if (!line.startsWith('+')) continue
+    if (line.startsWith('+++')) continue
+    if (isLikelyCodeLine(line.slice(1))) n += 1
+  }
+  return n
+}
+
+export type DetectMissingTestsOptions = {
+  /** Minimum added code lines to trigger a missing-tests finding. Default 10. */
+  minAddedLines?: number
+}
+
+/**
+ * Walk the unified diff. If the diff contains zero test files anywhere, emit
+ * one finding per non-test source file that added >= minAddedLines of code-ish
+ * lines. Returns an empty array when test files are present (we assume the
+ * author has accounted for coverage).
+ */
+export function detectMissingTests(
+  diff: string,
+  options: DetectMissingTestsOptions = {},
+): ReviewFinding[] {
+  if (!diff) return []
+  const minAdded = options.minAddedLines ?? 10
+  const byFile = splitDiffByFile(diff)
+  const filePaths = [...byFile.keys()]
+  const hasAnyTestFile = filePaths.some((p) => isTestFile(p))
+  if (hasAnyTestFile) return []
+
+  const findings: ReviewFinding[] = []
+  let id = 1
+  for (const [path, chunk] of byFile) {
+    if (isTestFile(path)) continue
+    if (!looksLikeSourceCode(path)) continue
+    const added = countAddedCodeLines(chunk)
+    if (added < minAdded) continue
+    findings.push({
+      id: `tests-${id++}`,
+      file: path,
+      line: null,
+      severity: 'medium',
+      risk: {
+        impact: 'medium',
+        likelihood: 'possible',
+        confidence: 'medium',
+        action: 'should-fix',
+      },
+      title: `No tests added for changes in ${path}`,
+      description: [
+        `Observation: This PR adds ${added} new code-ish line${added === 1 ? '' : 's'} in \`${path}\` and the diff contains no test or spec file anywhere.`,
+        `Why it matters: Behaviour changes without test coverage are easy to regress and harder to review with confidence.`,
+        `Suggested direction: Add or extend a test that exercises the new behaviour, or note explicitly why a test is not warranted (config-only change, type-only change, trivial refactor).`,
+      ].join('\n\n'),
+      domain: 'tests',
+    })
+  }
+  return findings
+}

package/skills/magpie/scripts/types.ts

@@ -1,4 +1,11 @@
-export const FOCUS_IDS = ['security', 'bugs', 'performance', 'code-smells', 'architecture'] as const
+export const FOCUS_IDS = [
+  'security',
+  'bugs',
+  'performance',
+  'code-smells',
+  'architecture',
+  'tests',
+] as const
 export type FocusId = (typeof FOCUS_IDS)[number]
 
 export const SEVERITIES = ['blocker', 'high', 'medium', 'low'] as const
@@ -45,6 +52,8 @@ export type ReviewFinding = {
   suggestion?: Suggestion
   domain: FocusId | string | null
   mergedFrom?: MergedFromEntry[]
+  /** Derived 0-10 importance score from risk fields. Populated during dedupe. */
+  score?: number
 }
 
 function assertOneOf<T extends string>(
@@ -102,6 +111,7 @@ export function parseFinding(raw: unknown): ReviewFinding {
     suggestion,
     domain: (r.domain as ReviewFinding['domain']) ?? null,
     mergedFrom: Array.isArray(r.mergedFrom) ? (r.mergedFrom as MergedFromEntry[]) : undefined,
+    ...(typeof r.score === 'number' && Number.isFinite(r.score) ? { score: r.score } : {}),
   }
 }
 

package/skills/magpie/skill.json

@@ -1,6 +1,6 @@
 {
   "name": "magpie",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "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.",
   "author": "iceinvein",
   "type": "prompt",