@iceinvein/agent-skills 0.1.24 → 0.1.26

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

@@ -52,6 +52,49 @@ test('renderProgressHtml renders empty specialists-line before any focus reports
   expect(html).toContain('awaiting specialist output')
 })
 
+test('pipeline carries a --done-count style for the filling connector line', () => {
+  const html = renderProgressHtml({
+    prNumber: 1,
+    headSha: 'abcd1234',
+    branch: 'main',
+    stages: {
+      setup: 'done',
+      context: 'done',
+      specialists: 'done',
+      dedupe: 'running',
+      critic: 'pending',
+      'peer-review': 'pending',
+      report: 'pending',
+      post: 'pending',
+    },
+    specialistCounts: {},
+  })
+  // CSS uses --done-count / 7 to compute the connector fill width.
+  expect(html).toContain('--done-count: 3')
+})
+
+test('each pipeline stage exposes a short sublabel so first-timers can learn what it does', () => {
+  const html = renderProgressHtml({
+    prNumber: 1,
+    headSha: 'abcd1234',
+    branch: 'main',
+    stages: {
+      setup: 'done',
+      context: 'pending',
+      specialists: 'pending',
+      dedupe: 'pending',
+      critic: 'pending',
+      'peer-review': 'pending',
+      report: 'pending',
+      post: 'pending',
+    },
+    specialistCounts: {},
+  })
+  expect(html).toContain('class="hint"')
+  expect(html).toContain('five reviewers in parallel')
+  expect(html).toContain('second opinion via codex')
+})
+
 test('renderProgressHtml includes the archived banner element', () => {
   const html = renderProgressHtml({
     prNumber: 1,
@@ -71,3 +114,46 @@ test('renderProgressHtml includes the archived banner element', () => {
   })
   expect(html).toContain('archived-banner')
 })
+
+test('emits the shared pr-header chrome', () => {
+  const html = renderProgressHtml({
+    prNumber: 1,
+    headSha: 'abc123def456789012345678',
+    branch: 'feat',
+    stages: {
+      setup: 'running',
+      context: 'pending',
+      specialists: 'pending',
+      dedupe: 'pending',
+      critic: 'pending',
+      'peer-review': 'pending',
+      report: 'pending',
+      post: 'pending',
+    },
+    specialistCounts: {},
+  })
+  expect(html).toContain('class="pr-header"')
+  expect(html).toContain('data-page="progress"')
+  expect(html).toContain('class="segmented"')
+})
+
+test('progress-pane block replaces diff-pane on the progress page', () => {
+  const html = renderProgressHtml({
+    prNumber: 1,
+    headSha: 'abc123def456789012345678',
+    branch: 'feat',
+    stages: {
+      setup: 'done',
+      context: 'running',
+      specialists: 'pending',
+      dedupe: 'pending',
+      critic: 'pending',
+      'peer-review': 'pending',
+      report: 'pending',
+      post: 'pending',
+    },
+    specialistCounts: { security: 0 },
+  })
+  expect(html).toContain('data-role="progress-pane"')
+  expect(html).toContain('Indexing repo symbols')
+})

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

@@ -137,3 +137,57 @@ test('writes server-info on start with url and port', async () => {
   expect(typeof info.port).toBe('number')
   expect(info.pid).toBe(process.pid)
 })
+
+test('POST /api/post-review returns reviewId under dry-run', async () => {
+  process.env.MAGPIE_DRY_RUN_POST = '1'
+  await writeFile(join(runDir, 'screen', 'a.html'), '<h1>X</h1>')
+  await writeFile(
+    join(runDir, 'pr.json'),
+    JSON.stringify({
+      number: 7,
+      headRefOid: 'abcdef00',
+      url: 'https://github.com/o/r/pull/7',
+    }),
+  )
+  await writeFile(
+    join(runDir, 'findings.json'),
+    JSON.stringify([
+      {
+        id: '1',
+        file: 'a.ts',
+        line: 1,
+        severity: 'blocker',
+        risk: { impact: 'critical', likelihood: 'likely', confidence: 'high', action: 'must-fix' },
+        title: 't1',
+        description: 'd1',
+        domain: 'security',
+      },
+      {
+        id: '2',
+        file: 'b.ts',
+        line: 2,
+        severity: 'warning',
+        risk: {
+          impact: 'medium',
+          likelihood: 'possible',
+          confidence: 'medium',
+          action: 'should-fix',
+        },
+        title: 't2',
+        description: 'd2',
+        domain: 'performance',
+      },
+    ]),
+  )
+  server = await startServer({ runDir, idleMs: 60_000 })
+  const res = await fetch(`${server.url}/api/post-review`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({ findingIds: ['1', '2'] }),
+  })
+  expect(res.status).toBe(200)
+  const body = (await res.json()) as { comments: Array<{ id: string; status: string }> }
+  expect(Array.isArray(body.comments)).toBe(true)
+  expect(body.comments).toHaveLength(2)
+  delete process.env.MAGPIE_DRY_RUN_POST
+})

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

@@ -1,6 +1,6 @@
-import { expect, test } from 'bun:test'
-import type { FocusId, ReviewFinding } from '../types.ts'
-import { FOCUS_IDS, parseFinding } from '../types.ts'
+import { describe, expect, test } from 'bun:test'
+import type { FocusId, PrFileEntry, ReviewFinding } from '../types.ts'
+import { FOCUS_IDS, isSuggestion, parseFinding } from '../types.ts'
 
 test('FOCUS_IDS contains the five default focuses', () => {
   expect(FOCUS_IDS).toEqual(['security', 'bugs', 'performance', 'code-smells', 'architecture'])
@@ -51,3 +51,48 @@ test('parseFinding accepts null line', () => {
   })
   expect(parsed.line).toBeNull()
 })
+
+describe('PrFileEntry', () => {
+  test('shape is { path, additions, deletions }', () => {
+    const f: PrFileEntry = { path: 'src/a.ts', additions: 10, deletions: 2 }
+    expect(f.path).toBe('src/a.ts')
+    expect(f.additions).toBe(10)
+    expect(f.deletions).toBe(2)
+  })
+})
+
+describe('isSuggestion', () => {
+  const base = {
+    id: '1',
+    file: 'a.ts',
+    line: 1,
+    severity: 'low' as const,
+    title: 't',
+    description: 'd',
+    risk: {
+      impact: 'low' as const,
+      likelihood: 'unknown' as const,
+      confidence: 'medium' as const,
+      action: 'optional' as const,
+    },
+    domain: 'security' as const,
+  }
+  test('returns true for action=optional', () => {
+    expect(isSuggestion(parseFinding({ ...base }))).toBe(true)
+  })
+  test('returns true for action=consider', () => {
+    expect(
+      isSuggestion(parseFinding({ ...base, risk: { ...base.risk, action: 'consider' } })),
+    ).toBe(true)
+  })
+  test('returns false for action=must-fix', () => {
+    expect(
+      isSuggestion(parseFinding({ ...base, risk: { ...base.risk, action: 'must-fix' } })),
+    ).toBe(false)
+  })
+  test('returns false for action=should-fix', () => {
+    expect(
+      isSuggestion(parseFinding({ ...base, risk: { ...base.risk, action: 'should-fix' } })),
+    ).toBe(false)
+  })
+})

package/skills/magpie/scripts/diff-utils.ts

@@ -0,0 +1,129 @@
+export type DiffLine = {
+  type: 'context' | 'added' | 'removed'
+  content: string
+  oldLineNo: number | null
+  newLineNo: number | null
+}
+
+export type DiffHunk = {
+  oldStart: number
+  oldLines: number
+  newStart: number
+  newLines: number
+  header: string
+  lines: DiffLine[]
+}
+
+const HUNK_HEADER = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)$/m
+const FILE_HEADER = /^diff --git a\/(.+?) b\/(.+)$/m
+
+export function parseUnifiedDiffToHunks(diff: string): DiffHunk[] {
+  if (!diff) return []
+  const lines = diff.split('\n')
+  const hunks: DiffHunk[] = []
+  let current: DiffHunk | null = null
+  let oldNo = 0
+  let newNo = 0
+
+  for (const raw of lines) {
+    const m = raw.match(HUNK_HEADER)
+    if (m) {
+      current = {
+        oldStart: Number(m[1]),
+        oldLines: m[2] ? Number(m[2]) : 1,
+        newStart: Number(m[3]),
+        newLines: m[4] ? Number(m[4]) : 1,
+        header: m[5] ?? '',
+        lines: [],
+      }
+      oldNo = current.oldStart
+      newNo = current.newStart
+      hunks.push(current)
+      continue
+    }
+    if (!current) continue
+    if (raw.startsWith('\\')) continue
+    if (raw.startsWith('+++') || raw.startsWith('---')) continue
+    if (raw.length === 0) continue
+    const first = raw[0]
+    if (first === '+') {
+      current.lines.push({
+        type: 'added',
+        content: raw.slice(1),
+        oldLineNo: null,
+        newLineNo: newNo,
+      })
+      newNo += 1
+    } else if (first === '-') {
+      current.lines.push({
+        type: 'removed',
+        content: raw.slice(1),
+        oldLineNo: oldNo,
+        newLineNo: null,
+      })
+      oldNo += 1
+    } else if (first === ' ') {
+      current.lines.push({
+        type: 'context',
+        content: raw.slice(1),
+        oldLineNo: oldNo,
+        newLineNo: newNo,
+      })
+      oldNo += 1
+      newNo += 1
+    }
+  }
+  return hunks
+}
+
+export function splitDiffByFile(diff: string): Map<string, string> {
+  const m = new Map<string, string>()
+  if (!diff) return m
+  const chunks = diff.split(/^(?=diff --git )/m)
+  for (const chunk of chunks) {
+    if (!chunk.startsWith('diff --git ')) continue
+    const headerMatch = chunk.match(FILE_HEADER)
+    if (!headerMatch || !headerMatch[2]) continue
+    m.set(headerMatch[2], chunk)
+  }
+  return m
+}
+
+export function filePathMatches(a: string, b: string): boolean {
+  const norm = (p: string) => p.replace(/^[ab]\//, '')
+  return norm(a) === norm(b)
+}
+
+export type PairedLine = { left: DiffLine | null; right: DiffLine | null }
+
+export function buildPairedLines(hunks: DiffHunk[]): PairedLine[] {
+  const rows: PairedLine[] = []
+  for (const h of hunks) {
+    let i = 0
+    while (i < h.lines.length) {
+      const cur = h.lines[i]
+      if (!cur) {
+        i += 1
+        continue
+      }
+      const next = h.lines[i + 1] ?? null
+      if (cur.type === 'context') {
+        rows.push({ left: cur, right: cur })
+        i += 1
+        continue
+      }
+      if (cur.type === 'removed' && next?.type === 'added') {
+        rows.push({ left: cur, right: next })
+        i += 2
+        continue
+      }
+      if (cur.type === 'removed') {
+        rows.push({ left: cur, right: null })
+      } else {
+        rows.push({ left: null, right: cur })
+      }
+      i += 1
+    }
+  }
+  return rows
+}

package/skills/magpie/scripts/file-tree.ts

@@ -0,0 +1,74 @@
+import { filePathMatches } from './diff-utils.ts'
+import { type PrFileEntry, type ReviewFinding, SEVERITIES, type Severity } from './types.ts'
+
+export type DirNode = {
+  name: string
+  fullPath: string
+  files: PrFileEntry[]
+  dirs: Map<string, DirNode>
+}
+
+export function buildTree(files: PrFileEntry[]): DirNode {
+  const root: DirNode = { name: '', fullPath: '', files: [], dirs: new Map() }
+  for (const file of files) {
+    const parts = file.path.split('/')
+    let node = root
+    for (let i = 0; i < parts.length - 1; i++) {
+      const dirName = parts[i]
+      if (!dirName) continue
+      if (!node.dirs.has(dirName)) {
+        const parentPath = node.fullPath ? `${node.fullPath}/${dirName}` : dirName
+        node.dirs.set(dirName, { name: dirName, fullPath: parentPath, files: [], dirs: new Map() })
+      }
+      const next = node.dirs.get(dirName)
+      if (!next) throw new Error('unreachable')
+      node = next
+    }
+    node.files.push(file)
+  }
+  return root
+}
+
+export function collapseTree(node: DirNode): DirNode {
+  const collapsedDirs = new Map<string, DirNode>()
+  for (const [, dir] of node.dirs) {
+    let current = dir
+    let label = current.name
+    while (current.files.length === 0 && current.dirs.size === 1) {
+      const child = [...current.dirs.values()][0]
+      if (!child) break
+      label = `${label}/${child.name}`
+      current = child
+    }
+    const collapsed = collapseTree(current)
+    collapsed.name = label
+    collapsedDirs.set(label, collapsed)
+  }
+  return { ...node, dirs: collapsedDirs }
+}
+
+export function findingCountsBySeverity(
+  findings: ReviewFinding[],
+  filePath: string,
+): { severity: Severity; count: number }[] {
+  const fileFindings = findings.filter((f) => f.file && filePathMatches(f.file, filePath))
+  if (fileFindings.length === 0) return []
+  const counts = new Map<Severity, number>()
+  for (const f of fileFindings) counts.set(f.severity, (counts.get(f.severity) ?? 0) + 1)
+  return SEVERITIES.filter((s) => counts.has(s)).map((s) => ({
+    severity: s,
+    count: counts.get(s) ?? 0,
+  }))
+}
+
+function collectPaths(node: DirNode): string[] {
+  const paths: string[] = node.files.map((f) => f.path)
+  for (const dir of node.dirs.values()) paths.push(...collectPaths(dir))
+  return paths
+}
+
+export function countDirFindings(findings: ReviewFinding[], node: DirNode): number {
+  const paths = collectPaths(node)
+  return findings.filter((f) => f.file && paths.some((p) => filePathMatches(f.file as string, p)))
+    .length
+}

package/skills/magpie/scripts/gh.ts

@@ -25,6 +25,7 @@ const PR_VIEW_FIELDS = [
   // `url` is included so server-side posting can parse owner/repo without
   // depending on cwd (the worktree is gone after cleanup).
   'url',
+  'files',
 ].join(',')
 
 export async function fetchPr(input: FetchPrInput): Promise<FetchPrResult> {