@pyreon/cli 0.16.0 → 0.18.0

package/src/tests/doctor.test.ts

@@ -2,11 +2,12 @@ import * as fs from 'node:fs'
 import * as os from 'node:os'
 import * as path from 'node:path'
 
+import { describe, expect, it, vi } from 'vitest'
+
 import { type DoctorOptions, doctor } from '../doctor'
 
 function makeTmpDir(): string {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'pyreon-doctor-'))
-  return dir
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'pyreon-doctor-'))
 }
 
 function writeFile(dir: string, relPath: string, content: string): void {
@@ -15,467 +16,114 @@ function writeFile(dir: string, relPath: string, content: string): void {
   fs.writeFileSync(full, content, 'utf-8')
 }
 
-function readFile(dir: string, relPath: string): string {
-  return fs.readFileSync(path.join(dir, relPath), 'utf-8')
-}
-
-function defaultOptions(cwd: string): DoctorOptions {
+function defaults(cwd: string): DoctorOptions {
   return { fix: false, json: false, ci: false, cwd }
 }
 
-const REACT_TSX = `import { useState, useEffect } from "react"
-
-export function Counter() {
-  const [count, setCount] = useState(0)
-  useEffect(() => {
-    console.log(count)
-  }, [count])
-  return <div className="counter">{count}</div>
-}
-`
-
-const CLEAN_TSX = `import { signal } from "@pyreon/reactivity"
-
-export function Counter() {
-  const count = signal(0)
-  return <div class="counter">{count()}</div>
-}
-`
-
-describe('doctor', () => {
-  let tmpDir: string
-  let logSpy: ReturnType<typeof vi.spyOn>
-
-  beforeEach(() => {
-    tmpDir = makeTmpDir()
-    logSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
-  })
-
-  afterEach(() => {
-    logSpy.mockRestore()
-    fs.rmSync(tmpDir, { recursive: true, force: true })
-  })
-
-  // ─── detect-only mode ──────────────────────────────────────────────────
-
-  it('detects React patterns in files (no --fix)', async () => {
-    writeFile(tmpDir, 'src/App.tsx', REACT_TSX)
-
-    const errorCount = await doctor(defaultOptions(tmpDir))
-
-    expect(errorCount).toBeGreaterThan(0)
-  })
-
-  it('reports correct file paths and diagnostic counts', async () => {
-    writeFile(tmpDir, 'src/App.tsx', REACT_TSX)
-
-    const opts: DoctorOptions = { fix: false, json: true, ci: false, cwd: tmpDir }
-    await doctor(opts)
-
-    const output = logSpy.mock.calls.map((c: unknown[]) => c[0]).join('')
-    const result = JSON.parse(output)
-
-    expect(result.passed).toBe(false)
-    expect(result.files.length).toBe(1)
-    expect(result.files[0].file).toBe(path.join('src', 'App.tsx'))
-    expect(result.summary.filesWithIssues).toBe(1)
-    expect(result.summary.totalErrors).toBeGreaterThan(0)
-    // Should detect: react-import, use-state, use-effect-deps, class-name-prop
-    const codes = result.files[0].diagnostics.map((d: { code: string }) => d.code)
-    expect(codes).toContain('react-import')
-    expect(codes).toContain('use-state')
-    expect(codes).toContain('class-name-prop')
-  })
-
-  // ─── --fix mode ────────────────────────────────────────────────────────
-
-  it('--fix mode rewrites files with migrations', async () => {
-    writeFile(tmpDir, 'src/App.tsx', REACT_TSX)
-
-    const opts: DoctorOptions = { fix: true, json: false, ci: false, cwd: tmpDir }
-    await doctor(opts)
-
-    const updated = readFile(tmpDir, 'src/App.tsx')
-    // React import should be removed or rewritten
-    expect(updated).not.toContain('from "react"')
-    // useState should be migrated to signal
-    expect(updated).toContain('signal')
-    // className should be migrated to class
-    expect(updated).toContain('class=')
-  })
-
-  it('--fix mode reports totalFixed in JSON output', async () => {
-    writeFile(tmpDir, 'src/App.tsx', REACT_TSX)
-
-    const opts: DoctorOptions = { fix: true, json: true, ci: false, cwd: tmpDir }
-    await doctor(opts)
-
-    const output = logSpy.mock.calls.map((c: unknown[]) => c[0]).join('')
-    const result = JSON.parse(output)
-
-    expect(result.summary.totalFixed).toBeGreaterThan(0)
-  })
-
-  // ─── --json mode ───────────────────────────────────────────────────────
-
-  it('--json mode returns structured JSON output', async () => {
-    writeFile(tmpDir, 'src/App.tsx', REACT_TSX)
-
-    const opts: DoctorOptions = { fix: false, json: true, ci: false, cwd: tmpDir }
-    await doctor(opts)
-
-    const output = logSpy.mock.calls.map((c: unknown[]) => c[0]).join('')
-    const result = JSON.parse(output)
-
-    expect(result).toHaveProperty('passed')
-    expect(result).toHaveProperty('files')
-    expect(result).toHaveProperty('summary')
-    expect(result.summary).toHaveProperty('filesScanned')
-    expect(result.summary).toHaveProperty('filesWithIssues')
-    expect(result.summary).toHaveProperty('totalErrors')
-    expect(result.summary).toHaveProperty('totalFixable')
-    expect(result.summary).toHaveProperty('totalFixed')
-    expect(Array.isArray(result.files)).toBe(true)
-  })
-
-  // ─── --ci mode ─────────────────────────────────────────────────────────
-
-  it('--ci mode returns non-zero error count when issues found', async () => {
-    writeFile(tmpDir, 'src/App.tsx', REACT_TSX)
-
-    const opts: DoctorOptions = { fix: false, json: false, ci: true, cwd: tmpDir }
-    const errorCount = await doctor(opts)
-
-    expect(errorCount).toBeGreaterThan(0)
-  })
-
-  it('--ci mode returns 0 when no issues found', async () => {
-    writeFile(tmpDir, 'src/App.tsx', CLEAN_TSX)
-
-    const opts: DoctorOptions = { fix: false, json: false, ci: true, cwd: tmpDir }
-    const errorCount = await doctor(opts)
-
-    expect(errorCount).toBe(0)
-  })
-
-  // ─── skipping ──────────────────────────────────────────────────────────
-
-  it('skips node_modules and non-source files', async () => {
-    writeFile(tmpDir, 'node_modules/some-pkg/index.tsx', REACT_TSX)
-    writeFile(tmpDir, 'dist/bundle.tsx', REACT_TSX)
-    writeFile(tmpDir, 'assets/readme.md', '# className something useState')
-    writeFile(tmpDir, 'src/App.tsx', CLEAN_TSX)
-
-    const opts: DoctorOptions = { fix: false, json: true, ci: false, cwd: tmpDir }
-    await doctor(opts)
-
-    const output = logSpy.mock.calls.map((c: unknown[]) => c[0]).join('')
-    const result = JSON.parse(output)
-
-    expect(result.passed).toBe(true)
-    expect(result.summary.filesWithIssues).toBe(0)
-    // Only the clean .tsx in src/ should be scanned
-    expect(result.summary.filesScanned).toBe(1)
-  })
-
-  // ─── clean project ─────────────────────────────────────────────────────
-
-  it('clean project returns no issues', async () => {
-    writeFile(tmpDir, 'src/App.tsx', CLEAN_TSX)
-
-    const errorCount = await doctor(defaultOptions(tmpDir))
-
-    expect(errorCount).toBe(0)
-  })
-
-  it('clean project prints success message in human mode', async () => {
-    writeFile(tmpDir, 'src/App.tsx', CLEAN_TSX)
-
-    await doctor(defaultOptions(tmpDir))
-
-    const output = logSpy.mock.calls.map((c: unknown[]) => c[0]).join('\n')
-    expect(output).toContain('No issues found')
-  })
-
-  // ─── hasReactPatterns pre-filter ────────────────────────────────────────
-
-  it('hasReactPatterns pre-filter skips non-React files efficiently', async () => {
-    // A file with Pyreon-only code should not produce diagnostics
-    const pyreonOnly = `import { signal, computed, effect } from "@pyreon/reactivity"
-import { onMount } from "@pyreon/core"
-
-export function App() {
-  const count = signal(0)
-  const doubled = computed(() => count() * 2)
-  effect(() => console.log(doubled()))
-  onMount(() => { console.log("mounted") })
-  return <div class="app">{count()}</div>
-}
-`
-    writeFile(tmpDir, 'src/App.tsx', pyreonOnly)
-
-    const opts: DoctorOptions = { fix: false, json: true, ci: false, cwd: tmpDir }
-    await doctor(opts)
-
-    const output = logSpy.mock.calls.map((c: unknown[]) => c[0]).join('')
-    const result = JSON.parse(output)
-
-    expect(result.passed).toBe(true)
-    expect(result.summary.totalErrors).toBe(0)
-  })
-
-  // ─── empty directory ────────────────────────────────────────────────────
-
-  it('handles empty directory with no source files', async () => {
-    const errorCount = await doctor(defaultOptions(tmpDir))
-
-    expect(errorCount).toBe(0)
-  })
-
-  // ─── multiple files ─────────────────────────────────────────────────────
-
-  it('scans multiple files and aggregates results', async () => {
-    writeFile(tmpDir, 'src/A.tsx', REACT_TSX)
-    writeFile(
-      tmpDir,
-      'src/B.tsx',
-      `import { useState } from "react"
-export function B() { const [x, setX] = useState(0); return <div>{x}</div> }
-`,
-    )
-    writeFile(tmpDir, 'src/C.tsx', CLEAN_TSX)
-
-    const opts: DoctorOptions = { fix: false, json: true, ci: false, cwd: tmpDir }
-    await doctor(opts)
-
-    const output = logSpy.mock.calls.map((c: unknown[]) => c[0]).join('')
-    const result = JSON.parse(output)
-
-    expect(result.summary.filesScanned).toBe(3)
-    expect(result.summary.filesWithIssues).toBe(2)
-  })
-})
-
-describe('doctor — --audit-tests integration', () => {
-  let logSpy: ReturnType<typeof vi.spyOn>
-  let tmpDir: string
-
-  beforeEach(() => {
-    logSpy = vi.spyOn(console, 'log').mockImplementation(() => undefined)
-    tmpDir = makeTmpDir()
-    fs.mkdirSync(path.join(tmpDir, 'packages'), { recursive: true })
-  })
-  afterEach(() => {
-    logSpy.mockRestore()
-    fs.rmSync(tmpDir, { recursive: true, force: true })
-  })
-
-  it('does NOT print audit output when --audit-tests is absent (default)', async () => {
-    writeFile(
-      tmpDir,
-      'packages/x/src/tests/mock.test.ts',
-      `const vnode = { type: 'div', props: {}, children: [] }`,
-    )
-    const opts: DoctorOptions = {
-      fix: false,
-      json: false,
-      ci: false,
-      cwd: tmpDir,
-      auditTests: false,
-    }
-    await doctor(opts)
-    const output = logSpy.mock.calls.map((c: unknown[]) => c.join(' ')).join('\n')
-    expect(output).not.toContain('Test environment audit')
-  })
-
-  it('prints the test-audit report when --audit-tests is passed', async () => {
-    writeFile(
-      tmpDir,
-      'packages/x/src/tests/mock.test.ts',
-      `const vnode = { type: 'div', props: {}, children: [] }`,
-    )
-    const opts: DoctorOptions = {
-      fix: false,
-      json: false,
-      ci: false,
-      cwd: tmpDir,
-      auditTests: true,
-    }
-    await doctor(opts)
-    const output = logSpy.mock.calls.map((c: unknown[]) => c.join(' ')).join('\n')
-    expect(output).toContain('Test environment audit')
-    expect(output).toContain('Mock-vnode exposure')
-    // The HIGH file we wrote surfaces at the default minRisk=medium.
-    expect(output).toContain('mock.test.ts')
-  })
-
-  it('emits machine-readable JSON when --json + --audit-tests both set', async () => {
-    writeFile(
-      tmpDir,
-      'packages/x/src/tests/mock.test.ts',
-      `const vnode = { type: 'div', props: {}, children: [] }`,
-    )
-    const opts: DoctorOptions = {
-      fix: false,
+describe('doctor() end-to-end', () => {
+  // Use `--only react-patterns` for the empty-dir tests — most other
+  // gates walk up the dir tree looking for `packages/` (audit-tests)
+  // or read the real repo root for known files (doc-claims). Pinning
+  // to `react-patterns` isolates the test to the actual tmp dir.
+
+  it('runs against an empty dir and prints a clean banner', async () => {
+    const cwd = makeTmpDir()
+    const log = vi.spyOn(console, 'log').mockImplementation(() => {})
+    const exitCode = await doctor({
+      ...defaults(cwd),
+      only: ['react-patterns'],
+    })
+    const out = log.mock.calls.map((c) => c[0]).join('\n')
+    log.mockRestore()
+    fs.rmSync(cwd, { recursive: true, force: true })
+
+    expect(out).toContain('pyreon doctor')
+    expect(out).toContain('Score:')
+    expect(exitCode).toBe(0)
+  })
+
+  it('--json emits a DoctorReport object', async () => {
+    const cwd = makeTmpDir()
+    const log = vi.spyOn(console, 'log').mockImplementation(() => {})
+    await doctor({
+      ...defaults(cwd),
       json: true,
-      ci: false,
-      cwd: tmpDir,
-      auditTests: true,
-    }
-    await doctor(opts)
-    // Two JSON blobs logged separately — doctor result then the audit.
-    const blobs = logSpy.mock.calls
-      .map((c: unknown[]) => String(c[0] ?? ''))
-      .filter((s: string) => s.trim().startsWith('{'))
-    expect(blobs.length).toBeGreaterThanOrEqual(2)
-    const auditBlob = blobs.find((s: string) => s.includes('testAudit'))
-    expect(auditBlob).toBeDefined()
-    const parsed = JSON.parse(auditBlob!) as { testAudit: { entries: unknown[] } }
-    expect(Array.isArray(parsed.testAudit.entries)).toBe(true)
-  })
-
-  it('honours --audit-min-risk=high — surfaces only HIGH files', async () => {
-    writeFile(
-      tmpDir,
-      'packages/x/src/tests/mock.test.ts',
-      `const vnode = { type: 'div', props: {}, children: [] }`,
-    )
-    const opts: DoctorOptions = {
-      fix: false,
-      json: false,
-      ci: false,
-      cwd: tmpDir,
-      auditTests: true,
-      auditMinRisk: 'high',
-    }
-    await doctor(opts)
-    const output = logSpy.mock.calls.map((c: unknown[]) => c.join(' ')).join('\n')
-    expect(output).toContain('## HIGH')
-    expect(output).not.toMatch(/^## MEDIUM/m)
-  })
-})
-
-// ─── --check-islands integration (PR C) ─────────────────────────────────────
-
-describe('doctor — --check-islands integration', () => {
-  let logSpy: ReturnType<typeof vi.spyOn>
-  let tmpDir: string
-
-  beforeEach(() => {
-    logSpy = vi.spyOn(console, 'log').mockImplementation(() => undefined)
-    tmpDir = makeTmpDir()
-    fs.mkdirSync(path.join(tmpDir, 'packages'), { recursive: true })
-  })
-  afterEach(() => {
-    logSpy.mockRestore()
-    fs.rmSync(tmpDir, { recursive: true, force: true })
-  })
-
-  it('does NOT print islands audit output when --check-islands is absent (default)', async () => {
-    writeFile(
-      tmpDir,
-      'packages/x/src/Counter.tsx',
-      `import { island } from '@pyreon/server'
-       export const Counter = island(() => import('./Inner'), { name: 'Counter', hydrate: 'load' })`,
-    )
-    const opts: DoctorOptions = {
-      fix: false,
-      json: false,
-      ci: false,
-      cwd: tmpDir,
-      checkIslands: false,
-    }
-    await doctor(opts)
-    const output = logSpy.mock.calls.map((c: unknown[]) => c.join(' ')).join('\n')
-    expect(output).not.toContain('Islands audit')
-  })
-
-  it('prints the islands audit when --check-islands is passed', async () => {
-    writeFile(
-      tmpDir,
-      'packages/x/src/A.tsx',
-      `import { island } from '@pyreon/server'
-       export const A = island(() => import('./AInner'), { name: 'Dup', hydrate: 'load' })`,
-    )
-    writeFile(
-      tmpDir,
-      'packages/y/src/B.tsx',
-      `import { island } from '@pyreon/server'
-       export const B = island(() => import('./BInner'), { name: 'Dup', hydrate: 'load' })`,
-    )
-    writeFile(tmpDir, 'packages/x/src/AInner.tsx', `export default () => null`)
-    writeFile(tmpDir, 'packages/y/src/BInner.tsx', `export default () => null`)
-    const opts: DoctorOptions = {
-      fix: false,
-      json: false,
-      ci: false,
-      cwd: tmpDir,
-      checkIslands: true,
-    }
-    await doctor(opts)
-    const output = logSpy.mock.calls.map((c: unknown[]) => c.join(' ')).join('\n')
-    expect(output).toContain('Islands audit')
-    expect(output).toContain('## duplicate-name')
-    // Both file locations appear in the human-readable section
-    expect(output).toContain('A.tsx')
-    expect(output).toContain('B.tsx')
-  })
-
-  it('emits machine-readable JSON when --json + --check-islands both set', async () => {
+      only: ['react-patterns'],
+    })
+    const out = log.mock.calls.map((c) => c[0]).join('')
+    log.mockRestore()
+    fs.rmSync(cwd, { recursive: true, force: true })
+
+    const parsed = JSON.parse(out)
+    expect(parsed.score).toBeTypeOf('number')
+    expect(parsed.grade).toMatch(/^[A-F]$/)
+    expect(Array.isArray(parsed.findings)).toBe(true)
+    expect(Array.isArray(parsed.gates)).toBe(true)
+  })
+
+  it('--ci returns 0 when no error findings', async () => {
+    const cwd = makeTmpDir()
+    const log = vi.spyOn(console, 'log').mockImplementation(() => {})
+    const exitCode = await doctor({
+      ...defaults(cwd),
+      ci: true,
+      only: ['react-patterns'],
+    })
+    log.mockRestore()
+    fs.rmSync(cwd, { recursive: true, force: true })
+    expect(exitCode).toBe(0)
+  })
+
+  it('flags React patterns when detected', async () => {
+    const cwd = makeTmpDir()
     writeFile(
-      tmpDir,
-      'packages/x/src/Orphan.tsx',
-      `import { island } from '@pyreon/server'
-       export const Orphan = island(() => import('./Inner'), { name: 'Orphan', hydrate: 'load' })`,
+      cwd,
+      'src/App.tsx',
+      `import { useState } from "react"\nexport function X() { const [c, setC] = useState(0); return <div className="x">{c}</div> }\n`,
     )
-    writeFile(tmpDir, 'packages/x/src/Inner.tsx', `export default () => null`)
-    const opts: DoctorOptions = {
-      fix: false,
+    const log = vi.spyOn(console, 'log').mockImplementation(() => {})
+    await doctor({ ...defaults(cwd), json: true, only: ['react-patterns'] })
+    const out = log.mock.calls.map((c) => c[0]).join('')
+    log.mockRestore()
+    fs.rmSync(cwd, { recursive: true, force: true })
+
+    const parsed = JSON.parse(out)
+    expect(parsed.findings.length).toBeGreaterThan(0)
+    const codes = parsed.findings.map((f: { code: string }) => f.code)
+    expect(codes.some((c: string) => c.startsWith('react-patterns/'))).toBe(true)
+  })
+
+  it('legacy --audit-tests maps to --only audit-tests', async () => {
+    const cwd = makeTmpDir()
+    const log = vi.spyOn(console, 'log').mockImplementation(() => {})
+    await doctor({
+      ...defaults(cwd),
       json: true,
-      ci: false,
-      cwd: tmpDir,
-      checkIslands: true,
-    }
-    await doctor(opts)
-    // Two JSON blobs logged separately — doctor result then the audit.
-    const blobs = logSpy.mock.calls
-      .map((c: unknown[]) => String(c[0] ?? ''))
-      .filter((s: string) => s.trim().startsWith('{'))
-    expect(blobs.length).toBeGreaterThanOrEqual(2)
-    const auditBlob = blobs.find((s: string) => s.includes('islandAudit'))
-    expect(auditBlob).toBeDefined()
-    const parsed = JSON.parse(auditBlob!) as {
-      islandAudit: { findings: Array<{ code: string }>; summary: { islandsDeclared: number } }
-    }
-    expect(parsed.islandAudit.summary.islandsDeclared).toBe(1)
-    // The orphan declaration should produce exactly one dead-island finding.
-    const codes = parsed.islandAudit.findings.map((f) => f.code)
-    expect(codes).toContain('dead-island')
-  })
-
-  it('emits a clean green-light section when no findings are present', async () => {
-    writeFile(
-      tmpDir,
-      'packages/x/src/Counter.tsx',
-      `import { island } from '@pyreon/server'
-       export const Counter = island(() => import('./Inner'), { name: 'Counter', hydrate: 'load' })`,
-    )
-    writeFile(tmpDir, 'packages/x/src/Inner.tsx', `export default () => null`)
-    writeFile(
-      tmpDir,
-      'packages/x/src/index.ts',
-      `export { Counter } from './Counter'`,
-    )
-    const opts: DoctorOptions = {
-      fix: false,
-      json: false,
-      ci: false,
-      cwd: tmpDir,
-      checkIslands: true,
-    }
-    await doctor(opts)
-    const output = logSpy.mock.calls.map((c: unknown[]) => c.join(' ')).join('\n')
-    expect(output).toContain('Islands audit')
-    expect(output).toContain('No island findings')
+      auditTests: true,
+    })
+    const out = log.mock.calls.map((c) => c[0]).join('')
+    log.mockRestore()
+    fs.rmSync(cwd, { recursive: true, force: true })
+
+    const parsed = JSON.parse(out)
+    const ranGates = parsed.gates
+      .filter((g: { meta: { skipped?: boolean } }) => !g.meta.skipped)
+      .map((g: { gate: string }) => g.gate)
+    expect(ranGates).toEqual(['audit-tests'])
+  })
+
+  it('respects --format=gha for GitHub Actions output', async () => {
+    const cwd = makeTmpDir()
+    const log = vi.spyOn(console, 'log').mockImplementation(() => {})
+    await doctor({
+      ...defaults(cwd),
+      format: 'gha',
+      only: ['react-patterns'],
+    })
+    const out = log.mock.calls.map((c) => c[0]).join('\n')
+    log.mockRestore()
+    fs.rmSync(cwd, { recursive: true, force: true })
+
+    expect(out).toContain('::notice::pyreon doctor score:')
   })
 })