@vibecodeqa/cli 0.9.0

package/dist/runners/testing.js

@@ -0,0 +1,401 @@
+/** Comprehensive testing assessment — pyramid layers, quality, coverage.
+ *
+ * Dimensions assessed:
+ *   1. Pyramid presence — which layers exist? (unit, integration, e2e, component)
+ *   2. Test execution — pass/fail from the runner
+ *   3. Coverage — statement, branch, function, line
+ *   4. File pairing — does each source file have a test file?
+ *   5. Test quality — naming, assertions, mocking patterns, snapshot smell
+ *   6. Pyramid balance — right ratio of fast-to-slow tests
+ */
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { basename, extname, join } from "node:path";
+import { gradeFromScore } from "../types.js";
+import { run } from "./exec.js";
+// ── Classification rules ──
+function classifyTestFile(relPath, content) {
+    const lower = relPath.toLowerCase();
+    // E2E — explicit directory or file naming
+    if (lower.includes("/e2e/") || lower.includes(".e2e.") || lower.includes("/playwright/") || lower.includes(".pw."))
+        return "e2e";
+    if (/\b(page|browser|navigate|goto|click|fill|expect\(page)\b/.test(content) && /playwright|puppeteer|cypress/.test(content))
+        return "e2e";
+    // Integration — explicit naming or real API/DB calls
+    if (lower.includes("integration") || lower.includes(".int."))
+        return "integration";
+    if (/\bfetch\(["']https?:/.test(content) && !/mock|stub|spy|vi\.fn|jest\.fn/.test(content))
+        return "integration";
+    if (/\bglobalSetup\b/.test(content))
+        return "integration";
+    // Component — React component tests (render, screen, fireEvent)
+    if (/\b(render|screen|fireEvent|userEvent|@testing-library)\b/.test(content))
+        return "component";
+    if (lower.includes(".component."))
+        return "component";
+    // Default: unit
+    return "unit";
+}
+function countPatterns(content) {
+    const assertions = (content.match(/\bexpect\s*\(/g) || []).length + (content.match(/\bassert[\.(]/g) || []).length;
+    const mocks = (content.match(/\b(vi\.fn|jest\.fn|vi\.mock|jest\.mock|vi\.spyOn|jest\.spyOn|sinon\.(stub|spy|mock)|\.mockResolvedValue|\.mockReturnValue|\.mockImplementation)\b/g) || []).length;
+    const snapshots = (content.match(/\btoMatchSnapshot|toMatchInlineSnapshot\b/g) || []).length;
+    const describes = (content.match(/\bdescribe\s*\(/g) || []).length;
+    const its = (content.match(/\b(it|test)\s*\(/g) || []).length;
+    return { assertions, mocks, snapshots, describes, its };
+}
+// ── File discovery ──
+function findTestFiles(cwd) {
+    const files = [];
+    const dirs = ["src", "web/src", "test", "tests", "__tests__", "e2e", "playwright"];
+    for (const dir of dirs) {
+        const full = join(cwd, dir);
+        if (existsSync(full))
+            walkTests(full, cwd, files);
+    }
+    // Also check root for standalone test configs (e.g. playwright.config.ts)
+    return files;
+}
+function walkTests(dir, cwd, out) {
+    for (const entry of readdirSync(dir)) {
+        if (entry === "node_modules" || entry === "dist" || entry === ".git")
+            continue;
+        const full = join(dir, entry);
+        if (statSync(full).isDirectory()) {
+            walkTests(full, cwd, out);
+            continue;
+        }
+        const ext = extname(entry);
+        if (![".ts", ".tsx", ".js", ".jsx"].includes(ext))
+            continue;
+        if (!entry.includes(".test.") && !entry.includes(".spec.") && !entry.includes(".e2e.") && !entry.includes(".int.") && !dir.includes("__tests__") && !dir.includes("/e2e") && !dir.includes("/test"))
+            continue;
+        const content = readFileSync(full, "utf-8");
+        const relPath = full.replace(cwd + "/", "");
+        const layer = classifyTestFile(relPath, content);
+        const patterns = countPatterns(content);
+        out.push({
+            path: relPath,
+            layer,
+            lines: content.split("\n").length,
+            ...patterns,
+        });
+    }
+}
+function findSourceFiles(cwd) {
+    const files = [];
+    const dirs = ["src", "web/src"];
+    for (const dir of dirs) {
+        try {
+            walkSource(join(cwd, dir), cwd, files);
+        }
+        catch { /* dir doesn't exist */ }
+    }
+    return files;
+}
+function walkSource(dir, cwd, out) {
+    for (const entry of readdirSync(dir)) {
+        if (entry === "node_modules" || entry === "dist")
+            continue;
+        const full = join(dir, entry);
+        if (statSync(full).isDirectory()) {
+            walkSource(full, cwd, out);
+        }
+        else {
+            const ext = extname(entry);
+            if ([".ts", ".tsx", ".js", ".jsx"].includes(ext) && !entry.includes(".test.") && !entry.includes(".spec.")) {
+                out.push(full.replace(cwd + "/", ""));
+            }
+        }
+    }
+}
+// ── Pairing analysis ──
+function computePairing(srcFiles, testFiles) {
+    const testBases = new Set(testFiles.map((t) => {
+        const b = basename(t.path);
+        return b.replace(/\.(test|spec|e2e|int)\.(ts|tsx|js|jsx)$/, "");
+    }));
+    const unpaired = [];
+    let paired = 0;
+    for (const src of srcFiles) {
+        const b = basename(src).replace(/\.(ts|tsx|js|jsx)$/, "");
+        // Skip files that conventionally don't need tests
+        if (["index", "main", "types", "constants", "config"].includes(b))
+            continue;
+        if (testBases.has(b)) {
+            paired++;
+        }
+        else {
+            unpaired.push(src);
+        }
+    }
+    return { paired, unpaired };
+}
+// ── E2E tool detection ──
+function detectE2E(cwd) {
+    const allDeps = readDeps(cwd);
+    if (allDeps["@playwright/test"] || allDeps.playwright) {
+        const hasConfig = existsSync(join(cwd, "playwright.config.ts")) || existsSync(join(cwd, "playwright.config.js"));
+        return { tool: "playwright", configured: hasConfig };
+    }
+    if (allDeps.cypress) {
+        const hasConfig = existsSync(join(cwd, "cypress.config.ts")) || existsSync(join(cwd, "cypress.config.js")) || existsSync(join(cwd, "cypress.json"));
+        return { tool: "cypress", configured: hasConfig };
+    }
+    return { tool: "none", configured: false };
+}
+function readDeps(cwd) {
+    try {
+        const pkg = JSON.parse(readFileSync(join(cwd, "package.json"), "utf-8"));
+        return { ...pkg.dependencies, ...pkg.devDependencies };
+    }
+    catch {
+        return {};
+    }
+}
+// ── Coverage collection ──
+function collectCoverage(cwd, stack) {
+    if (stack.testRunner === "none")
+        return null;
+    const cmd = stack.testRunner === "vitest"
+        ? "npx vitest run --coverage 2>/dev/null || true"
+        : "npx jest --coverage --coverageReporters=json-summary 2>/dev/null || true";
+    run(cmd, cwd, 120_000);
+    const searchPaths = ["coverage/coverage-summary.json", "test-results/coverage/coverage-summary.json"];
+    for (const p of searchPaths) {
+        const full = join(cwd, p);
+        if (existsSync(full)) {
+            try {
+                const summary = JSON.parse(readFileSync(full, "utf-8"));
+                if (summary?.total) {
+                    return {
+                        statements: summary.total.statements?.pct || 0,
+                        lines: summary.total.lines?.pct || 0,
+                        branches: summary.total.branches?.pct || 0,
+                        functions: summary.total.functions?.pct || 0,
+                    };
+                }
+            }
+            catch { /* parse failed */ }
+        }
+    }
+    return null;
+}
+// ── Test execution ──
+function executeTests(cwd, stack) {
+    if (stack.testRunner === "none")
+        return null;
+    const cmd = stack.testRunner === "vitest"
+        ? "npx vitest run --reporter=json 2>/dev/null || true"
+        : "npx jest --json 2>/dev/null || true";
+    const { stdout } = run(cmd, cwd, 120_000);
+    try {
+        const jsonStart = stdout.indexOf("{");
+        if (jsonStart >= 0) {
+            const data = JSON.parse(stdout.slice(jsonStart));
+            return {
+                passed: data.numPassedTests || 0,
+                failed: data.numFailedTests || 0,
+                total: data.numTotalTests || 0,
+            };
+        }
+    }
+    catch { /* parse failed */ }
+    return null;
+}
+function analyzeQuality(testFiles) {
+    let totalAssertions = 0;
+    let totalMocks = 0;
+    let totalSnapshots = 0;
+    let totalIts = 0;
+    let testsWithNoAssertions = 0;
+    for (const f of testFiles) {
+        totalAssertions += f.assertions;
+        totalMocks += f.mocks;
+        totalSnapshots += f.snapshots;
+        totalIts += f.its;
+        if (f.assertions === 0 && f.its > 0)
+            testsWithNoAssertions += f.its;
+    }
+    return {
+        avgAssertionsPerTest: totalIts > 0 ? Math.round((totalAssertions / totalIts) * 10) / 10 : 0,
+        testsWithNoAssertions,
+        mockRatio: totalAssertions > 0 ? Math.round((totalMocks / totalAssertions) * 100) / 100 : 0,
+        snapshotRatio: totalAssertions > 0 ? Math.round((totalSnapshots / totalAssertions) * 100) / 100 : 0,
+        emptyDescribes: 0, // TODO: detect empty describe blocks
+        wellNamedTests: totalIts, // simplified for v0.2
+        totalTests: totalIts,
+    };
+}
+// ── Main runner ──
+export function runTesting(cwd, stack, skipExec) {
+    const start = Date.now();
+    const issues = [];
+    // 1. Discover test files and classify by layer
+    const testFiles = findTestFiles(cwd);
+    const srcFiles = findSourceFiles(cwd);
+    if (testFiles.length === 0) {
+        return {
+            name: "testing",
+            score: 0,
+            grade: "F",
+            details: {
+                reason: "No test files found",
+                srcFiles: srcFiles.length,
+                testFiles: 0,
+                pyramid: { unit: 0, integration: 0, component: 0, e2e: 0 },
+            },
+            issues: [{ severity: "error", message: `${srcFiles.length} source files with zero tests`, rule: "no-tests" }],
+            duration: Date.now() - start,
+        };
+    }
+    // 2. Pyramid layer analysis
+    const layers = { unit: [], integration: [], component: [], e2e: [] };
+    for (const f of testFiles)
+        layers[f.layer].push(f);
+    const pyramid = {
+        unit: { present: layers.unit.length > 0, files: layers.unit.length, assertions: layers.unit.reduce((s, f) => s + f.assertions, 0), score: 0 },
+        integration: { present: layers.integration.length > 0, files: layers.integration.length, assertions: layers.integration.reduce((s, f) => s + f.assertions, 0), score: 0 },
+        component: { present: layers.component.length > 0, files: layers.component.length, assertions: layers.component.reduce((s, f) => s + f.assertions, 0), score: 0 },
+        e2e: { present: layers.e2e.length > 0, files: layers.e2e.length, assertions: layers.e2e.reduce((s, f) => s + f.assertions, 0), score: 0 },
+    };
+    // 3. E2E tool detection
+    const e2eTool = detectE2E(cwd);
+    const needsE2E = stack.framework !== "none"; // frontends should have E2E
+    const needsComponent = stack.framework === "react" || stack.framework === "vue" || stack.framework === "svelte";
+    // 4. Penalize missing layers based on what the stack needs
+    if (!pyramid.unit.present) {
+        issues.push({ severity: "error", message: "No unit tests found — every project needs unit tests", rule: "no-unit-tests" });
+    }
+    if (!pyramid.integration.present && srcFiles.length > 5) {
+        issues.push({ severity: "warning", message: "No integration tests — consider testing service boundaries", rule: "no-integration-tests" });
+    }
+    if (needsComponent && !pyramid.component.present) {
+        issues.push({ severity: "warning", message: `${stack.framework} project with no component tests — test your UI components`, rule: "no-component-tests" });
+    }
+    if (needsE2E && !pyramid.e2e.present) {
+        if (e2eTool.tool === "none") {
+            issues.push({ severity: "warning", message: "No E2E test framework (Playwright/Cypress) — critical user flows untested", rule: "no-e2e-framework" });
+        }
+        else if (!e2eTool.configured) {
+            issues.push({ severity: "info", message: `${e2eTool.tool} installed but not configured`, rule: "e2e-not-configured" });
+        }
+        else {
+            issues.push({ severity: "info", message: `${e2eTool.tool} configured but no E2E test files found`, rule: "e2e-no-tests" });
+        }
+    }
+    // 5. File pairing analysis
+    const pairing = computePairing(srcFiles, testFiles);
+    const pairingPct = srcFiles.length > 0 ? Math.round(((pairing.paired) / Math.max(1, srcFiles.length - countUntestable(srcFiles))) * 100) : 100;
+    if (pairingPct < 30) {
+        issues.push({ severity: "warning", message: `Only ${pairingPct}% of source files have matching test files`, rule: "low-test-pairing" });
+    }
+    // Report up to 5 unpaired files
+    for (const f of pairing.unpaired.slice(0, 5)) {
+        issues.push({ severity: "info", message: `No test file for ${f}`, file: f, rule: "untested-file" });
+    }
+    if (pairing.unpaired.length > 5) {
+        issues.push({ severity: "info", message: `...and ${pairing.unpaired.length - 5} more untested files`, rule: "untested-file" });
+    }
+    // 6. Test quality analysis
+    const quality = analyzeQuality(testFiles);
+    if (quality.avgAssertionsPerTest < 1) {
+        issues.push({ severity: "warning", message: `Low assertion density: ${quality.avgAssertionsPerTest} assertions/test (aim for 2+)`, rule: "low-assertions" });
+    }
+    if (quality.mockRatio > 0.5) {
+        issues.push({ severity: "warning", message: `High mock ratio: ${quality.mockRatio} mocks per assertion — tests may not reflect real behavior`, rule: "over-mocked" });
+    }
+    if (quality.snapshotRatio > 0.3) {
+        issues.push({ severity: "warning", message: `${Math.round(quality.snapshotRatio * 100)}% of assertions are snapshots — brittle, prefer explicit assertions`, rule: "snapshot-heavy" });
+    }
+    // 7. Execute tests + collect coverage (unless --skip-tests)
+    let execution = null;
+    let coverage = null;
+    if (!skipExec) {
+        // Run with coverage to get both results in one pass
+        coverage = collectCoverage(cwd, stack);
+        execution = executeTests(cwd, stack);
+        if (execution) {
+            if (execution.failed > 0) {
+                issues.push({ severity: "error", message: `${execution.failed} of ${execution.total} tests failing`, rule: "failing-tests" });
+            }
+        }
+        if (coverage) {
+            if (coverage.branches < 50) {
+                issues.push({ severity: "warning", message: `Branch coverage ${coverage.branches}% — below 50% threshold`, rule: "low-branch-coverage" });
+            }
+            if (coverage.statements < 60) {
+                issues.push({ severity: "warning", message: `Statement coverage ${coverage.statements}% — below 60% threshold`, rule: "low-statement-coverage" });
+            }
+        }
+    }
+    // 8. Compute composite score
+    let score = 0;
+    // Pyramid presence (30 points)
+    const layerCount = [pyramid.unit.present, pyramid.integration.present, pyramid.component.present && needsComponent, pyramid.e2e.present && needsE2E].filter(Boolean).length;
+    const expectedLayers = 1 + (srcFiles.length > 5 ? 1 : 0) + (needsComponent ? 1 : 0) + (needsE2E ? 1 : 0);
+    const pyramidScore = expectedLayers > 0 ? Math.round((layerCount / expectedLayers) * 30) : 30;
+    score += pyramidScore;
+    // Execution (20 points)
+    if (execution) {
+        const passRate = execution.total > 0 ? execution.passed / execution.total : 0;
+        score += Math.round(passRate * 20);
+    }
+    else if (!skipExec) {
+        // Couldn't run tests
+    }
+    else {
+        score += 10; // partial credit when skipped
+    }
+    // Coverage (20 points)
+    if (coverage) {
+        const avgCov = (coverage.statements + coverage.branches + coverage.lines + coverage.functions) / 4;
+        score += Math.round((avgCov / 100) * 20);
+    }
+    // Pairing (15 points)
+    score += Math.round((pairingPct / 100) * 15);
+    // Quality (15 points)
+    let qualityScore = 15;
+    if (quality.avgAssertionsPerTest < 1)
+        qualityScore -= 5;
+    if (quality.mockRatio > 0.5)
+        qualityScore -= 3;
+    if (quality.snapshotRatio > 0.3)
+        qualityScore -= 3;
+    if (quality.testsWithNoAssertions > 0)
+        qualityScore -= 2;
+    score += Math.max(0, qualityScore);
+    score = Math.max(0, Math.min(100, score));
+    return {
+        name: "testing",
+        score,
+        grade: gradeFromScore(score),
+        details: {
+            pyramid: {
+                unit: pyramid.unit.files,
+                integration: pyramid.integration.files,
+                component: pyramid.component.files,
+                e2e: pyramid.e2e.files,
+            },
+            layersPresent: layerCount + "/" + expectedLayers,
+            e2eTool: e2eTool.tool,
+            testFiles: testFiles.length,
+            srcFiles: srcFiles.length,
+            pairing: pairingPct + "%",
+            quality: {
+                assertionsPerTest: quality.avgAssertionsPerTest,
+                mockRatio: quality.mockRatio,
+                snapshotRatio: quality.snapshotRatio,
+            },
+            ...(execution ? { passed: execution.passed, failed: execution.failed, total: execution.total } : {}),
+            ...(coverage ? { coverage: { stmts: coverage.statements, branches: coverage.branches, lines: coverage.lines, fns: coverage.functions } } : {}),
+        },
+        issues,
+        duration: Date.now() - start,
+    };
+}
+function countUntestable(srcFiles) {
+    return srcFiles.filter((f) => {
+        const b = basename(f).replace(/\.(ts|tsx|js|jsx)$/, "");
+        return ["index", "main", "types", "constants", "config"].includes(b);
+    }).length;
+}

package/dist/runners/tests.d.ts

@@ -0,0 +1,3 @@
+/** Test runner — auto-detects vitest or jest. */
+import type { CheckResult, StackInfo } from "../types.js";
+export declare function runTests(cwd: string, stack: StackInfo): CheckResult;

package/dist/runners/tests.js

@@ -0,0 +1,54 @@
+/** Test runner — auto-detects vitest or jest. */
+import { gradeFromScore } from "../types.js";
+import { run } from "./exec.js";
+export function runTests(cwd, stack) {
+    const start = Date.now();
+    if (stack.testRunner === "none") {
+        return {
+            name: "tests",
+            score: 0,
+            grade: "F",
+            details: { skipped: true, reason: "no test runner" },
+            issues: [],
+            duration: Date.now() - start,
+        };
+    }
+    const cmd = stack.testRunner === "vitest"
+        ? "npx vitest run --reporter=json 2>/dev/null || true"
+        : "npx jest --json 2>/dev/null || true";
+    const { stdout } = run(cmd, cwd, 120_000);
+    // Extract JSON from output (vitest may print other stuff before the JSON)
+    let data = null;
+    try {
+        // Find the JSON object in stdout
+        const jsonStart = stdout.indexOf("{");
+        if (jsonStart >= 0) {
+            data = JSON.parse(stdout.slice(jsonStart));
+        }
+    }
+    catch {
+        /* parse failed */
+    }
+    if (!data) {
+        return {
+            name: "tests",
+            score: 0,
+            grade: "F",
+            details: { error: "could not parse test output" },
+            issues: [],
+            duration: Date.now() - start,
+        };
+    }
+    const passed = data.numPassedTests || 0;
+    const failed = data.numFailedTests || 0;
+    const total = data.numTotalTests || 0;
+    const score = total === 0 ? 0 : Math.round((passed / total) * 100);
+    return {
+        name: "tests",
+        score,
+        grade: gradeFromScore(score),
+        details: { passed, failed, total, runner: stack.testRunner },
+        issues: [],
+        duration: Date.now() - start,
+    };
+}

package/dist/runners/type-safety.d.ts

@@ -0,0 +1,3 @@
+/** Type safety check — count unsafe patterns: `as any`, explicit `any`, non-null assertions. */
+import type { CheckResult } from "../types.js";
+export declare function runTypeSafety(cwd: string): CheckResult;

package/dist/runners/type-safety.js

@@ -0,0 +1,74 @@
+/** Type safety check — count unsafe patterns: `as any`, explicit `any`, non-null assertions. */
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { extname, join } from "node:path";
+import { gradeFromScore } from "../types.js";
+const PATTERNS = [
+    { name: "as any", pattern: /\bas any\b/g, severity: "warning", weight: 2 },
+    { name: ": any", pattern: /:\s*any\b/g, severity: "warning", weight: 1 },
+    { name: "non-null assertion (!.)", pattern: /\w+!\./g, severity: "info", weight: 0.5 },
+    { name: "@ts-ignore", pattern: /@ts-ignore/g, severity: "error", weight: 5 },
+    { name: "@ts-expect-error", pattern: /@ts-expect-error/g, severity: "warning", weight: 2 },
+    { name: "@ts-nocheck", pattern: /@ts-nocheck/g, severity: "error", weight: 10 },
+];
+export function runTypeSafety(cwd) {
+    const start = Date.now();
+    const issues = [];
+    const counts = {};
+    let totalPenalty = 0;
+    const files = [];
+    const dirs = ["src", "web/src"];
+    for (const dir of dirs) {
+        try {
+            collectFiles(join(cwd, dir), files);
+        }
+        catch { /* dir doesn't exist */ }
+    }
+    if (files.length === 0) {
+        return { name: "type-safety", score: 100, grade: "A", details: { skipped: true, reason: "no source files" }, issues: [], duration: Date.now() - start };
+    }
+    for (const file of files) {
+        const content = readFileSync(file, "utf-8");
+        const relPath = file.replace(cwd + "/", "");
+        const lines = content.split("\n");
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            if (line.trim().startsWith("//"))
+                continue;
+            for (const p of PATTERNS) {
+                const matches = line.match(p.pattern);
+                if (matches) {
+                    counts[p.name] = (counts[p.name] || 0) + matches.length;
+                    totalPenalty += p.weight * matches.length;
+                    for (const _m of matches) {
+                        issues.push({ severity: p.severity, message: p.name, file: relPath, line: i + 1, rule: "unsafe-type" });
+                    }
+                }
+            }
+        }
+    }
+    const score = Math.max(0, Math.min(100, Math.round(100 - totalPenalty)));
+    return {
+        name: "type-safety",
+        score,
+        grade: gradeFromScore(score),
+        details: { ...counts, filesScanned: files.length, totalUnsafe: issues.length },
+        issues,
+        duration: Date.now() - start,
+    };
+}
+function collectFiles(dir, out) {
+    for (const entry of readdirSync(dir)) {
+        if (entry === "node_modules" || entry === "dist")
+            continue;
+        const full = join(dir, entry);
+        if (statSync(full).isDirectory()) {
+            collectFiles(full, out);
+        }
+        else {
+            const ext = extname(entry);
+            if ((ext === ".ts" || ext === ".tsx") && !entry.includes(".test.") && !entry.includes(".spec.")) {
+                out.push(full);
+            }
+        }
+    }
+}

package/dist/runners/types-check.d.ts

@@ -0,0 +1,3 @@
+/** TypeScript type checking runner. */
+import type { CheckResult } from "../types.js";
+export declare function runTypeCheck(cwd: string): CheckResult;

package/dist/runners/types-check.js

@@ -0,0 +1,44 @@
+/** TypeScript type checking runner. */
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { gradeFromScore } from "../types.js";
+import { run } from "./exec.js";
+export function runTypeCheck(cwd) {
+    const start = Date.now();
+    const issues = [];
+    if (!existsSync(join(cwd, "tsconfig.json")) &&
+        !existsSync(join(cwd, "tsconfig.app.json"))) {
+        return {
+            name: "types",
+            score: 0,
+            grade: "F",
+            details: { skipped: true, reason: "no tsconfig.json" },
+            issues: [],
+            duration: Date.now() - start,
+        };
+    }
+    const { stdout } = run("npx tsc --noEmit 2>&1 || true", cwd, 30_000);
+    const lines = stdout.split("\n");
+    for (const line of lines) {
+        const match = line.match(/^(.+)\((\d+),\d+\): error (TS\d+): (.+)/);
+        if (match) {
+            issues.push({
+                severity: "error",
+                file: match[1],
+                line: parseInt(match[2]),
+                rule: match[3],
+                message: match[4],
+            });
+        }
+    }
+    const errorCount = issues.length;
+    const score = errorCount === 0 ? 100 : Math.max(0, 100 - errorCount * 5);
+    return {
+        name: "types",
+        score,
+        grade: gradeFromScore(score),
+        details: { errors: errorCount, ok: errorCount === 0 },
+        issues,
+        duration: Date.now() - start,
+    };
+}

package/dist/score.d.ts

@@ -0,0 +1,6 @@
+/** Compute weighted composite score from individual check results.
+ *  Weights are sourced from check-meta.ts — single source of truth. */
+import type { CheckResult } from "./types.js";
+export declare function computeScore(checks: CheckResult[]): number;
+/** Total weight across all checks (should be 100). */
+export declare function totalWeight(): number;

package/dist/score.js

@@ -0,0 +1,19 @@
+/** Compute weighted composite score from individual check results.
+ *  Weights are sourced from check-meta.ts — single source of truth. */
+import { CHECK_META, getCheckMeta } from "./check-meta.js";
+export function computeScore(checks) {
+    let totalWeight = 0;
+    let weightedSum = 0;
+    for (const check of checks) {
+        if (check.details.skipped)
+            continue;
+        const meta = getCheckMeta(check.name);
+        totalWeight += meta.weight;
+        weightedSum += check.score * meta.weight;
+    }
+    return totalWeight > 0 ? Math.round(weightedSum / totalWeight) : 0;
+}
+/** Total weight across all checks (should be 100). */
+export function totalWeight() {
+    return Object.values(CHECK_META).reduce((s, m) => s + m.weight, 0);
+}

package/dist/trend.d.ts

@@ -0,0 +1,19 @@
+/** Trend comparison — compares current report to previous run. */
+import type { VibeReport } from "./types.js";
+export interface TrendDelta {
+    scoreDelta: number;
+    checkDeltas: {
+        name: string;
+        prev: number;
+        curr: number;
+        delta: number;
+    }[];
+    newIssues: number;
+    fixedIssues: number;
+    prevTimestamp: string;
+}
+export declare function computeTrend(report: VibeReport, outputDir: string): TrendDelta | null;
+/** Render trend delta as terminal-friendly string. */
+export declare function formatTrend(trend: TrendDelta): string;
+/** Render trend HTML for the report. */
+export declare function trendHTML(trend: TrendDelta): string;