@vibecodeqa/cli 0.39.1 → 0.41.0

package/dist/ai-fix.d.ts

@@ -0,0 +1,27 @@
+/** AI-powered code fixing — uses Claude to fix issues found by vcqa scan.
+ *
+ * Auth: ANTHROPIC_API_KEY (direct) or VCQA_PRO_KEY (via api.vibecodeqa.online).
+ */
+import type { CheckResult } from "./types.js";
+export interface FixableIssue {
+    check: string;
+    file: string;
+    line: number;
+    rule: string;
+    message: string;
+    suggestion: string | null;
+}
+export interface AiFixResult {
+    file: string;
+    line: number;
+    check: string;
+    message: string;
+    explanation: string;
+    applied: boolean;
+}
+/** Collect fixable issues from scan results, optionally filtered by check name. */
+export declare function collectFixableIssues(checks: CheckResult[], suggestFix: (check: string, rule: string, message: string) => string | null, checkFilter?: string): FixableIssue[];
+/** Fix issues using AI. Returns results for each attempted fix. */
+export declare function aiFixIssues(cwd: string, issues: FixableIssue[], opts: {
+    dryRun: boolean;
+}): Promise<AiFixResult[]>;

package/dist/ai-fix.js

@@ -0,0 +1,216 @@
+/** AI-powered code fixing — uses Claude to fix issues found by vcqa scan.
+ *
+ * Auth: ANTHROPIC_API_KEY (direct) or VCQA_PRO_KEY (via api.vibecodeqa.online).
+ */
+import { readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { getCheckMeta } from "./check-meta.js";
+/** Collect fixable issues from scan results, optionally filtered by check name. */
+export function collectFixableIssues(checks, suggestFix, checkFilter) {
+    const issues = [];
+    for (const c of checks) {
+        if (checkFilter && c.name !== checkFilter)
+            continue;
+        for (const iss of c.issues) {
+            if (!iss.file || typeof iss.file !== "string" || !iss.line)
+                continue;
+            if (iss.severity === "info")
+                continue;
+            issues.push({
+                check: c.name,
+                file: iss.file,
+                line: iss.line,
+                rule: iss.rule || "",
+                message: iss.message,
+                suggestion: suggestFix(c.name, iss.rule || "", iss.message),
+            });
+        }
+    }
+    return issues;
+}
+/** Fix issues using AI. Returns results for each attempted fix. */
+export async function aiFixIssues(cwd, issues, opts) {
+    const apiKey = process.env.ANTHROPIC_API_KEY || "";
+    const proKey = process.env.VCQA_PRO_KEY || "";
+    if (!apiKey && !proKey) {
+        console.log("  \x1b[31mNo API key found.\x1b[0m Set ANTHROPIC_API_KEY or VCQA_PRO_KEY.");
+        console.log("  \x1b[2mANTHROPIC_API_KEY — direct Claude API (recommended)\x1b[0m");
+        console.log("  \x1b[2mVCQA_PRO_KEY     — via api.vibecodeqa.online\x1b[0m");
+        return [];
+    }
+    const results = [];
+    // Process files in order, one issue at a time to avoid drift
+    const sorted = [...issues].sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line);
+    // Limit to 10 fixes per run to avoid burning tokens
+    const batch = sorted.slice(0, 10);
+    if (sorted.length > 10) {
+        console.log(`  \x1b[2mFixing 10 of ${sorted.length} issues (run again for more)\x1b[0m`);
+    }
+    for (const issue of batch) {
+        const absPath = join(cwd, issue.file);
+        let content;
+        try {
+            content = readFileSync(absPath, "utf-8");
+        }
+        catch {
+            results.push({ ...issue, explanation: "file not readable", applied: false });
+            continue;
+        }
+        const lines = content.split("\n");
+        const meta = getCheckMeta(issue.check);
+        // Extract context: ±20 lines around the issue
+        const start = Math.max(0, issue.line - 21);
+        const end = Math.min(lines.length, issue.line + 20);
+        const contextLines = lines.slice(start, end);
+        const numbered = contextLines.map((l, i) => `${start + i + 1}| ${l}`).join("\n");
+        const prompt = buildFixPrompt(issue, meta, numbered, issue.file);
+        process.stdout.write(`  ${issue.file}:${issue.line} \x1b[2m${issue.message.slice(0, 50)}\x1b[0m `);
+        const fix = apiKey
+            ? await callAnthropicDirect(prompt, apiKey)
+            : await callVcqaProxy(prompt, proKey);
+        if (!fix) {
+            console.log("\x1b[33mskip\x1b[0m");
+            results.push({ ...issue, explanation: "AI could not generate fix", applied: false });
+            continue;
+        }
+        if (opts.dryRun) {
+            console.log("\x1b[36mdry-run\x1b[0m");
+            console.log(`    \x1b[2m${fix.explanation}\x1b[0m`);
+            results.push({ ...issue, explanation: fix.explanation, applied: false });
+            continue;
+        }
+        // Apply search/replace
+        const searchNormalized = fix.search.trim();
+        if (!content.includes(searchNormalized)) {
+            console.log("\x1b[33mskip (no match)\x1b[0m");
+            results.push({ ...issue, explanation: "search text not found in file", applied: false });
+            continue;
+        }
+        const idx = content.indexOf(searchNormalized);
+        const updated = content.slice(0, idx) + fix.replace.trim() + content.slice(idx + searchNormalized.length);
+        writeFileSync(absPath, updated);
+        console.log("\x1b[32mfixed\x1b[0m");
+        console.log(`    \x1b[2m${fix.explanation}\x1b[0m`);
+        results.push({ ...issue, explanation: fix.explanation, applied: true });
+    }
+    return results;
+}
+function buildFixPrompt(issue, meta, codeContext, filePath) {
+    const ext = filePath.split(".").pop() || "ts";
+    const lang = ext === "vue" ? "vue" : ext === "svelte" ? "svelte" : ext === "dart" ? "dart" : "typescript";
+    let prompt = `Fix this code quality issue. Return a JSON object with search/replace strings.
+
+## Issue
+- Check: ${issue.check}
+- Rule: ${issue.rule || "n/a"}
+- Message: ${issue.message}
+- File: ${filePath}:${issue.line}
+
+## Why this matters
+${meta.risk}
+
+## Recommended approach
+${meta.recommendation}`;
+    if (issue.suggestion) {
+        prompt += `\n\nSpecific suggestion: ${issue.suggestion}`;
+    }
+    prompt += `
+
+## Code context (${filePath})
+\`\`\`${lang}
+${codeContext}
+\`\`\`
+
+## Instructions
+Return ONLY a valid JSON object (no markdown, no explanation outside JSON):
+{
+  "search": "exact lines from the code above that need to change (copy verbatim, preserve whitespace)",
+  "replace": "the fixed replacement code (same indentation)",
+  "explanation": "one sentence: what changed and why"
+}
+
+Rules:
+- The "search" string MUST appear verbatim in the file — copy it exactly
+- Keep the fix minimal — change only what's needed to resolve the issue
+- Preserve surrounding code, comments, and formatting
+- Do not add imports unless absolutely required
+- Match the existing code style`;
+    return prompt;
+}
+let _apiErrorShown = false;
+async function callAnthropicDirect(prompt, apiKey) {
+    try {
+        const res = await fetch("https://api.anthropic.com/v1/messages", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "x-api-key": apiKey,
+                "anthropic-version": "2023-06-01",
+            },
+            body: JSON.stringify({
+                model: "claude-haiku-4-5-20251001",
+                max_tokens: 1024,
+                messages: [{ role: "user", content: prompt }],
+            }),
+        });
+        if (!res.ok) {
+            if (!_apiErrorShown) {
+                const err = (await res.json().catch(() => null));
+                console.log(`\n  \x1b[31mAPI error:\x1b[0m ${err?.error?.message || `HTTP ${res.status}`}\n`);
+                _apiErrorShown = true;
+            }
+            return null;
+        }
+        const data = (await res.json());
+        const text = data.content?.find((c) => c.type === "text")?.text;
+        if (!text)
+            return null;
+        return parseFixResponse(text);
+    }
+    catch {
+        return null;
+    }
+}
+async function callVcqaProxy(prompt, proKey) {
+    try {
+        const res = await fetch("https://api.vibecodeqa.online/api/pro/fix", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${proKey}`,
+            },
+            body: JSON.stringify({ prompt }),
+        });
+        if (!res.ok)
+            return null;
+        const data = (await res.json());
+        if (!data.search || !data.replace)
+            return null;
+        return { search: data.search, replace: data.replace, explanation: data.explanation || "" };
+    }
+    catch {
+        return null;
+    }
+}
+function parseFixResponse(text) {
+    try {
+        // Try to extract JSON from the response (handle markdown fences)
+        let json = text.trim();
+        const fenceMatch = json.match(/```(?:json)?\s*([\s\S]*?)```/);
+        if (fenceMatch)
+            json = fenceMatch[1].trim();
+        const parsed = JSON.parse(json);
+        if (!parsed.search || typeof parsed.search !== "string")
+            return null;
+        if (!parsed.replace || typeof parsed.replace !== "string")
+            return null;
+        return {
+            search: parsed.search,
+            replace: parsed.replace,
+            explanation: parsed.explanation || "",
+        };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/cli.js

@@ -2,6 +2,7 @@
 /** vibe-check — code health scanner for the AI coding era. */
 import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { join, resolve } from "node:path";
+import { aiFixIssues, collectFixableIssues } from "./ai-fix.js";
 import { getCheckMeta } from "./check-meta.js";
 import { getCheckIgnore, isCheckEnabled, loadConfig } from "./config.js";
 import { detectRepoUrl, detectStack, detectWorkspace } from "./detect.js";
@@ -387,6 +388,9 @@ function printHelp() {
   \x1b[1mCommands:\x1b[0m
     init [path]       Set up CI workflow + recommended configs
     fix [path]        Auto-fix (.gitignore, strict mode, biome/eslint, suggestions)
+      --ai            Use Claude to fix remaining issues (needs ANTHROPIC_API_KEY)
+      --check NAME    Only fix issues from a specific check (e.g. --check security)
+      --dry-run       Show what AI would fix without applying changes
     explain [check]   Deep-dive explanation of a check (what/risk/fix)
     monitor [path]    Live quality control panel — re-scans on file changes
 
@@ -411,6 +415,9 @@ function printHelp() {
     npx @vibecodeqa/cli                     # scan current directory
     npx @vibecodeqa/cli init                # set up CI + configs
     npx @vibecodeqa/cli fix                 # auto-fix what's fixable
+    npx @vibecodeqa/cli fix --ai            # AI-powered fix (uses Claude)
+    npx @vibecodeqa/cli fix --ai --check security  # fix only security issues
+    npx @vibecodeqa/cli fix --ai --dry-run  # preview AI fixes without applying
     npx @vibecodeqa/cli --skip-tests --top  # fast scan with top issues
     npx @vibecodeqa/cli --ci --fail-under 80  # CI with quality gate
 `);
@@ -548,9 +555,9 @@ async function runExplain(checkName) {
     console.log("");
 }
 // ── fix command ──
-async function runFix(cwd) {
+async function runFix(cwd, opts = {}) {
     console.log("");
-    console.log(`  \x1b[1m\x1b[38;5;141mvcqa fix\x1b[0m`);
+    console.log(`  \x1b[1m\x1b[38;5;141mvcqa fix${opts.ai ? " --ai" : ""}${opts.dryRun ? " --dry-run" : ""}${opts.checkFilter ? ` --check ${opts.checkFilter}` : ""}\x1b[0m`);
     console.log(`  \x1b[2m${cwd}\x1b[0m`);
     console.log("");
     validateCwd(cwd);
@@ -621,7 +628,39 @@ async function runFix(cwd) {
     const isDart = enrichedStack.language === "dart";
     const checks = await runChecks(cwd, enrichedStack, workspace, true, isDart, true);
     const score = computeScore(checks);
-    // Collect actionable issues with fix suggestions
+    // AI-powered fix mode
+    if (opts.ai) {
+        const aiIssues = collectFixableIssues(checks, suggestFix, opts.checkFilter);
+        if (aiIssues.length === 0) {
+            console.log("  \x1b[2mNo fixable issues found.\x1b[0m");
+        }
+        else {
+            console.log(`  \x1b[1mAI fixing ${Math.min(aiIssues.length, 10)} issues${opts.dryRun ? " (dry run)" : ""}...\x1b[0m`);
+            console.log("");
+            const results = await aiFixIssues(cwd, aiIssues, { dryRun: opts.dryRun || false });
+            const applied = results.filter((r) => r.applied).length;
+            if (applied > 0) {
+                // Re-scan to show new score
+                console.log("");
+                console.log("  \x1b[1mRe-scanning...\x1b[0m");
+                const reChecks = await runChecks(cwd, enrichedStack, workspace, true, isDart, true);
+                const newScore = computeScore(reChecks);
+                const newGrade = gradeFromScore(newScore);
+                const delta = newScore - score;
+                console.log(`  Score: \x1b[${newScore >= 75 ? "32" : newScore >= 60 ? "33" : "31"}m${newGrade} ${newScore}/100\x1b[0m${delta > 0 ? ` \x1b[32m(+${delta})\x1b[0m` : ""}`);
+                console.log(`  \x1b[32m${applied} AI fix(es) applied.\x1b[0m Re-run \x1b[1mnpx @vibecodeqa/cli\x1b[0m for full report.`);
+            }
+            else {
+                const grade = gradeFromScore(score);
+                console.log(`\n  Score: \x1b[${score >= 75 ? "32" : score >= 60 ? "33" : "31"}m${grade} ${score}/100\x1b[0m`);
+                if (opts.dryRun)
+                    console.log("  \x1b[2mDry run — no files modified. Remove --dry-run to apply.\x1b[0m");
+            }
+        }
+        console.log("");
+        return;
+    }
+    // Collect actionable issues with fix suggestions (non-AI mode)
     const fixable = [];
     for (const c of checks) {
         for (const iss of c.issues) {
@@ -826,8 +865,13 @@ async function main() {
         return;
     }
     if (args[0] === "fix") {
-        const path = args.slice(1).find((a) => !a.startsWith("-")) || ".";
-        await runFix(resolve(path));
+        const fixArgs = args.slice(1);
+        const path = fixArgs.find((a) => !a.startsWith("-")) || ".";
+        const aiMode = fixArgs.includes("--ai");
+        const dryRun = fixArgs.includes("--dry-run");
+        const checkIdx = fixArgs.indexOf("--check");
+        const checkFilter = checkIdx !== -1 ? fixArgs[checkIdx + 1] : undefined;
+        await runFix(resolve(path), { ai: aiMode, dryRun, checkFilter });
         return;
     }
     if (args[0] === "explain") {
@@ -907,11 +951,11 @@ async function main() {
         emitAnnotations(report);
     }
     if (flags.uploadMode) {
-        await handleUpload(report, cwd, jsonOnly);
+        await handleUpload(report, cwd, quietMode);
     }
     if (flags.prComment) {
         const posted = await postPRComment(report, trend, cwd);
-        if (!jsonOnly) {
+        if (!quietMode) {
             if (posted)
                 console.log("  \x1b[32m\u2713 PR comment posted\x1b[0m");
             else
@@ -921,12 +965,12 @@ async function main() {
     // CI exit code: fail if score below threshold (skip in watch mode)
     const failUnder = flags.failUnder ?? (ciMode ? 60 : (config.failUnder ?? 0));
     if (failUnder > 0 && score < failUnder && !watchMode) {
-        if (!jsonOnly)
+        if (!quietMode)
             console.log(`  \x1b[31mFailing: score ${score} < ${failUnder}\x1b[0m\n`);
         process.exit(1);
     }
     // Non-blocking update check (don't slow down the scan)
-    if (!jsonOnly && !ciMode && !watchMode && !process.env.VCQA_NO_UPDATE_CHECK) {
+    if (!quietMode && !ciMode && !watchMode && !process.env.VCQA_NO_UPDATE_CHECK) {
         checkForUpdate(VERSION).catch(() => { });
     }
     if (watchMode) {

package/dist/core.d.ts

@@ -0,0 +1,28 @@
+/** @vibecodeqa/cli/core — Programmatic scan API.
+ *
+ * Usage:
+ *   import { scan } from "@vibecodeqa/cli/core";
+ *   const report = await scan("./src");
+ *   console.log(report.score, report.grade);
+ */
+import { CHECK_META, getCheckMeta, type CheckMeta } from "./check-meta.js";
+import { type VcqaConfig } from "./config.js";
+import type { CheckResult, Issue, StackInfo, VibeReport, WorkspaceInfo, WorkspacePackage } from "./types.js";
+export interface ScanOptions {
+    /** Skip test execution (faster scan). Default: false */
+    skipTests?: boolean;
+    /** Only run these checks (by name). Default: all checks */
+    checks?: string[];
+    /** Override config (instead of loading from .vcqa.json). */
+    config?: VcqaConfig;
+    /** Progress callback — called for each completed check. */
+    onProgress?: (check: string, result: CheckResult, index: number, total: number) => void;
+}
+/** Run a full code health scan. Returns a VibeReport with score, grade, and all check results. */
+export declare function scan(cwd: string, options?: ScanOptions): Promise<VibeReport>;
+export { CHECK_META, getCheckMeta, type CheckMeta };
+export { computeScore } from "./score.js";
+export { loadConfig, type VcqaConfig } from "./config.js";
+export { detectStack, detectWorkspace } from "./detect.js";
+export { gradeFromScore } from "./types.js";
+export type { CheckResult, Issue, StackInfo, VibeReport, WorkspaceInfo, WorkspacePackage };

package/dist/core.js

@@ -0,0 +1,163 @@
+/** @vibecodeqa/cli/core — Programmatic scan API.
+ *
+ * Usage:
+ *   import { scan } from "@vibecodeqa/cli/core";
+ *   const report = await scan("./src");
+ *   console.log(report.score, report.grade);
+ */
+import { resolve } from "node:path";
+import { readFileSync } from "node:fs";
+import { CHECK_META, getCheckMeta } from "./check-meta.js";
+import { getCheckIgnore, isCheckEnabled, loadConfig } from "./config.js";
+import { detectRepoUrl, detectStack, detectWorkspace } from "./detect.js";
+import { setGlobalIgnore, setGlobalSrcRoots } from "./fs-utils.js";
+import { runAccessibility } from "./runners/accessibility.js";
+import { runArchitecture } from "./runners/architecture.js";
+import { runBestPractices } from "./runners/best-practices.js";
+import { runCodeCoherence } from "./runners/code-coherence.js";
+import { runCommentStaleness } from "./runners/comment-staleness.js";
+import { runComplexity } from "./runners/complexity.js";
+import { runDeadPatterns } from "./runners/dead-patterns.js";
+import { runTestAudit } from "./runners/test-audit.js";
+import { runConfusion } from "./runners/confusion.js";
+import { runContext } from "./runners/context.js";
+import { runDependencies } from "./runners/dependencies.js";
+import { runDocCoherence } from "./runners/doc-coherence.js";
+import { runDocs } from "./runners/docs.js";
+import { runDuplication } from "./runners/duplication.js";
+import { runErrorHandling } from "./runners/error-handling.js";
+import { runLint } from "./runners/lint.js";
+import { runPerformance } from "./runners/performance.js";
+import { runReact } from "./runners/react.js";
+import { runSecrets } from "./runners/secrets.js";
+import { runSecurity } from "./runners/security.js";
+import { runStandards } from "./runners/standards.js";
+import { runStructure } from "./runners/structure.js";
+import { runTesting } from "./runners/testing.js";
+import { runTypeSafety } from "./runners/type-safety.js";
+import { runTypeCheck } from "./runners/types-check.js";
+import { computeScore } from "./score.js";
+import { gradeFromScore } from "./types.js";
+const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf-8"));
+const VERSION = pkg.version;
+/** Run a full code health scan. Returns a VibeReport with score, grade, and all check results. */
+export async function scan(cwd, options = {}) {
+    const start = Date.now();
+    const resolvedCwd = resolve(cwd);
+    const config = options.config ?? loadConfig(resolvedCwd);
+    const workspace = detectWorkspace(resolvedCwd);
+    const stack = detectStack(resolvedCwd, workspace);
+    const isDart = stack.language === "dart";
+    setGlobalSrcRoots(workspace.isMonorepo ? workspace.srcRoots : undefined);
+    setGlobalIgnore(config.ignore);
+    const srcRoots = workspace.isMonorepo ? workspace.srcRoots : undefined;
+    const skipTests = options.skipTests ?? false;
+    const allRunners = [
+        { name: "structure", fn: () => runStructure(resolvedCwd, stack, workspace) },
+        { name: "lint", fn: () => runLint(resolvedCwd, stack, workspace) },
+        { name: "types", fn: () => runTypeCheck(resolvedCwd, isDart, workspace) },
+        { name: "type-safety", fn: () => runTypeSafety(resolvedCwd, isDart) },
+        { name: "standards", fn: () => runStandards(resolvedCwd, stack) },
+        { name: "complexity", fn: () => runComplexity(resolvedCwd) },
+        { name: "duplication", fn: () => runDuplication(resolvedCwd) },
+        { name: "error-handling", fn: () => runErrorHandling(resolvedCwd, stack) },
+        { name: "react", fn: () => runReact(resolvedCwd, stack) },
+        { name: "accessibility", fn: () => runAccessibility(resolvedCwd) },
+        { name: "docs", fn: () => runDocs(resolvedCwd) },
+        { name: "best-practices", fn: () => runBestPractices(resolvedCwd, workspace) },
+        { name: "testing", fn: () => runTesting(resolvedCwd, stack, skipTests, srcRoots) },
+        { name: "secrets", fn: () => runSecrets(resolvedCwd) },
+        { name: "security", fn: () => runSecurity(resolvedCwd) },
+        { name: "dependencies", fn: () => runDependencies(resolvedCwd, stack) },
+        { name: "architecture", fn: () => runArchitecture(resolvedCwd, workspace) },
+        { name: "performance", fn: () => runPerformance(resolvedCwd) },
+        { name: "confusion", fn: () => runConfusion(resolvedCwd) },
+        { name: "context", fn: () => runContext(resolvedCwd) },
+        { name: "doc-coherence", fn: () => runDocCoherence(resolvedCwd) },
+        { name: "code-coherence", fn: () => runCodeCoherence(resolvedCwd) },
+        { name: "comment-staleness", fn: () => runCommentStaleness(resolvedCwd) },
+        { name: "dead-patterns", fn: () => runDeadPatterns(resolvedCwd) },
+        { name: "test-audit", fn: () => runTestAudit(resolvedCwd) },
+    ];
+    // Filter checks if specified
+    const checkFilter = options.checks ? new Set(options.checks) : null;
+    const runners = checkFilter
+        ? allRunners.filter((r) => checkFilter.has(r.name))
+        : allRunners;
+    const checks = [];
+    const total = runners.length;
+    for (let i = 0; i < total; i++) {
+        const runner = runners[i];
+        if (!isCheckEnabled(config, runner.name)) {
+            const skipped = {
+                name: runner.name,
+                score: 0,
+                grade: "F",
+                details: { skipped: true, reason: "disabled in config" },
+                issues: [],
+                duration: 0,
+            };
+            checks.push(skipped);
+            options.onProgress?.(runner.name, skipped, i, total);
+            continue;
+        }
+        let result;
+        try {
+            const maybeResult = runner.fn();
+            result = maybeResult instanceof Promise ? await maybeResult : maybeResult;
+        }
+        catch (err) {
+            result = {
+                name: runner.name,
+                score: 0,
+                grade: "F",
+                details: { skipped: true, reason: `runner error: ${err instanceof Error ? err.message : "unknown"}` },
+                issues: [],
+                duration: 0,
+            };
+        }
+        // Apply per-check ignore patterns
+        const patterns = getCheckIgnore(config, result.name);
+        if (patterns?.length) {
+            result.issues = result.issues.filter((issue) => {
+                if (!issue.file || typeof issue.file !== "string")
+                    return true;
+                const f = issue.file;
+                return !patterns.some((p) => {
+                    if (p.endsWith("/**"))
+                        return f.startsWith(p.slice(0, -3) + "/");
+                    if (p.startsWith("*"))
+                        return f.endsWith(p.slice(1));
+                    return f.startsWith(p);
+                });
+            });
+        }
+        checks.push(result);
+        options.onProgress?.(runner.name, result, i, total);
+    }
+    const score = computeScore(checks);
+    const grade = gradeFromScore(score);
+    const { repoUrl, branch } = detectRepoUrl(resolvedCwd);
+    return {
+        version: VERSION,
+        timestamp: new Date().toISOString(),
+        score,
+        grade,
+        checks,
+        meta: {
+            cwd: resolvedCwd,
+            node: process.version,
+            duration: Date.now() - start,
+            stack,
+            workspace,
+            repoUrl,
+            branch,
+        },
+    };
+}
+// ── Re-exports ──
+export { CHECK_META, getCheckMeta };
+export { computeScore } from "./score.js";
+export { loadConfig } from "./config.js";
+export { detectStack, detectWorkspace } from "./detect.js";
+export { gradeFromScore } from "./types.js";

package/dist/fs-utils.js

@@ -168,7 +168,7 @@ function walk(dir, cwd, out, exts) {
             });
         }
         catch {
-            continue; // broken symlink, deleted file, or permission denied
+            /* broken symlink, deleted file, or permission denied */
         }
     }
 }

package/package.json

@@ -1,12 +1,16 @@
 {
 	"name": "@vibecodeqa/cli",
-	"version": "0.39.1",
+	"version": "0.41.0",
 	"description": "Code health scanner for the AI coding era. 25 checks, zero config, full report.",
 	"type": "module",
 	"bin": {
 		"vcqa": "./dist/cli.js",
 		"vibe-check": "./dist/cli.js"
 	},
+	"exports": {
+		".": "./dist/cli.js",
+		"./core": "./dist/core.js"
+	},
 	"files": [
 		"dist",
 		"LICENSE",