@iceinvein/agent-skills 0.23.9 → 0.23.13

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

@@ -1,9 +1,9 @@
 import { readFile, writeFile } from 'node:fs/promises'
 import { join } from 'node:path'
-import { foldLabels, readJsonLines } from './labels.ts'
+import { type FindingLabel, foldLabels, readJsonLines } from './labels.ts'
 import type { PostStatusMap } from './types.ts'
 
-export async function writeLabels(runDir: string): Promise<number> {
+export async function readRunLabels(runDir: string): Promise<FindingLabel[]> {
   const findingsPath = join(runDir, 'findings.final.json')
   const raw = JSON.parse(await readFile(findingsPath, 'utf8')) as unknown
   if (!Array.isArray(raw)) throw new Error(`${findingsPath} is not an array`)
@@ -21,12 +21,16 @@ export async function writeLabels(runDir: string): Promise<number> {
     if ((err as NodeJS.ErrnoException).code !== 'ENOENT') throw err
   }
 
-  const labels = foldLabels({
+  return foldLabels({
     findingIds,
     postStatus,
     events: await readJsonLines(join(runDir, 'state', 'events')),
     log: await readJsonLines(join(runDir, 'log.jsonl')),
   })
+}
+
+export async function writeLabels(runDir: string): Promise<number> {
+  const labels = await readRunLabels(runDir)
   await writeFile(join(runDir, 'labels.json'), `${JSON.stringify(labels, null, 2)}\n`)
   return labels.length
 }

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

@@ -3,7 +3,10 @@ import { appendFile, readFile, writeFile } from 'node:fs/promises'
 import { join } from 'node:path'
 import { buildNewSideLineIndex } from './diff-utils.ts'
 import { formatFindingDescriptionMarkdown } from './finding-description.ts'
+import { readHistory } from './history.ts'
 import type { PostVia } from './labels.ts'
+import { describePreviousPosted } from './previous-findings.ts'
+import { describeUnreviewed, readShardCoverage } from './shard-coverage.ts'
 import {
   type FocusId,
   type PrFileEntry,
@@ -150,6 +153,31 @@ function buildSuggestion(f: ReviewFinding): SuggestionParts {
   }
 }
 
+/** GitHub renders the `<summary>` line as HTML, where a raw `<` in a command would start a tag. */
+function escapeHtml(s: string): string {
+  return s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
+}
+
+/** The repro rides folded under the finding, so the comment stays short on GitHub. */
+function buildRepro(f: ReviewFinding): string | null {
+  if (f.proof?.status !== 'reproduced') return null
+  const { command, source, output } = f.proof.repro
+  const fence = (code: string) => '`'.repeat(Math.max(3, maxBacktickRun(code) + 1))
+  return [
+    `<details><summary>Reproduced with <code>${escapeHtml(command)}</code></summary>`,
+    '',
+    fence(source),
+    source,
+    fence(source),
+    '',
+    fence(output),
+    output,
+    fence(output),
+    '',
+    '</details>',
+  ].join('\n')
+}
+
 function buildFindingMarker(f: ReviewFinding): string {
   const normalized = JSON.stringify({
     file: f.file || '',
@@ -180,6 +208,7 @@ export function formatInlineBody(f: ReviewFinding): string {
   const metaLine = buildMetaLine([...buildRiskParts(f), focus ? `Focus · ${focus}` : null])
   const { block: suggestion, preamble: sugPre, postamble: sugPost } = buildSuggestion(f)
   const sections = formatFindingDescriptionMarkdown(f.description)
+  const repro = buildRepro(f)
 
   return joinBlock([
     `### ${icon} ${label}: ${f.title}`,
@@ -193,6 +222,8 @@ export function formatInlineBody(f: ReviewFinding): string {
     suggestion,
     sugPost ? '' : null,
     sugPost,
+    repro ? '' : null,
+    repro,
     '',
     buildFindingMarker(f),
   ])
@@ -213,6 +244,7 @@ export function formatConversationBody(f: ReviewFinding): string {
     ...buildRiskParts(f),
   ])
   const sections = formatFindingDescriptionMarkdown(f.description)
+  const repro = buildRepro(f)
   const { block: suggestion, preamble: sugPre, postamble: sugPost } = buildSuggestion(f)
 
   return joinBlock([
@@ -227,6 +259,8 @@ export function formatConversationBody(f: ReviewFinding): string {
     suggestion,
     sugPost ? '' : null,
     sugPost,
+    repro ? '' : null,
+    repro,
     '',
     buildFindingMarker(f),
   ])
@@ -260,6 +294,10 @@ export type ReviewSummaryOptions = {
   files?: PrFileEntry[]
   /** Incremental review context. When present, surfaces "since <prev-sha>" trailer. */
   incremental?: { previousSha: string; sameSha: boolean }
+  /** `describePreviousPosted` on a re-review. */
+  previousRun?: string
+  /** `describeUnreviewed` when shards were skipped at the stage 4 gate. */
+  unreviewed?: string
 }
 
 /** Effort score 1 (trivial) to 5 (substantial), derived from changed files and lines. */
@@ -383,6 +421,8 @@ export function formatReviewSummaryBody(
       : `Incremental review since \`${prevShort}\``
     lines.push('', `<sub>${msg}</sub>`)
   }
+  if (options.previousRun) lines.push('', `<sub>${options.previousRun}</sub>`)
+  if (options.unreviewed) lines.push('', `<sub>${options.unreviewed}</sub>`)
 
   if (findings.length > 0) {
     const inlineText =
@@ -862,11 +902,17 @@ export async function runPost(input: PostInput): Promise<PostOutcome> {
     // No incremental sidecar; first run for this PR.
   }
 
+  const { previous } = await readHistory(input.runDir)
+  const previousRun = previous ? describePreviousPosted(previous) : null
+  const coverage = await readShardCoverage(input.runDir)
+
   if (shouldPostSummary) {
     const summaryBody = formatReviewSummaryBody(selectedFindings, {
       commitId: headSha,
       files: prFiles,
       ...(incremental ? { incremental } : {}),
+      ...(previousRun ? { previousRun } : {}),
+      ...(coverage ? { unreviewed: describeUnreviewed(coverage) } : {}),
     })
     const summaryCmd = buildPrCommentCommand(repo, prNumber, summaryBody)
     if (input.dryRun) {

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

@@ -0,0 +1,243 @@
+import { writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+
+export type PrCheck = {
+  name: string
+  /** CheckRun conclusion, or its status while it has none; StatusContext state. Upper case as GitHub sends it. */
+  conclusion: string
+  url: string | null
+}
+
+export type PrThread = {
+  file: string
+  line: number | null
+  resolved: boolean
+  outdated: boolean
+  author: string
+  /** The thread's first comment. */
+  body: string
+  replies: number
+  /** Posted by magpie in an earlier run, recognised by its hidden marker. */
+  magpie: boolean
+}
+
+export type PrComment = {
+  author: string
+  body: string
+  magpie: boolean
+}
+
+export type PrActivity = {
+  checks: PrCheck[]
+  threads: PrThread[]
+  comments: PrComment[]
+}
+
+export type FetchPrActivityInput = {
+  ghBin: string
+  prNumber: number
+  /** pr.json's `url`, the source of owner and repo for the thread query. */
+  prUrl: string
+  runDir: string
+  cwd?: string
+  env?: Record<string, string>
+}
+
+export type FetchPrActivityResult =
+  | { ok: true; activity: PrActivity }
+  | { ok: false; error: string }
+
+const ACTIVITY_VIEW_FIELDS = 'statusCheckRollup,comments,reviews'
+
+const FINDING_MARKER = '<!-- magpie:finding'
+const SUMMARY_MARKER = '<!-- magpie:summary -->'
+const REVIEW_BODY_SEPARATOR = '\n\n---\n\n'
+
+// gh pr view does not expose review threads, which carry the file, line and
+// resolved state, so they come from GraphQL a page at a time.
+const THREADS_QUERY = `query($owner: String!, $repo: String!, $number: Int!, $after: String) {
+  repository(owner: $owner, name: $repo) {
+    pullRequest(number: $number) {
+      reviewThreads(first: 100, after: $after) {
+        pageInfo { hasNextPage endCursor }
+        nodes {
+          path line originalLine isResolved isOutdated
+          comments(first: 1) { totalCount nodes { author { login } body } }
+        }
+      }
+    }
+  }
+}`
+
+type GhRun = { ok: true; stdout: string } | { ok: false; error: string }
+
+async function runGh(input: FetchPrActivityInput, args: string[]): Promise<GhRun> {
+  const proc = Bun.spawn([input.ghBin, ...args], {
+    stdout: 'pipe',
+    stderr: 'pipe',
+    ...(input.cwd ? { cwd: input.cwd } : {}),
+    ...(input.env ? { env: { ...process.env, ...input.env } } : {}),
+  })
+  const [stdout, stderr] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+  ])
+  const exit = await proc.exited
+  if (exit !== 0)
+    return { ok: false, error: `gh ${args[0]} ${args[1]} exit ${exit}: ${stderr.trim()}` }
+  return { ok: true, stdout }
+}
+
+function str(value: unknown): string {
+  return typeof value === 'string' ? value : ''
+}
+
+// GitHub returns a null author for a deleted account and shows it as "ghost".
+function login(author: unknown): string {
+  return author === null ? 'ghost' : str((author as { login?: unknown }).login)
+}
+
+function parseChecks(rollup: unknown): PrCheck[] {
+  if (!Array.isArray(rollup)) return []
+  return rollup.map((raw) => {
+    const c = raw as Record<string, unknown>
+    if (c.__typename === 'StatusContext') {
+      return { name: str(c.context), conclusion: str(c.state), url: str(c.targetUrl) || null }
+    }
+    return {
+      name: str(c.name),
+      conclusion: str(c.conclusion) || str(c.status),
+      url: str(c.detailsUrl) || null,
+    }
+  })
+}
+
+function parseComments(view: Record<string, unknown>): PrComment[] {
+  const entries = [
+    ...(Array.isArray(view.comments) ? view.comments : []),
+    ...(Array.isArray(view.reviews) ? view.reviews : []),
+  ] as Array<Record<string, unknown>>
+  // The report's Post Selected joins findings with no inline anchor into one
+  // review body; split it so each one is its own entry rather than one cut short.
+  return entries
+    .flatMap((e) =>
+      str(e.body)
+        .split(REVIEW_BODY_SEPARATOR)
+        .map((body) => ({ author: login(e.author), body })),
+    )
+    .filter((c) => c.body.trim() !== '' && !c.body.includes(SUMMARY_MARKER))
+    .map((c) => ({ ...c, magpie: c.body.includes(FINDING_MARKER) }))
+}
+
+/** Null for a thread whose opening comment was deleted: it has nothing left to repeat. */
+function parseThread(raw: unknown): PrThread | null {
+  const t = raw as Record<string, unknown>
+  const comments = (t.comments ?? {}) as { totalCount?: unknown; nodes?: unknown }
+  const first = (Array.isArray(comments.nodes) ? comments.nodes[0] : undefined) as
+    | Record<string, unknown>
+    | undefined
+  const body = str(first?.body)
+  if (!first || body.trim() === '') return null
+  const total = typeof comments.totalCount === 'number' ? comments.totalCount : 0
+  // An outdated thread has no current line; where it was first left is still the best pointer.
+  const line =
+    typeof t.line === 'number' ? t.line : typeof t.originalLine === 'number' ? t.originalLine : null
+  return {
+    file: str(t.path),
+    line,
+    resolved: t.isResolved === true,
+    outdated: t.isOutdated === true,
+    author: login(first.author),
+    body,
+    replies: Math.max(total - 1, 0),
+    magpie: body.includes(FINDING_MARKER),
+  }
+}
+
+async function fetchThreads(
+  input: FetchPrActivityInput,
+  owner: string,
+  repo: string,
+): Promise<{ ok: true; threads: PrThread[] } | { ok: false; error: string }> {
+  const threads: PrThread[] = []
+  let after: string | null = null
+  do {
+    const args = [
+      'api',
+      'graphql',
+      '-f',
+      `query=${THREADS_QUERY}`,
+      '-f',
+      `owner=${owner}`,
+      '-f',
+      `repo=${repo}`,
+      '-F',
+      `number=${input.prNumber}`,
+      ...(after ? ['-f', `after=${after}`] : []),
+    ]
+    const run = await runGh(input, args)
+    if (!run.ok) return run
+    let page: {
+      data?: { repository?: { pullRequest?: { reviewThreads?: unknown } } } | null
+      errors?: Array<{ message?: unknown }>
+    }
+    try {
+      page = JSON.parse(run.stdout)
+    } catch (err) {
+      return { ok: false, error: `gh api graphql returned unparseable JSON: ${String(err)}` }
+    }
+    if (page.errors && page.errors.length > 0) {
+      return {
+        ok: false,
+        error: `gh api graphql: ${page.errors.map((e) => str(e.message)).join('; ')}`,
+      }
+    }
+    const connection = page.data?.repository?.pullRequest?.reviewThreads as
+      | { pageInfo?: { hasNextPage?: unknown; endCursor?: unknown }; nodes?: unknown }
+      | undefined
+    if (!connection || !Array.isArray(connection.nodes)) {
+      return { ok: false, error: 'gh api graphql returned no reviewThreads for the PR' }
+    }
+    threads.push(...connection.nodes.flatMap((node) => parseThread(node) ?? []))
+    after =
+      connection.pageInfo?.hasNextPage === true ? str(connection.pageInfo.endCursor) || null : null
+  } while (after)
+  return { ok: true, threads }
+}
+
+/** `https://github.com/<owner>/<repo>/pull/<n>` to owner and repo. */
+function ownerRepo(prUrl: string): { owner: string; repo: string } | null {
+  const m = prUrl.match(/^https?:\/\/[^/]+\/([^/]+)\/([^/]+)\/pull\/\d+/)
+  return m?.[1] && m[2] ? { owner: m[1], repo: m[2] } : null
+}
+
+export async function fetchPrActivity(input: FetchPrActivityInput): Promise<FetchPrActivityResult> {
+  const target = ownerRepo(input.prUrl)
+  if (!target) return { ok: false, error: `cannot read owner and repo from PR url ${input.prUrl}` }
+
+  const view = await runGh(input, [
+    'pr',
+    'view',
+    String(input.prNumber),
+    '--json',
+    ACTIVITY_VIEW_FIELDS,
+  ])
+  if (!view.ok) return view
+  let viewJson: Record<string, unknown>
+  try {
+    viewJson = JSON.parse(view.stdout)
+  } catch (err) {
+    return { ok: false, error: `gh pr view returned unparseable JSON: ${String(err)}` }
+  }
+
+  const threads = await fetchThreads(input, target.owner, target.repo)
+  if (!threads.ok) return threads
+
+  const activity: PrActivity = {
+    checks: parseChecks(viewJson.statusCheckRollup),
+    threads: threads.threads,
+    comments: parseComments(viewJson),
+  }
+  await writeFile(join(input.runDir, 'pr-activity.json'), `${JSON.stringify(activity, null, 2)}\n`)
+  return { ok: true, activity }
+}

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

@@ -96,6 +96,7 @@ export const STAGE_PRESETS = {
       dedupe: 'done',
       critic: 'done',
       'peer-review': 'done',
+      proof: 'done',
       report: 'done',
     },
     counts: { security: 1, bugs: 2, performance: 2, 'code-smells': 2, architecture: 1 },
@@ -109,6 +110,7 @@ export const STAGE_PRESETS = {
       dedupe: 'done',
       critic: 'done',
       'peer-review': 'done',
+      proof: 'done',
       report: 'done',
       post: 'done',
     },
@@ -124,6 +126,7 @@ function pending(): Record<StageId, StageStatus> {
     dedupe: 'pending',
     critic: 'pending',
     'peer-review': 'pending',
+    proof: 'pending',
     report: 'pending',
     post: 'pending',
   }

package/skills/magpie/scripts/previous-findings.ts

@@ -0,0 +1,181 @@
+import { readFile, writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import { containsEvidence } from './evidence-filter.ts'
+import { DISMISS_REASONS, type DismissReason, type FindingLabel } from './labels.ts'
+import { readRunLabels } from './labels-cmd.ts'
+import { parseFinding } from './types.ts'
+
+type PreviousFindingBase = {
+  id: string
+  /** The run that produced the finding, which can be older than the previous run when carried. */
+  fromRunId: string
+  file: string
+  line: number | null
+  title: string
+  domain: string | null
+}
+
+/**
+ * `anchor` says whether the code the finding quoted is still in the file. It
+ * does not say the finding was fixed: the code can change and keep the defect.
+ */
+export type PreviousFinding =
+  | (PreviousFindingBase & { label: 'posted'; anchor: 'unchanged' | 'changed' | 'unanchored' })
+  | (PreviousFindingBase & { label: 'dismissed'; reason: DismissReason })
+
+export type PreviousFindings = {
+  previousRunId: string
+  findings: PreviousFinding[]
+}
+
+function isMissingFile(err: unknown): boolean {
+  return (err as NodeJS.ErrnoException)?.code === 'ENOENT'
+}
+
+async function readOptionalJson(path: string): Promise<unknown | null> {
+  let text: string
+  try {
+    text = await readFile(path, 'utf8')
+  } catch (err) {
+    if (isMissingFile(err)) return null
+    throw err
+  }
+  try {
+    return JSON.parse(text)
+  } catch (err) {
+    throw new Error(`${path}: ${err instanceof Error ? err.message : String(err)}`)
+  }
+}
+
+/** cleanup writes labels.json before archiving; an active run's labels are folded fresh. */
+async function readLabels(runDir: string): Promise<FindingLabel[]> {
+  const path = join(runDir, 'labels.json')
+  const raw = await readOptionalJson(path)
+  if (raw === null) return readRunLabels(runDir)
+  if (!Array.isArray(raw)) throw new Error(`${path}: expected a JSON array`)
+  return raw as FindingLabel[]
+}
+
+async function anchorStatus(
+  worktree: string,
+  file: string,
+  line: number | null,
+  evidence: string | undefined,
+): Promise<'unchanged' | 'changed' | 'unanchored'> {
+  if (line === null || !evidence?.trim()) return 'unanchored'
+  let text: string
+  try {
+    text = await readFile(join(worktree, file), 'utf8')
+  } catch (err) {
+    if (isMissingFile(err)) return 'changed'
+    throw err
+  }
+  return containsEvidence(text, evidence) ? 'unchanged' : 'changed'
+}
+
+/**
+ * Dismissals only travel one run at a time: a finding the critic dropped as
+ * already dismissed never reaches findings.final.json, so the next run would
+ * forget it unless the previous run's own carried dismissals come along too.
+ */
+function parseCarried(raw: unknown, path: string): PreviousFinding[] {
+  if (raw === null) return []
+  const findings = (raw as { findings?: unknown }).findings
+  if (!Array.isArray(findings)) throw new Error(`${path}: expected { findings: [...] }`)
+  return findings.flatMap((entry, i) => {
+    const f = entry as Record<string, unknown>
+    if (f.label !== 'dismissed') return []
+    const reason = DISMISS_REASONS.find((r) => r === f.reason)
+    if (
+      typeof f.id !== 'string' ||
+      typeof f.fromRunId !== 'string' ||
+      typeof f.file !== 'string' ||
+      typeof f.title !== 'string' ||
+      !reason
+    ) {
+      throw new Error(`${path}: findings[${i}] is not a dismissed finding`)
+    }
+    return [
+      {
+        id: f.id,
+        fromRunId: f.fromRunId,
+        file: f.file,
+        line: typeof f.line === 'number' ? f.line : null,
+        title: f.title,
+        domain: typeof f.domain === 'string' ? f.domain : null,
+        label: 'dismissed' as const,
+        reason,
+      },
+    ]
+  })
+}
+
+/**
+ * The previous run's posted and dismissed findings, for a re-review to carry
+ * forward. Ignored findings are left out: nobody judged them. A run aborted
+ * before findings.final.json still passes on what it carried. Null when it has
+ * neither.
+ */
+export async function readPreviousFindings(input: {
+  runDir: string
+  runId: string
+  worktree: string
+}): Promise<PreviousFindings | null> {
+  const finalPath = join(input.runDir, 'findings.final.json')
+  const raw = await readOptionalJson(finalPath)
+  const carriedPath = join(input.runDir, 'previous-findings.json')
+  const carriedRaw = await readOptionalJson(carriedPath)
+  if (raw === null && carriedRaw === null) return null
+  if (raw !== null && !Array.isArray(raw)) throw new Error(`${finalPath}: expected a JSON array`)
+  const labels =
+    raw === null ? new Map() : new Map((await readLabels(input.runDir)).map((l) => [l.id, l]))
+
+  const findings: PreviousFinding[] = []
+  for (const entry of raw ?? []) {
+    const f = parseFinding(entry)
+    const label = labels.get(f.id)
+    const base = {
+      id: f.id,
+      fromRunId: input.runId,
+      file: f.file,
+      line: f.line,
+      title: f.title,
+      domain: typeof f.domain === 'string' ? f.domain : null,
+    }
+    if (label?.label === 'posted') {
+      const anchor = await anchorStatus(input.worktree, f.file, f.line, f.evidence)
+      findings.push({ ...base, label: 'posted', anchor })
+    } else if (label?.label === 'dismissed' && label.reason) {
+      findings.push({ ...base, label: 'dismissed', reason: label.reason })
+    }
+  }
+
+  const carried = parseCarried(carriedRaw, carriedPath)
+  const seen = new Set(findings.map((f) => `${f.fromRunId}/${f.id}`))
+  for (const f of carried) {
+    if (!seen.has(`${f.fromRunId}/${f.id}`)) findings.push(f)
+  }
+  return { previousRunId: input.runId, findings }
+}
+
+export async function writePreviousFindings(
+  runDir: string,
+  previous: PreviousFindings,
+): Promise<void> {
+  await writeFile(join(runDir, 'previous-findings.json'), `${JSON.stringify(previous, null, 2)}\n`)
+}
+
+/** One line for the report header and the summary comment; null when nothing was posted last review. */
+export function describePreviousPosted(previous: PreviousFindings): string | null {
+  const posted = previous.findings.flatMap((f) => (f.label === 'posted' ? [f] : []))
+  if (posted.length === 0) return null
+  const count = (anchor: string) => posted.filter((f) => f.anchor === anchor).length
+  const parts = [
+    `Last review: ${posted.length} posted`,
+    `${count('changed')} on changed code`,
+    `${count('unchanged')} on unchanged code`,
+  ]
+  const unanchored = count('unanchored')
+  if (unanchored > 0) parts.push(`${unanchored} not anchored to a line`)
+  return parts.join(' · ')
+}