laxy-verify 0.1.2 → 1.0.0

package/dist/cli.js

@@ -1,102 +1,257 @@
-#!/usr/bin/env node
-import { Command } from "commander";
-import { resolve } from "path";
-import { existsSync } from "fs";
-import { loadConfig } from "./config.js";
-import { runBuild } from "./build-runner.js";
-import { runLighthouse } from "./lighthouse-runner.js";
-import { getVerificationGrade, getImprovementRecommendations } from "./verification.js";
-import { formatReport } from "./reporter.js";
-const EXIT_PASS = 0; // Silver or Gold
-const EXIT_SOFT_FAIL = 1; // Bronze (build OK, LH failed)
-const EXIT_FAIL = 2; // Unverified (build failed)
-const EXIT_CONFIG = 3; // Config error
-const program = new Command();
-program
-    .name("laxy-verify")
-    .description("Frontend quality gate: build check + Lighthouse audit + verification grade")
-    .version("0.1.0")
-    .argument("[dir]", "Project directory", ".")
-    .option("--format <type>", "Output format: console, json, md", "console")
-    .option("--ci", "CI mode: relaxed thresholds, 3 Lighthouse runs")
-    .option("--skip-lighthouse", "Skip Lighthouse, build-only verification")
-    .option("--runs <number>", "Number of Lighthouse runs", parseInt)
-    .option("--port <number>", "Dev server port", parseInt)
-    .action(async (dir, opts) => {
-    const projectPath = resolve(dir);
-    if (!existsSync(projectPath)) {
-        console.error(`Directory not found: ${projectPath}`);
-        process.exit(EXIT_CONFIG);
-    }
-    if (!existsSync(resolve(projectPath, "package.json"))) {
-        console.error("Not a Node.js project: package.json not found");
-        process.exit(EXIT_CONFIG);
-    }
-    // Load config
-    const { config, warnings } = loadConfig(projectPath, opts.ci);
-    for (const w of warnings)
-        console.warn(`[warn] ${w}`);
-    // Override config with CLI flags
-    if (opts.runs)
-        config.runs = opts.runs;
-    if (opts.port)
-        config.port = opts.port;
-    // Step 1: Build check
-    const buildResult = await runBuild(projectPath);
-    if (!buildResult.success) {
-        const report = {
-            grade: "unverified",
-            build: { success: false, errors: buildResult.errors, duration: buildResult.duration },
-            lighthouse: { scores: null },
-            thresholds: config.thresholds,
-            recommendations: getImprovementRecommendations({
-                buildSuccess: false,
-                buildErrors: buildResult.errors,
-            }),
-        };
-        console.log(formatReport(report, opts.format));
-        process.exit(EXIT_FAIL);
-    }
-    // Step 2: Lighthouse (optional)
-    let lighthouseScores = null;
-    let lighthouseError;
-    if (!opts.skipLighthouse) {
-        const lhResult = await runLighthouse(projectPath, {
-            port: config.port,
-            runs: config.runs,
-            ciMode: opts.ci,
-        });
-        lighthouseScores = lhResult.scores;
-        lighthouseError = lhResult.error;
-    }
-    // Step 3: Grade
-    const grade = getVerificationGrade({
-        buildSuccess: true,
-        lighthouseScores: lighthouseScores ?? undefined,
-    });
-    const report = {
-        grade,
-        build: { success: true, errors: [], duration: buildResult.duration },
-        lighthouse: { scores: lighthouseScores, error: lighthouseError },
-        thresholds: config.thresholds,
-        recommendations: getImprovementRecommendations({
-            buildSuccess: true,
-            lighthouseScores: lighthouseScores ?? undefined,
-        }),
-    };
-    console.log(formatReport(report, opts.format));
-    // Exit codes
-    switch (grade) {
-        case "gold":
-        case "silver":
-            process.exit(EXIT_PASS);
-            break;
-        case "bronze":
-            process.exit(EXIT_SOFT_FAIL);
-            break;
-        default:
-            process.exit(EXIT_FAIL);
-    }
-});
-program.parse();
-//# sourceMappingURL=cli.js.map
+#!/usr/bin/env node
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { loadConfig } from "./config.js";
+import { detect } from "./detect.js";
+import { runBuild } from "./build.js";
+import { startDevServer, stopDevServer } from "./serve.js";
+import { runLighthouse } from "./lighthouse.js";
+import { calculateGrade } from "./grade.js";
+import { runInit } from "./init.js";
+import { generateBadge } from "./badge.js";
+import { postPRComment } from "./comment.js";
+import { createStatusCheck } from "./status.js";
+function parseArgs() {
+    const raw = process.argv.slice(2);
+    // Single-pass: collect flags and first positional
+    let projectDir = ".";
+    const flags = {};
+    for (let i = 0; i < raw.length; i++) {
+        const arg = raw[i];
+        if (arg.startsWith("--")) {
+            const eqIndex = arg.indexOf("=");
+            if (eqIndex >= 0) {
+                const key = arg.slice(2, eqIndex);
+                flags[key] = arg.slice(eqIndex + 1);
+            }
+            else {
+                const key = arg.slice(2);
+                // Check if next arg is a value
+                if (i + 1 < raw.length && !raw[i + 1].startsWith("-")) {
+                    flags[key] = raw[++i];
+                }
+                else {
+                    flags[key] = "true";
+                }
+            }
+        }
+        else {
+            // Only first non-flag arg is positional (projectDir)
+            if (projectDir === ".") {
+                projectDir = arg;
+            }
+        }
+    }
+    return {
+        projectDir: path.resolve(projectDir),
+        format: flags["format"] ?? "console",
+        ciMode: flags["ci"] !== undefined || process.env.CI === "true",
+        configPath: flags["config"],
+        failOn: flags["fail-on"] ?? undefined,
+        skipLighthouse: flags["skip-lighthouse"] !== undefined,
+        badge: flags["badge"] !== undefined,
+        init: flags["init"] !== undefined,
+    };
+}
+function writeResultFile(projectDir, result) {
+    const filePath = path.join(projectDir, ".laxy-result.json");
+    fs.writeFileSync(filePath, JSON.stringify(result, null, 2) + "\n", "utf-8");
+}
+function consoleOutput(result) {
+    const gradeLabel = result.grade;
+    const checkEmoji = result.grade !== "Unverified" ? " ✅" : "";
+    console.log(`\n  Laxy Verify — ${gradeLabel}${checkEmoji}`);
+    console.log(`  Build: ${result.build.success ? `OK (${result.build.durationMs}ms)` : "FAILED"}`);
+    if (result.build.errors.length > 0) {
+        const last5 = result.build.errors.slice(-5);
+        console.log(`  Errors:`);
+        for (const e of last5)
+            console.error(`    ${e}`);
+    }
+    if (result.lighthouse !== null) {
+        const lh = result.lighthouse;
+        const t = result.thresholds;
+        const check = (passed) => passed ? " ✅" : " ❌";
+        console.log(`  Lighthouse:`);
+        console.log(`    Performance:     ${lh.performance} / ${t.performance}${check(lh.performance >= t.performance)}`);
+        console.log(`    Accessibility:   ${lh.accessibility} / ${t.accessibility}${check(lh.accessibility >= t.accessibility)}`);
+        console.log(`    SEO:             ${lh.seo} / ${t.seo}${check(lh.seo >= t.seo)}`);
+        console.log(`    Best Practices:  ${lh.bestPractices} / ${t.bestPractices}${check(lh.bestPractices >= t.bestPractices)}`);
+        console.log(`    Runs:            ${lh.runs}`);
+    }
+    else {
+        console.log(`  Lighthouse: skipped`);
+    }
+    if (result.github) {
+        if (result.github.status === "comment_posted")
+            console.log(`  PR comment: posted`);
+        if (result.github.status === "status_set")
+            console.log(`  Status check: ${result.github.grade}`);
+    }
+    console.log(`  Result: .laxy-result.json`);
+    console.log(`  Exit code: ${result.exitCode}`);
+}
+async function run() {
+    const args = parseArgs();
+    // --init
+    if (args.init) {
+        runInit(args.projectDir);
+        process.exit(0);
+        return;
+    }
+    // --badge
+    if (args.badge) {
+        const resultPath = path.join(args.projectDir, ".laxy-result.json");
+        if (!fs.existsSync(resultPath)) {
+            console.error("Error: .laxy-result.json not found. Run `npx laxy-verify .` first to generate it.");
+            process.exit(2);
+            return;
+        }
+        const content = JSON.parse(fs.readFileSync(resultPath, "utf-8"));
+        const badge = generateBadge(content.grade);
+        console.log(badge);
+        process.exit(0);
+        return;
+    }
+    // Load config
+    let config;
+    try {
+        config = loadConfig({
+            dir: args.projectDir,
+            configPath: args.configPath,
+            ciMode: args.ciMode,
+            cliFlags: {
+                failOn: args.failOn,
+                skipLighthouse: args.skipLighthouse,
+            },
+        });
+    }
+    catch (err) {
+        console.error(`Config error: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(2);
+        return;
+    }
+    // Auto-detect framework + package manager
+    let detected;
+    try {
+        detected = detect(args.projectDir);
+    }
+    catch (err) {
+        console.error(`Detection error: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(2);
+        return;
+    }
+    // Merge config overrides
+    const buildCmd = config.build_command || detected.buildCmd;
+    const devCmd = config.dev_command || detected.devCmd;
+    const port = config.port;
+    // Phase 1: Build
+    let buildResult;
+    try {
+        buildResult = await runBuild(buildCmd, config.build_timeout);
+    }
+    catch (err) {
+        buildResult = {
+            success: false,
+            durationMs: 0,
+            errors: err instanceof Error ? [err.message] : [String(err)],
+        };
+    }
+    let scores = undefined;
+    let lighthouseResult = null;
+    const adjustedThresholds = {
+        performance: config.ciMode
+            ? config.thresholds.performance - 10
+            : config.thresholds.performance,
+        accessibility: config.thresholds.accessibility,
+        seo: config.thresholds.seo,
+        bestPractices: config.thresholds.bestPractices,
+    };
+    // Phase 2: Dev server + Lighthouse (only if build succeeded and not skipped)
+    if (buildResult.success && !args.skipLighthouse) {
+        let servePid;
+        try {
+            const serve = await startDevServer(devCmd, port, config.dev_timeout);
+            servePid = serve.pid;
+            try {
+                const lhResult = await runLighthouse(port, config.lighthouse_runs);
+                scores = lhResult.scores ?? undefined;
+                if (scores) {
+                    lighthouseResult = {
+                        performance: scores.performance,
+                        accessibility: scores.accessibility,
+                        seo: scores.seo,
+                        bestPractices: scores.bestPractices,
+                        runs: config.lighthouse_runs,
+                    };
+                }
+            }
+            catch (lhErr) {
+                console.error(`Lighthouse error: ${lhErr instanceof Error ? lhErr.message : String(lhErr)}`);
+            }
+        }
+        catch (serveErr) {
+            console.error(`Dev server error: ${serveErr instanceof Error ? serveErr.message : String(serveErr)}`);
+        }
+        finally {
+            if (servePid) {
+                stopDevServer(servePid);
+            }
+        }
+    }
+    // Calculate grade
+    const gradeResult = calculateGrade({
+        buildSuccess: buildResult.success,
+        scores,
+        thresholds: adjustedThresholds,
+        failOn: config.fail_on,
+    });
+    // Build result object
+    const resultObj = {
+        grade: gradeResult.grade.charAt(0).toUpperCase() + gradeResult.grade.slice(1), // Capitalize
+        timestamp: new Date().toISOString(),
+        build: {
+            success: buildResult.success,
+            durationMs: buildResult.durationMs,
+            errors: buildResult.errors,
+        },
+        lighthouse: lighthouseResult,
+        thresholds: adjustedThresholds,
+        ciMode: config.ciMode,
+        framework: detected.framework,
+        exitCode: gradeResult.exitCode,
+        config_fail_on: config.fail_on,
+    };
+    // GitHub integration (only in Actions)
+    const inGitHubActions = !!process.env.GITHUB_ACTIONS;
+    if (inGitHubActions) {
+        try {
+            if (process.env.GITHUB_EVENT_NAME === "pull_request") {
+                await postPRComment(resultObj);
+                resultObj.github = { status: "comment_posted", grade: resultObj.grade };
+            }
+            await createStatusCheck({ grade: resultObj.grade, exitCode: resultObj.exitCode });
+            resultObj.github ??= { status: "status_set", grade: resultObj.grade };
+        }
+        catch (ghErr) {
+            console.error(`GitHub API warning: ${ghErr instanceof Error ? ghErr.message : String(ghErr)}`);
+        }
+    }
+    writeResultFile(args.projectDir, resultObj);
+    // Output
+    if (args.format === "json") {
+        console.log(JSON.stringify(resultObj, null, 2));
+    }
+    else {
+        consoleOutput(resultObj);
+    }
+    // Set $GITHUB_OUTPUT if in Actions
+    if (inGitHubActions && process.env.GITHUB_OUTPUT) {
+        fs.appendFileSync(process.env.GITHUB_OUTPUT, `grade=${resultObj.grade}\n`);
+    }
+    process.exit(gradeResult.exitCode);
+}
+run().catch((err) => {
+    console.error(`Fatal error: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+});

package/dist/comment.d.ts

@@ -0,0 +1,20 @@
+interface LaxyResult {
+    grade: string;
+    lighthouse: {
+        performance: number;
+        accessibility: number;
+        seo: number;
+        bestPractices: number;
+        runs: number;
+    } | null;
+    thresholds: {
+        performance: number;
+        accessibility: number;
+        seo: number;
+        bestPractices: number;
+    };
+    exitCode: number;
+    config_fail_on: string;
+}
+export declare function postPRComment(result: LaxyResult): Promise<void>;
+export {};

package/dist/comment.js

@@ -0,0 +1,53 @@
+import * as fs from "node:fs";
+import { getGitHubContext } from "./github.js";
+export async function postPRComment(result) {
+    const ctx = getGitHubContext();
+    if (!ctx || ctx.eventName !== "pull_request")
+        return;
+    // Parse PR number from event
+    let prNumber = 0;
+    if (ctx.eventPath && fs.existsSync(ctx.eventPath)) {
+        const event = JSON.parse(fs.readFileSync(ctx.eventPath, "utf-8"));
+        prNumber = event.pull_request?.number ?? 0;
+    }
+    if (!prNumber)
+        return;
+    const grade = result.grade ?? "Unverified";
+    const lh = result.lighthouse;
+    const t = result.thresholds;
+    let lhTable = "";
+    if (lh) {
+        lhTable = `| Performance | Accessibility | SEO | Best Practices |\n|---|---|---|---|\n| ${lh.performance} / ${t.performance} | ${lh.accessibility} / ${t.accessibility} | ${lh.seo} / ${t.seo} | ${lh.bestPractices} / ${t.bestPractices} |\n\n`;
+    }
+    const emoji = grade === "Gold" ? "🥇" :
+        grade === "Silver" ? "🥈" :
+            grade === "Bronze" ? "🥉" : "⚪";
+    const body = `## ${emoji} Laxy Verify — **${grade}**
+
+${grade === "Unverified" ? "The build failed or verification could not be completed." : `Build passed verification with a **${grade}** grade.`}
+
+${lhTable}**Fail-on threshold**: ${result.config_fail_on ?? "bronze"}
+
+---
+[🔍 Laxy Verify](https://github.com/psungmin24/laxy-verify) — Frontend quality gate`;
+    const [owner, repo] = ctx.repository.split("/");
+    const url = `https://api.github.com/repos/${owner}/${repo}/issues/${prNumber}/comments`;
+    try {
+        const res = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Authorization": `Bearer ${ctx.token}`,
+                "Accept": "application/vnd.github.v3+json",
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({ body }),
+        });
+        if (!res.ok) {
+            console.warn(`GitHub PR comment API returned ${res.status} — skipping comment`);
+            return;
+        }
+    }
+    catch (err) {
+        console.warn(`GitHub PR comment request failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}

package/dist/config.d.ts

@@ -1,16 +1,34 @@
-export interface LaxyConfig {
-    thresholds: {
-        performance: number;
-        accessibility: number;
-        seo: number;
-        bestPractices: number;
-    };
-    buildCommand?: string;
-    devCommand?: string;
-    port: number;
-    runs: number;
-}
-export declare function loadConfig(projectPath: string, ciMode?: boolean): {
-    config: LaxyConfig;
-    warnings: string[];
-};
+export type FailOn = "unverified" | "bronze" | "silver" | "gold";
+export interface Thresholds {
+    performance: number;
+    accessibility: number;
+    seo: number;
+    bestPractices: number;
+}
+export interface LaxyConfig {
+    framework: string;
+    build_command: string;
+    dev_command: string;
+    package_manager: string;
+    port: number;
+    build_timeout: number;
+    dev_timeout: number;
+    lighthouse_runs: number;
+    thresholds: Thresholds;
+    fail_on: FailOn;
+}
+export declare class ConfigParseError extends Error {
+    constructor(msg: string);
+}
+export interface LoadConfigOptions {
+    dir: string;
+    configPath?: string;
+    cliFlags?: {
+        failOn?: FailOn;
+        skipLighthouse?: boolean;
+    };
+    ciMode: boolean;
+}
+export declare function loadConfig(options: LoadConfigOptions): LaxyConfig & {
+    ciMode: boolean;
+};