@iceinvein/agent-skills 0.1.24 → 0.1.26

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

@@ -280,6 +280,208 @@ export function formatReviewSummaryBody(
   return lines.join('\n')
 }
 
+// ---------------------------------------------------------------------------
+// postFindingsAsReview
+// ---------------------------------------------------------------------------
+
+export type PostReviewInput = {
+  runDir: string
+  findingIds: string[]
+  prNumber: number
+  headSha: string
+  reviewBody?: string
+  ghBin?: string
+  dryRun?: boolean
+}
+
+export type PostReviewCommentResult = {
+  id: string
+  status: 'posted' | 'failed'
+  message?: string
+}
+
+export type PostReviewResult = {
+  reviewId: string | null
+  comments: PostReviewCommentResult[]
+  command?: string[]
+  payload?: string
+}
+
+// Looser finding shape used only inside postFindingsAsReview to accommodate
+// findings.json entries where `file` may be null (not yet anchored to a path).
+type LooseFinding = {
+  id: string
+  file: string | null
+  line: number | null
+  title: string
+  description: string
+}
+
+function parseLooseFinding(raw: unknown): LooseFinding | null {
+  if (!raw || typeof raw !== 'object') return null
+  const r = raw as Record<string, unknown>
+  if (typeof r.id !== 'string') return null
+  if (typeof r.title !== 'string') return null
+  if (typeof r.description !== 'string') return null
+  const file = typeof r.file === 'string' ? r.file : null
+  const line = typeof r.line === 'number' ? r.line : null
+  return { id: r.id, file, line, title: r.title, description: r.description }
+}
+
+export async function postFindingsAsReview(input: PostReviewInput): Promise<PostReviewResult> {
+  const bin = input.ghBin ?? process.env.MAGPIE_GH_BIN ?? 'gh'
+
+  // Load findings.json and index by id. Use a loose parser that tolerates
+  // null file/line fields which parseFinding (strict) would reject.
+  const byId = new Map<string, LooseFinding>()
+  try {
+    const raw = JSON.parse(await readFile(join(input.runDir, 'findings.json'), 'utf8'))
+    if (Array.isArray(raw)) {
+      for (const entry of raw) {
+        const f = parseLooseFinding(entry)
+        if (f) byId.set(f.id, f)
+      }
+    }
+  } catch {
+    // findings.json missing or unparseable; byId stays empty
+  }
+
+  // Also load findings.final.json so we can use strict ReviewFinding formatters.
+  const strictById = new Map<string, ReviewFinding>()
+  try {
+    const raw = JSON.parse(await readFile(join(input.runDir, 'findings.final.json'), 'utf8'))
+    if (Array.isArray(raw)) {
+      for (const entry of raw) {
+        try {
+          const f = parseFinding(entry)
+          strictById.set(f.id, f)
+        } catch {
+          // entry doesn't pass strict validation; will fall back to LooseFinding path
+        }
+      }
+    }
+  } catch {
+    // findings.final.json missing or unparseable; strictById stays empty
+  }
+
+  // Partition into inline (has file + line) and unplaced.
+  type InlineComment = { path: string; line: number; side: 'RIGHT'; body: string }
+  const inlineComments: InlineComment[] = []
+  const unplacedBodies: string[] = []
+
+  for (const id of input.findingIds) {
+    const f = byId.get(id)
+    if (!f) continue
+    const strict = strictById.get(id)
+    if (f.line != null && f.file != null) {
+      const body = strict
+        ? formatInlineBody(strict)
+        : formatFindingDescriptionMarkdown(f.description)
+      inlineComments.push({
+        path: f.file,
+        line: f.line,
+        side: 'RIGHT',
+        body,
+      })
+    } else {
+      const body = strict
+        ? formatConversationBody(strict)
+        : `**${f.title}** (${f.file ?? 'general'})\n\n${formatFindingDescriptionMarkdown(f.description)}`
+      unplacedBodies.push(body)
+    }
+  }
+
+  // Build review body.
+  const unplacedSection = unplacedBodies.join('\n\n---\n\n')
+  const reviewBodyParts = [input.reviewBody, unplacedSection].filter(
+    (s): s is string => typeof s === 'string' && s.length > 0,
+  )
+  const reviewBody = reviewBodyParts.join('\n\n')
+
+  const payloadObj = {
+    commit_id: input.headSha,
+    event: 'COMMENT',
+    body: reviewBody,
+    comments: inlineComments,
+  }
+  const payload = JSON.stringify(payloadObj)
+
+  const command = [
+    bin,
+    'api',
+    `repos/{owner}/{repo}/pulls/${input.prNumber}/reviews`,
+    '--method',
+    'POST',
+    '--input',
+    '-',
+  ]
+
+  if (input.dryRun) {
+    return {
+      reviewId: null,
+      comments: input.findingIds.map((id) => ({ id, status: 'posted' as const })),
+      command,
+      payload,
+    }
+  }
+
+  // Execute.
+  let stdoutText: string
+  let stderrText: string
+  let exit: number
+  try {
+    const proc = Bun.spawn(command, { stdin: 'pipe', stdout: 'pipe', stderr: 'pipe' })
+    const stdin = proc.stdin as import('bun').FileSink
+    stdin.write(payload)
+    await stdin.flush()
+    stdin.end()
+    ;[stdoutText, stderrText, exit] = await Promise.all([
+      new Response(proc.stdout as ReadableStream).text(),
+      new Response(proc.stderr as ReadableStream).text(),
+      proc.exited,
+    ])
+  } catch (err) {
+    const msg = (err as Error).message ?? `cannot spawn ${bin}`
+    return {
+      reviewId: null,
+      comments: input.findingIds.map((id) => ({ id, status: 'failed' as const, message: msg })),
+      command,
+      payload,
+    }
+  }
+
+  if (exit !== 0) {
+    return {
+      reviewId: null,
+      comments: input.findingIds.map((id) => ({
+        id,
+        status: 'failed' as const,
+        message: stderrText.trim(),
+      })),
+      command,
+      payload,
+    }
+  }
+
+  const review = JSON.parse(stdoutText) as { id: number }
+  const reviewId = String(review.id)
+
+  // Persist to post-status.json.
+  const existing = await readPostStatus(input.runDir)
+  for (const id of input.findingIds) {
+    existing[id] = 'posted'
+  }
+  existing.__lastReviewId = reviewId
+  await writePostStatus(input.runDir, existing)
+
+  return {
+    reviewId,
+    comments: input.findingIds.map((id) => ({ id, status: 'posted' as const })),
+    command,
+    payload,
+  }
+}
+
 async function readPostStatus(runDir: string): Promise<Record<string, unknown>> {
   try {
     return (await Bun.file(join(runDir, 'post-status.json')).json()) as Record<string, unknown>

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

@@ -0,0 +1,300 @@
+import { mkdir, readFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import type { PostStatusMap } from './render-findings.ts'
+import { renderFindingsToDisk } from './render-findings.ts'
+import type { RenderProgressInput, StageId, StageStatus } from './render-progress.ts'
+import { renderProgressToDisk } from './render-progress.ts'
+import { parseFinding } from './types.ts'
+
+export type PreviewPage = 'findings' | 'progress' | 'both'
+
+/** Stage presets. Each one is a complete snapshot of what the pipeline page
+ * should look like at that point in the run. Keeping them as literal data
+ * (instead of synthesizing from a log file) lets a designer iterate on the
+ * progress UI without simulating events. */
+export const STAGE_PRESETS = {
+  fresh: {
+    stages: pending(),
+    counts: {},
+  },
+  'setup-running': {
+    stages: { ...pending(), setup: 'running' },
+    counts: {},
+  },
+  'setup-done': {
+    stages: { ...pending(), setup: 'done', context: 'running' },
+    counts: {},
+  },
+  'context-skipped': {
+    stages: { ...pending(), setup: 'done', context: 'skipped', specialists: 'running' },
+    counts: { security: 0, bugs: 1 },
+  },
+  'specialists-running': {
+    // Partial counts coming in while the specialists are mid-flight.
+    stages: {
+      ...pending(),
+      setup: 'done',
+      context: 'done',
+      specialists: 'running',
+    },
+    counts: { security: 1, bugs: 3, performance: 2, 'code-smells': 0, architecture: 0 },
+  },
+  'specialists-done': {
+    stages: {
+      ...pending(),
+      setup: 'done',
+      context: 'done',
+      specialists: 'done',
+      dedupe: 'running',
+    },
+    counts: { security: 1, bugs: 4, performance: 2, 'code-smells': 5, architecture: 3 },
+  },
+  'dedupe-done': {
+    stages: {
+      ...pending(),
+      setup: 'done',
+      context: 'done',
+      specialists: 'done',
+      dedupe: 'done',
+      critic: 'running',
+    },
+    counts: { security: 1, bugs: 3, performance: 2, 'code-smells': 4, architecture: 2 },
+  },
+  'critic-done': {
+    stages: {
+      ...pending(),
+      setup: 'done',
+      context: 'done',
+      specialists: 'done',
+      dedupe: 'done',
+      critic: 'done',
+      'peer-review': 'running',
+    },
+    counts: { security: 1, bugs: 2, performance: 1, 'code-smells': 3, architecture: 2 },
+  },
+  'peer-review-error': {
+    stages: {
+      ...pending(),
+      setup: 'done',
+      context: 'done',
+      specialists: 'done',
+      dedupe: 'done',
+      critic: 'done',
+      'peer-review': 'error',
+    },
+    counts: { security: 1, bugs: 2, performance: 1, 'code-smells': 3, architecture: 2 },
+  },
+  'report-done': {
+    // The default: what a reviewer sees when they open the page after the
+    // pipeline finishes but before they post anything.
+    stages: {
+      ...pending(),
+      setup: 'done',
+      context: 'done',
+      specialists: 'done',
+      dedupe: 'done',
+      critic: 'done',
+      'peer-review': 'done',
+      report: 'done',
+    },
+    counts: { security: 1, bugs: 2, performance: 2, 'code-smells': 2, architecture: 1 },
+  },
+  'post-done': {
+    stages: {
+      ...pending(),
+      setup: 'done',
+      context: 'done',
+      specialists: 'done',
+      dedupe: 'done',
+      critic: 'done',
+      'peer-review': 'done',
+      report: 'done',
+      post: 'done',
+    },
+    counts: { security: 1, bugs: 2, performance: 2, 'code-smells': 2, architecture: 1 },
+  },
+} as const
+
+function pending(): Record<StageId, StageStatus> {
+  return {
+    setup: 'pending',
+    context: 'pending',
+    specialists: 'pending',
+    dedupe: 'pending',
+    critic: 'pending',
+    'peer-review': 'pending',
+    report: 'pending',
+    post: 'pending',
+  }
+}
+
+export type StagePreset = keyof typeof STAGE_PRESETS
+
+export const DEFAULT_STAGE: StagePreset = 'report-done'
+
+export type PreviewOptions = {
+  page: PreviewPage
+  stage: StagePreset
+  /** Fixture directory; defaults to the bundled example-pr. */
+  fixtureDir?: string
+  /** Output directory; defaults to a timestamped path under ~/.magpie/. */
+  outDir?: string
+  /** When false, skip the OS `open` call (used by tests and dry runs). */
+  openInBrowser?: boolean
+  /** When true, do not write files; only resolve and return the planned paths. */
+  dryRun?: boolean
+  /** Allow tests / CI to inject the opener. Defaults to the system `open` / `xdg-open`. */
+  openerFactory?: () => Opener
+}
+
+export type PreviewResult = {
+  outDir: string
+  findingsHtml?: string
+  progressHtml?: string
+  opened?: string
+  dryRun?: boolean
+}
+
+export type Opener = (filePath: string) => Promise<void>
+
+function defaultOpener(): Opener {
+  return async (filePath) => {
+    const bin = process.platform === 'darwin' ? 'open' : 'xdg-open'
+    const proc = Bun.spawn([bin, filePath], { stdout: 'inherit', stderr: 'inherit' })
+    await proc.exited
+  }
+}
+
+function defaultFixtureDir(): string {
+  // The fixture lives next to this script, under fixtures/example-pr.
+  return new URL('../fixtures/example-pr', import.meta.url).pathname
+}
+
+function defaultOutDir(): string {
+  const home = process.env.HOME || '/tmp'
+  return join(home, '.magpie', `preview-${Date.now()}`)
+}
+
+async function readFixture(fixtureDir: string): Promise<{
+  pr: { number: number; branch: string; headSha: string }
+  findings: ReturnType<typeof parseFinding>[]
+  postStatus: PostStatusMap
+  files: Array<{ path: string; additions: number; deletions: number }>
+  diff: string
+}> {
+  const prRaw = JSON.parse(await readFile(join(fixtureDir, 'pr.json'), 'utf8')) as Record<
+    string,
+    unknown
+  >
+  const findingsRaw = JSON.parse(
+    await readFile(join(fixtureDir, 'findings.final.json'), 'utf8'),
+  ) as unknown[]
+  let postStatusRaw: Record<string, unknown> = {}
+  try {
+    postStatusRaw = JSON.parse(
+      await readFile(join(fixtureDir, 'post-status.json'), 'utf8'),
+    ) as Record<string, unknown>
+  } catch {
+    // optional file
+  }
+  let filesArray: Array<{ path: string; additions: number; deletions: number }> = []
+  if (Array.isArray(prRaw.files)) {
+    filesArray = (prRaw.files as unknown[]).map((f) => {
+      const entry = f as Record<string, unknown>
+      return {
+        path: String(entry.path ?? ''),
+        additions: Number(entry.additions ?? 0),
+        deletions: Number(entry.deletions ?? 0),
+      }
+    })
+  }
+  let diff = ''
+  try {
+    diff = await readFile(join(fixtureDir, 'diff.patch'), 'utf8')
+  } catch {
+    // optional file
+  }
+  return {
+    pr: {
+      number: Number(prRaw.number ?? 0),
+      branch: String(prRaw.headRefName ?? '?'),
+      headSha: String(prRaw.headRefOid ?? '?'),
+    },
+    findings: findingsRaw.map((raw) => parseFinding(raw)),
+    postStatus: postStatusRaw as PostStatusMap,
+    files: filesArray,
+    diff,
+  }
+}
+
+function progressInput(
+  pr: { number: number; branch: string; headSha: string },
+  stage: StagePreset,
+): RenderProgressInput {
+  const preset = STAGE_PRESETS[stage]
+  return {
+    prNumber: pr.number,
+    branch: pr.branch,
+    headSha: pr.headSha,
+    stages: preset.stages,
+    specialistCounts: preset.counts,
+  }
+}
+
+export async function runPreview(opts: PreviewOptions): Promise<PreviewResult> {
+  const fixtureDir = opts.fixtureDir ?? defaultFixtureDir()
+  const outDir = opts.outDir ?? defaultOutDir()
+  const fixture = await readFixture(fixtureDir)
+  const findingsPath = join(outDir, 'findings.html')
+  const progressPath = join(outDir, 'progress.html')
+
+  if (opts.dryRun) {
+    return {
+      outDir,
+      ...(opts.page !== 'progress' ? { findingsHtml: findingsPath } : {}),
+      ...(opts.page !== 'findings' ? { progressHtml: progressPath } : {}),
+      dryRun: true,
+    }
+  }
+
+  await mkdir(outDir, { recursive: true })
+
+  const result: PreviewResult = { outDir }
+
+  if (opts.page !== 'progress') {
+    await renderFindingsToDisk(
+      {
+        findings: fixture.findings,
+        postStatus: fixture.postStatus,
+        runId: `preview-${opts.stage}`,
+        pr: fixture.pr,
+        files: fixture.files,
+        diff: fixture.diff,
+      },
+      findingsPath,
+    )
+    result.findingsHtml = findingsPath
+  }
+
+  if (opts.page !== 'findings') {
+    await renderProgressToDisk(progressInput(fixture.pr, opts.stage), progressPath)
+    result.progressHtml = progressPath
+  }
+
+  if (opts.openInBrowser !== false) {
+    const opener = (opts.openerFactory ?? defaultOpener)()
+    // Open findings if requested, else progress.
+    const target =
+      opts.page === 'progress'
+        ? progressPath
+        : opts.page === 'findings'
+          ? findingsPath
+          : findingsPath
+    await opener(target)
+    result.opened = target
+  }
+
+  return result
+}
+
+export const KNOWN_STAGE_PRESETS = Object.keys(STAGE_PRESETS) as StagePreset[]

package/skills/magpie/scripts/refresh.ts

@@ -59,8 +59,23 @@ export async function refreshFindings(runDir: string): Promise<RefreshResult> {
     // optional file
   }
 
+  let pr: { number: number; branch: string; headSha: string } | undefined
+  try {
+    const prJson = (await Bun.file(join(runDir, 'pr.json')).json()) as Record<string, unknown>
+    const prNumber = Number(prJson.number ?? 0)
+    if (prNumber > 0) {
+      pr = {
+        number: prNumber,
+        branch: String(prJson.headRefName ?? '?'),
+        headSha: String(prJson.headRefOid ?? '?'),
+      }
+    }
+  } catch {
+    // optional file; archived runs may not include pr.json
+  }
+
   await renderFindingsToDisk(
-    { findings, postStatus, runId: basename(runDir) },
+    { findings, postStatus, runId: basename(runDir), pr },
     join(screenDir, 'findings.html'),
   )
 

package/skills/magpie/scripts/render-action-bar.ts

@@ -0,0 +1,51 @@
+import { isSuggestion, type ReviewFinding, SEVERITIES, type Severity } from './types.ts'
+
+const SEVERITY_LABEL: Record<Severity, string> = {
+  blocker: 'Blocker',
+  high: 'High',
+  medium: 'Medium',
+  low: 'Low',
+}
+
+function esc(s: string): string {
+  return s.replace(/[&<>"']/g, (c) => {
+    const m: Record<string, string> = {
+      '&': '&amp;',
+      '<': '&lt;',
+      '>': '&gt;',
+      '"': '&quot;',
+      "'": '&#39;',
+    }
+    return m[c] ?? c
+  })
+}
+
+export type RenderActionBarInput = {
+  findings: ReviewFinding[]
+}
+
+export function renderActionBar(input: RenderActionBarInput): string {
+  const recommended = input.findings.filter((f) => !isSuggestion(f))
+  const excluded = input.findings.length - recommended.length
+  const counts = new Map<Severity, number>()
+  for (const f of recommended) counts.set(f.severity, (counts.get(f.severity) ?? 0) + 1)
+  const pills = SEVERITIES.filter((s) => (counts.get(s) ?? 0) > 0)
+    .map(
+      (s) =>
+        `<button type="button" class="action-pill sev-${s}" data-action="select-sev" data-sev="${s}" aria-pressed="false">${esc(SEVERITY_LABEL[s])} (${counts.get(s) ?? 0})</button>`,
+    )
+    .join('')
+  const excludedHint =
+    excluded > 0
+      ? `<span class="excluded">${excluded} suggestion${excluded === 1 ? '' : 's'} excluded</span>`
+      : ''
+  return `<footer class="action-bar" data-role="action-bar">
+    <button type="button" class="link-btn" data-action="select-recommended">Select recommended</button>
+    <div class="pills">${pills}</div>
+    <div class="spacer"></div>
+    <button type="button" class="btn outline" data-action="post-selected" disabled>Post Selected (<span data-role="selected-count">0</span>)</button>
+    <button type="button" class="btn primary" data-action="post-recommended">Post Recommended (${recommended.length})</button>
+    ${excludedHint}
+    <p class="post-status" data-role="post-status" role="status" aria-live="polite" hidden></p>
+  </footer>`
+}

package/skills/magpie/scripts/render-annotation.ts

@@ -0,0 +1,96 @@
+import { parseFindingDescription } from './finding-description.ts'
+import { isSuggestion, type ReviewFinding } from './types.ts'
+
+const DOMAIN_LABELS: Record<string, string> = {
+  security: 'Security',
+  bugs: 'Bugs',
+  performance: 'Perf',
+  'code-smells': 'Smells',
+  architecture: 'Arch',
+}
+
+const SEVERITY_LABEL: Record<string, string> = {
+  blocker: 'BLOCKER',
+  high: 'HIGH',
+  medium: 'MEDIUM',
+  low: 'LOW',
+}
+
+function esc(s: string): string {
+  return s.replace(/[&<>"']/g, (c) => {
+    const m: Record<string, string> = {
+      '&': '&amp;',
+      '<': '&lt;',
+      '>': '&gt;',
+      '"': '&quot;',
+      "'": '&#39;',
+    }
+    return m[c] ?? c
+  })
+}
+
+export type RenderAnnotationOptions = {
+  checked: boolean
+  posted: boolean
+  asCard: boolean
+  /** When posting previously failed, surface the failure on the card. */
+  failed?: { message: string }
+}
+
+function renderSections(description: string): string {
+  const sections = parseFindingDescription(description)
+  if (sections.length === 0) {
+    return `<section class="section"><div class="section-label">Observation</div><div class="section-body">${esc(description.trim())}</div></section>`
+  }
+  return sections
+    .map(
+      (s) =>
+        `<section class="section"><div class="section-label">${esc(s.label)}</div><div class="section-body">${esc(s.body)}</div></section>`,
+    )
+    .join('')
+}
+
+function renderSuggestion(f: ReviewFinding): string {
+  if (!f.suggestion) return ''
+  return `<section class="section"><div class="section-label">Suggested change</div><pre class="suggestion">${esc(f.suggestion.body)}</pre></section>`
+}
+
+function renderRisk(f: ReviewFinding): string {
+  return `<div class="risk">Impact: <span class="tag">${esc(f.risk.impact)}</span> · Likelihood: <span class="tag">${esc(f.risk.likelihood)}</span> · Confidence: <span class="tag">${esc(f.risk.confidence)}</span> · Action: <span class="tag">${esc(f.risk.action)}</span></div>`
+}
+
+export function renderAnnotation(f: ReviewFinding, opts: RenderAnnotationOptions): string {
+  const domain = (f.domain as string) ?? 'unknown'
+  const domainLabel = DOMAIN_LABELS[domain] ?? domain
+  const sevLabel = SEVERITY_LABEL[f.severity] ?? f.severity.toUpperCase()
+  const containerClass = opts.asCard ? `issue-card sev-${f.severity}` : `annot sev-${f.severity}`
+  const cbAttrs = opts.posted ? 'checked disabled' : opts.checked ? 'checked' : ''
+  const suggestion = isSuggestion(f) ? 'true' : 'false'
+  const postedAttr = opts.posted ? ' data-posted="true"' : ''
+  const failedAttr = opts.failed ? ' data-failed="true"' : ''
+  let statusChip: string
+  if (opts.posted) {
+    statusChip = '<span class="status-chip posted">POSTED</span>'
+  } else if (opts.failed) {
+    statusChip = `<span class="status-chip failed" title="${esc(opts.failed.message)}">FAILED: ${esc(opts.failed.message)}</span>`
+  } else {
+    statusChip = '<span class="status-chip new">NEW</span>'
+  }
+  return `<div class="${containerClass}" data-finding-id="${esc(f.id)}" data-severity="${f.severity}" data-domain="${esc(domain)}" data-suggestion="${suggestion}"${postedAttr}${failedAttr}>
+  <div class="annot-row">
+    <input type="checkbox" data-finding-id="${esc(f.id)}" ${cbAttrs} aria-label="select ${esc(f.id)}" />
+    <div class="annot-body">
+      <div class="annot-head">
+        <span class="sev-label sev-${f.severity}">${sevLabel}</span>
+        <span class="annot-title">${esc(f.title)}</span>
+        <span class="domain-chip">${esc(domainLabel)}</span>
+        ${statusChip}
+      </div>
+      ${renderSections(f.description)}
+      ${renderSuggestion(f)}
+      ${renderRisk(f)}
+    </div>
+    <button type="button" class="send-btn" data-action="post-one" data-finding-id="${esc(f.id)}" title="Post this finding" aria-label="post">▸</button>
+  </div>
+</div>`
+}