@pyreon/cli 0.15.0 → 0.18.0

package/src/tests/orchestrator.test.ts

@@ -0,0 +1,72 @@
+import { describe, expect, it } from 'vitest'
+
+import { resolveGates } from '../doctor/orchestrator'
+
+describe('resolveGates', () => {
+  it('default = 8 fast gates (no audit-types / bundle-budgets)', () => {
+    const gates = resolveGates({ cwd: '/' })
+    expect(gates).toEqual([
+      'react-patterns',
+      'pyreon-patterns',
+      'lint',
+      'distribution',
+      'doc-claims',
+      'islands-audit',
+      'ssg-audit',
+      'audit-tests',
+    ])
+  })
+
+  it('--full enables 10 gates total (adds the 2 slow ones)', () => {
+    const gates = resolveGates({ cwd: '/', full: true })
+    expect(gates).toContain('audit-types')
+    expect(gates).toContain('bundle-budgets')
+    expect(gates).toHaveLength(10)
+  })
+
+  it('--only restricts to the listed gates', () => {
+    const gates = resolveGates({
+      cwd: '/',
+      only: ['lint', 'doc-claims'],
+    })
+    expect(gates).toEqual(['lint', 'doc-claims'])
+  })
+
+  it('--only overrides --full (only wins precedence)', () => {
+    const gates = resolveGates({
+      cwd: '/',
+      full: true,
+      only: ['lint'],
+    })
+    expect(gates).toEqual(['lint'])
+  })
+
+  it('--skip removes from the default set', () => {
+    const gates = resolveGates({
+      cwd: '/',
+      skip: ['lint', 'pyreon-patterns'],
+    })
+    expect(gates).not.toContain('lint')
+    expect(gates).not.toContain('pyreon-patterns')
+    expect(gates).toContain('react-patterns')
+  })
+
+  it('--skip applies after --only (intersection)', () => {
+    const gates = resolveGates({
+      cwd: '/',
+      only: ['lint', 'doc-claims', 'distribution'],
+      skip: ['doc-claims'],
+    })
+    expect(gates).toEqual(['lint', 'distribution'])
+  })
+
+  it('empty --only falls through to default + --skip', () => {
+    const gates = resolveGates({
+      cwd: '/',
+      only: [],
+      skip: ['lint'],
+    })
+    expect(gates).not.toContain('lint')
+    expect(gates).toContain('react-patterns')
+  })
+})

package/src/tests/render.test.ts

@@ -0,0 +1,213 @@
+import { describe, expect, it } from 'vitest'
+
+import { buildReport } from '../doctor/report'
+import { renderGha, renderJson, renderText } from '../doctor/render'
+import type { Finding, GateResult } from '../doctor/types'
+
+// Strip ANSI for assertions. We test in a controlled NO_COLOR env via
+// `FORCE_COLOR=0` at runtime (set in vitest.config or per-run), but
+// the test environment may still have a TTY — so strip defensively.
+const stripAnsi = (s: string): string =>
+  // eslint-disable-next-line no-control-regex
+  s.replace(/\[[0-9;]*m/g, '').replace(/\][^]*\\/g, '')
+
+const f = (
+  severity: Finding['severity'],
+  category: Finding['category'],
+  code: string,
+  extra: Partial<Finding> = {},
+): Finding => ({
+  severity,
+  category,
+  code,
+  gate: 'test',
+  message: `Message for ${code}`,
+  ...extra,
+})
+
+const g = (
+  gate: string,
+  category: GateResult['category'],
+  findings: Finding[] = [],
+  meta: Partial<GateResult['meta']> = {},
+): GateResult => ({
+  gate,
+  category,
+  findings,
+  meta: { elapsedMs: 1, ...meta },
+})
+
+describe('renderText', () => {
+  it('renders the banner with score + grade', () => {
+    const report = buildReport([g('lint', 'correctness')])
+    const out = stripAnsi(renderText(report, { cwd: '/' }))
+    expect(out).toContain('pyreon doctor')
+    expect(out).toContain('Score:')
+    expect(out).toContain('100')
+    expect(out).toContain('Grade:')
+    expect(out).toContain('A')
+  })
+
+  it('renders per-category bar chart', () => {
+    const report = buildReport([
+      g('lint', 'correctness', [f('error', 'correctness', 'a/x')]),
+      g('distribution', 'architecture'),
+    ])
+    const out = stripAnsi(renderText(report, { cwd: '/' }))
+    expect(out).toContain('correctness')
+    expect(out).toContain('architecture')
+    expect(out).toContain('90') // 100 - 10 for one error
+    expect(out).toContain('1E') // 1 error breakdown
+  })
+
+  it('shows "skipped" for uncovered categories', () => {
+    const report = buildReport([g('lint', 'correctness')])
+    const out = stripAnsi(renderText(report, { cwd: '/' }))
+    expect(out).toContain('performance')
+    expect(out).toContain('skipped')
+  })
+
+  it('lists top-N findings with severity icon + code + message', () => {
+    const report = buildReport([
+      g('lint', 'correctness', [
+        f('error', 'correctness', 'lint/no-x'),
+        f('warning', 'correctness', 'lint/no-y'),
+      ]),
+    ])
+    const out = stripAnsi(renderText(report, { cwd: '/' }))
+    expect(out).toContain('lint/no-x')
+    expect(out).toContain('Message for lint/no-x')
+    expect(out).toContain('lint/no-y')
+  })
+
+  it('shows clean green-light when no findings', () => {
+    const report = buildReport([g('lint', 'correctness')])
+    const out = stripAnsi(renderText(report, { cwd: '/' }))
+    expect(out).toContain('No findings')
+  })
+
+  it('lists skipped gates in the footer', () => {
+    const report = buildReport([
+      g('lint', 'correctness'),
+      g('bundle-budgets', 'performance', [], {
+        skipped: true,
+        skipReason: 'enable with --full',
+      }),
+    ])
+    const out = stripAnsi(renderText(report, { cwd: '/' }))
+    expect(out).toContain('Skipped:')
+    expect(out).toContain('bundle-budgets')
+    expect(out).toContain('enable with --full')
+  })
+
+  it('shows fix hint when finding has one', () => {
+    const report = buildReport([
+      g('lint', 'correctness', [
+        f('warning', 'correctness', 'lint/x', { fix: 'Use `class` instead.' }),
+      ]),
+    ])
+    const out = stripAnsi(renderText(report, { cwd: '/' }))
+    expect(out).toContain('fix:')
+    expect(out).toContain('Use `class` instead.')
+  })
+
+  it('shows location with line:col when present', () => {
+    const report = buildReport([
+      g('lint', 'correctness', [
+        f('warning', 'correctness', 'lint/x', {
+          location: {
+            path: '/abs/file.ts',
+            relPath: 'file.ts',
+            line: 42,
+            column: 7,
+          },
+        }),
+      ]),
+    ])
+    const out = stripAnsi(renderText(report, { cwd: '/' }))
+    expect(out).toContain('file.ts:42:7')
+  })
+
+  it('truncates to topN with "and N more" hint', () => {
+    const findings = Array(15).fill(null).map((_, i) =>
+      f('info', 'correctness', `lint/x${i}`),
+    )
+    const report = buildReport([g('lint', 'correctness', findings)])
+    const out = stripAnsi(renderText(report, { cwd: '/', topN: 3 }))
+    expect(out).toContain('and 12 more')
+  })
+})
+
+describe('renderJson', () => {
+  it('emits a parseable JSON object', () => {
+    const report = buildReport([g('lint', 'correctness')])
+    const json = renderJson(report)
+    const parsed = JSON.parse(json)
+    expect(parsed.score).toBe(100)
+    expect(parsed.grade).toBe('A')
+    expect(Array.isArray(parsed.findings)).toBe(true)
+    expect(Array.isArray(parsed.categories)).toBe(true)
+    expect(Array.isArray(parsed.gates)).toBe(true)
+  })
+})
+
+describe('renderGha', () => {
+  it('emits a notice header with score + totals', () => {
+    const report = buildReport([
+      g('lint', 'correctness', [
+        f('error', 'correctness', 'lint/err'),
+        f('warning', 'correctness', 'lint/warn'),
+      ]),
+    ])
+    const out = renderGha(report)
+    expect(out).toMatch(/^::notice::pyreon doctor score:/)
+    expect(out).toContain('1 errors, 1 warnings')
+  })
+
+  it('emits per-finding annotation with file + line + col', () => {
+    const report = buildReport([
+      g('lint', 'correctness', [
+        f('error', 'correctness', 'lint/err', {
+          location: {
+            path: '/abs/file.ts',
+            relPath: 'src/file.ts',
+            line: 10,
+            column: 5,
+          },
+        }),
+      ]),
+    ])
+    const out = renderGha(report)
+    expect(out).toContain('::error ')
+    expect(out).toContain('file=src/file.ts')
+    expect(out).toContain('line=10')
+    expect(out).toContain('col=5')
+  })
+
+  it('maps severity correctly (error → error, warning → warning, info → notice)', () => {
+    const report = buildReport([
+      g('lint', 'correctness', [
+        f('error', 'correctness', 'a'),
+        f('warning', 'correctness', 'b'),
+        f('info', 'correctness', 'c'),
+      ]),
+    ])
+    const out = renderGha(report)
+    expect(out).toContain('::error ')
+    expect(out).toContain('::warning ')
+    // notice appears for both the header AND the info finding
+    expect((out.match(/::notice/g) ?? []).length).toBeGreaterThanOrEqual(2)
+  })
+
+  it('URL-encodes special chars in messages', () => {
+    const report = buildReport([
+      g('lint', 'correctness', [
+        f('error', 'correctness', 'a', {
+          message: 'line1\nline2',
+        }),
+      ]),
+    ])
+    const out = renderGha(report)
+    expect(out).toContain('%0A') // newline encoded
+  })
+})

package/src/tests/report.test.ts

@@ -0,0 +1,99 @@
+import { describe, expect, it } from 'vitest'
+
+import { buildReport } from '../doctor/report'
+import type { Finding, GateResult } from '../doctor/types'
+
+const f = (
+  severity: Finding['severity'],
+  category: Finding['category'],
+  code: string,
+): Finding => ({
+  severity,
+  category,
+  code,
+  gate: 'test',
+  message: 'm',
+})
+
+const g = (
+  gate: string,
+  category: GateResult['category'],
+  findings: Finding[] = [],
+  elapsedMs = 10,
+): GateResult => ({
+  gate,
+  category,
+  findings,
+  meta: { elapsedMs },
+})
+
+describe('buildReport', () => {
+  it('produces a clean report when no gates run', () => {
+    const report = buildReport([])
+    expect(report.score).toBe(100)
+    expect(report.grade).toBe('A')
+    expect(report.findings).toEqual([])
+    expect(report.totals).toEqual({ errors: 0, warnings: 0, infos: 0 })
+    expect(report.elapsedMs).toBe(0)
+    expect(report.timestamp).toMatch(/^\d{4}-\d{2}-\d{2}T/)
+  })
+
+  it('sorts findings: errors → warnings → infos, then by category, then by code', () => {
+    const gates = [
+      g('a', 'correctness', [
+        f('info', 'documentation', 'a/info'),
+        f('warning', 'performance', 'a/warn'),
+      ]),
+      g('b', 'architecture', [
+        f('error', 'correctness', 'b/err1'),
+        f('error', 'architecture', 'b/err2'),
+      ]),
+    ]
+    const report = buildReport(gates)
+    // Errors first, sorted by category (architecture < correctness alphabetically)
+    expect(report.findings.map((x) => x.code)).toEqual([
+      'b/err2',
+      'b/err1',
+      'a/warn',
+      'a/info',
+    ])
+  })
+
+  it('counts totals across gates', () => {
+    const gates = [
+      g('a', 'correctness', [
+        f('error', 'correctness', 'a'),
+        f('error', 'correctness', 'b'),
+        f('warning', 'correctness', 'c'),
+        f('info', 'correctness', 'd'),
+      ]),
+    ]
+    const report = buildReport(gates)
+    expect(report.totals.errors).toBe(2)
+    expect(report.totals.warnings).toBe(1)
+    expect(report.totals.infos).toBe(1)
+  })
+
+  it('sums elapsedMs across gates (proxy for total CPU work)', () => {
+    const gates = [
+      g('a', 'correctness', [], 100),
+      g('b', 'architecture', [], 200),
+      g('c', 'testing', [], 50),
+    ]
+    expect(buildReport(gates).elapsedMs).toBe(350)
+  })
+
+  it('preserves the gates array in the report', () => {
+    const gates = [g('a', 'correctness'), g('b', 'architecture')]
+    expect(buildReport(gates).gates).toEqual(gates)
+  })
+
+  it('computes score from findings (1 error = -10)', () => {
+    const gates = [
+      g('a', 'correctness', [f('error', 'correctness', 'a/err')]),
+    ]
+    const report = buildReport(gates)
+    expect(report.score).toBe(90)
+    expect(report.grade).toBe('A')
+  })
+})

package/src/tests/score.test.ts

@@ -0,0 +1,158 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+  computeScore,
+  gradeFor,
+  scoreCategory,
+} from '../doctor/score'
+import type { Finding, GateResult } from '../doctor/types'
+
+const makeFinding = (
+  category: Finding['category'],
+  severity: Finding['severity'],
+  code = 'test/x',
+): Finding => ({
+  category,
+  severity,
+  code,
+  gate: 'test',
+  message: 'test',
+})
+
+const makeGate = (
+  gate: string,
+  category: GateResult['category'],
+  findings: Finding[] = [],
+  skipped = false,
+): GateResult => ({
+  gate,
+  category,
+  findings,
+  meta: {
+    elapsedMs: 1,
+    ...(skipped && { skipped: true, skipReason: 'test' }),
+  },
+})
+
+describe('gradeFor', () => {
+  it('returns A for 90+', () => {
+    expect(gradeFor(100)).toBe('A')
+    expect(gradeFor(95)).toBe('A')
+    expect(gradeFor(90)).toBe('A')
+  })
+  it('returns B for 80-89', () => {
+    expect(gradeFor(89)).toBe('B')
+    expect(gradeFor(80)).toBe('B')
+  })
+  it('returns C for 70-79', () => {
+    expect(gradeFor(79)).toBe('C')
+    expect(gradeFor(70)).toBe('C')
+  })
+  it('returns D for 60-69', () => {
+    expect(gradeFor(69)).toBe('D')
+    expect(gradeFor(60)).toBe('D')
+  })
+  it('returns F for <60', () => {
+    expect(gradeFor(59)).toBe('F')
+    expect(gradeFor(0)).toBe('F')
+  })
+})
+
+describe('scoreCategory', () => {
+  it('returns 100 with grade A for empty findings', () => {
+    const result = scoreCategory('correctness', [], true)
+    expect(result.score).toBe(100)
+    expect(result.grade).toBe('A')
+    expect(result.errors).toBe(0)
+    expect(result.warnings).toBe(0)
+    expect(result.infos).toBe(0)
+  })
+
+  it('weights: 1 error = -10, 1 warning = -3, 1 info = -1', () => {
+    const findings = [
+      makeFinding('correctness', 'error'),
+      makeFinding('correctness', 'warning'),
+      makeFinding('correctness', 'info'),
+    ]
+    const result = scoreCategory('correctness', findings, true)
+    expect(result.score).toBe(86) // 100 - 10 - 3 - 1
+    expect(result.errors).toBe(1)
+    expect(result.warnings).toBe(1)
+    expect(result.infos).toBe(1)
+  })
+
+  it('saturates at 0', () => {
+    const findings = Array(20).fill(null).map(() =>
+      makeFinding('correctness', 'error'),
+    )
+    const result = scoreCategory('correctness', findings, true)
+    expect(result.score).toBe(0)
+    expect(result.grade).toBe('F')
+  })
+
+  it('only counts findings in the named category', () => {
+    const findings = [
+      makeFinding('correctness', 'error'),
+      makeFinding('performance', 'error'),
+    ]
+    const result = scoreCategory('correctness', findings, true)
+    expect(result.score).toBe(90) // -10 for the one correctness error
+  })
+
+  it('passes through `included` flag', () => {
+    expect(scoreCategory('testing', [], true).included).toBe(true)
+    expect(scoreCategory('testing', [], false).included).toBe(false)
+  })
+})
+
+describe('computeScore', () => {
+  it('returns 100/A when no gates run', () => {
+    const { score, grade } = computeScore([], [])
+    expect(score).toBe(100)
+    expect(grade).toBe('A')
+  })
+
+  it('excludes uncovered categories from the mean', () => {
+    // Only ONE gate (correctness) covers anything — should NOT
+    // average in 4× perfect 100s from uncovered categories.
+    const gates = [makeGate('lint', 'correctness')]
+    const findings = [makeFinding('correctness', 'error')]
+    const { score, categories } = computeScore(findings, gates)
+    expect(score).toBe(90) // only correctness counted, 100-10
+    expect(categories.find((c) => c.category === 'correctness')!.included).toBe(true)
+    expect(categories.find((c) => c.category === 'performance')!.included).toBe(false)
+  })
+
+  it('averages included categories', () => {
+    // 2 gates: lint (correctness, 1 error → 90) + distribution
+    // (architecture, 0 findings → 100). Mean = 95.
+    const gates = [
+      makeGate('lint', 'correctness'),
+      makeGate('distribution', 'architecture'),
+    ]
+    const findings = [makeFinding('correctness', 'error')]
+    const { score } = computeScore(findings, gates)
+    expect(score).toBe(95)
+  })
+
+  it('skipped gates do NOT include their category', () => {
+    const gates = [
+      makeGate('lint', 'correctness', [], true), // skipped
+      makeGate('distribution', 'architecture'),
+    ]
+    const { categories } = computeScore([], gates)
+    expect(categories.find((c) => c.category === 'correctness')!.included).toBe(false)
+    expect(categories.find((c) => c.category === 'architecture')!.included).toBe(true)
+  })
+
+  it('finding category alone is enough to include the category', () => {
+    // A finding emitted under 'performance' (perhaps from a lint
+    // rule whose default gate-category is 'correctness') should
+    // pull performance into the included set.
+    const gates = [makeGate('lint', 'correctness')]
+    const findings = [makeFinding('performance', 'warning')]
+    const { categories } = computeScore(findings, gates)
+    expect(categories.find((c) => c.category === 'performance')!.included).toBe(true)
+    expect(categories.find((c) => c.category === 'performance')!.score).toBe(97)
+  })
+})