laxy-verify 0.1.2 → 1.0.0

package/dist/config.js

@@ -1,55 +1,118 @@
-import { readFileSync, existsSync } from "fs";
-import { join } from "path";
-import { parse as parseYaml } from "yaml";
-import { LH_THRESHOLDS, LH_CI_THRESHOLDS } from "./verification.js";
-const DEFAULT_CONFIG = {
-    thresholds: { ...LH_THRESHOLDS },
-    port: 3000,
-    runs: 1,
-};
-export function loadConfig(projectPath, ciMode = false) {
-    const warnings = [];
-    const configPath = join(projectPath, ".laxy.yml");
-    const defaults = {
-        thresholds: ciMode ? { ...LH_CI_THRESHOLDS } : { ...LH_THRESHOLDS },
-        port: DEFAULT_CONFIG.port,
-        runs: ciMode ? 3 : 1,
-    };
-    if (!existsSync(configPath)) {
-        return { config: defaults, warnings };
-    }
-    try {
-        const raw = readFileSync(configPath, "utf-8");
-        const parsed = parseYaml(raw);
-        if (!parsed || typeof parsed !== "object") {
-            warnings.push("Invalid .laxy.yml: not an object. Using defaults.");
-            return { config: defaults, warnings };
-        }
-        const config = { ...defaults };
-        if (parsed.thresholds && typeof parsed.thresholds === "object") {
-            const t = parsed.thresholds;
-            if (typeof t.performance === "number")
-                config.thresholds.performance = t.performance;
-            if (typeof t.accessibility === "number")
-                config.thresholds.accessibility = t.accessibility;
-            if (typeof t.seo === "number")
-                config.thresholds.seo = t.seo;
-            if (typeof t.bestPractices === "number")
-                config.thresholds.bestPractices = t.bestPractices;
-        }
-        if (typeof parsed.buildCommand === "string")
-            config.buildCommand = parsed.buildCommand;
-        if (typeof parsed.devCommand === "string")
-            config.devCommand = parsed.devCommand;
-        if (typeof parsed.port === "number")
-            config.port = parsed.port;
-        if (typeof parsed.runs === "number")
-            config.runs = Math.max(1, Math.min(parsed.runs, 5));
-        return { config, warnings };
-    }
-    catch {
-        warnings.push("Failed to parse .laxy.yml. Using defaults.");
-        return { config: defaults, warnings };
-    }
-}
-//# sourceMappingURL=config.js.map
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as yaml from "js-yaml";
+const DEFAULT_CONFIG = {
+    framework: "auto",
+    build_command: "",
+    dev_command: "",
+    package_manager: "auto",
+    port: 3000,
+    build_timeout: 300,
+    dev_timeout: 60,
+    lighthouse_runs: 1,
+    thresholds: {
+        performance: 70,
+        accessibility: 85,
+        seo: 80,
+        bestPractices: 80,
+    },
+    fail_on: "bronze",
+};
+const VALID_FAIL_ON = ["unverified", "bronze", "silver", "gold"];
+export class ConfigParseError extends Error {
+    constructor(msg) {
+        super(msg);
+        this.name = "ConfigParseError";
+    }
+}
+function parseYaml(filePath) {
+    const content = fs.readFileSync(filePath, "utf-8");
+    const raw = yaml.load(content);
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+        throw new ConfigParseError("Invalid YAML structure in .laxy.yml");
+    }
+    const result = {};
+    if (typeof raw.framework === "string")
+        result.framework = raw.framework;
+    if (typeof raw.build_command === "string")
+        result.build_command = raw.build_command;
+    if (typeof raw.dev_command === "string")
+        result.dev_command = raw.dev_command;
+    if (typeof raw.package_manager === "string")
+        result.package_manager = raw.package_manager;
+    if (typeof raw.port === "number")
+        result.port = raw.port;
+    if (typeof raw.build_timeout === "number")
+        result.build_timeout = raw.build_timeout;
+    if (typeof raw.dev_timeout === "number")
+        result.dev_timeout = raw.dev_timeout;
+    if (typeof raw.lighthouse_runs === "number")
+        result.lighthouse_runs = raw.lighthouse_runs;
+    if (typeof raw.fail_on === "string") {
+        const f = raw.fail_on;
+        if (!VALID_FAIL_ON.includes(f)) {
+            throw new ConfigParseError(`Invalid fail_on value: "${f}". Must be one of: ${VALID_FAIL_ON.join(", ")}`);
+        }
+        result.fail_on = f;
+    }
+    if (typeof raw.thresholds === "object" &&
+        raw.thresholds !== null &&
+        !Array.isArray(raw.thresholds)) {
+        const t = raw.thresholds;
+        const thr = {};
+        if (typeof t.performance === "number")
+            thr.performance = t.performance;
+        if (typeof t.accessibility === "number")
+            thr.accessibility = t.accessibility;
+        if (typeof t.seo === "number")
+            thr.seo = t.seo;
+        if (typeof t.best_practices === "number")
+            thr.bestPractices = t.best_practices;
+        result.thresholds = thr;
+    }
+    return result;
+}
+export function loadConfig(options) {
+    const configPath = options.configPath ?? path.join(options.dir, ".laxy.yml");
+    let base = {};
+    if (fs.existsSync(configPath)) {
+        base = parseYaml(configPath);
+    }
+    const config = {
+        ...DEFAULT_CONFIG,
+        framework: base.framework ?? DEFAULT_CONFIG.framework,
+        build_command: base.build_command ?? DEFAULT_CONFIG.build_command,
+        dev_command: base.dev_command ?? DEFAULT_CONFIG.dev_command,
+        package_manager: base.package_manager ?? DEFAULT_CONFIG.package_manager,
+        port: base.port ?? DEFAULT_CONFIG.port,
+        build_timeout: base.build_timeout ?? DEFAULT_CONFIG.build_timeout,
+        dev_timeout: base.dev_timeout ?? DEFAULT_CONFIG.dev_timeout,
+        lighthouse_runs: base.lighthouse_runs ?? DEFAULT_CONFIG.lighthouse_runs,
+        fail_on: base.fail_on ?? DEFAULT_CONFIG.fail_on,
+    };
+    config.thresholds = { ...DEFAULT_CONFIG.thresholds, ...(base.thresholds ?? {}) };
+    // CLI flag overrides
+    if (options.cliFlags?.failOn !== undefined) {
+        if (!VALID_FAIL_ON.includes(options.cliFlags.failOn)) {
+            throw new ConfigParseError(`Invalid --fail-on value: "${options.cliFlags.failOn}". Must be one of: ${VALID_FAIL_ON.join(", ")}`);
+        }
+        config.fail_on = options.cliFlags.failOn;
+    }
+    // CI mode: apply CI defaults
+    const ciMode = options.ciMode;
+    if (ciMode) {
+        // dev_timeout: 90s in CI
+        if (!base.dev_timeout) {
+            config.dev_timeout = 90;
+        }
+        // lighthouse_runs: default to 3 in CI, but explicit config file value wins
+        if (!base.lighthouse_runs) {
+            config.lighthouse_runs = 3;
+        }
+    }
+    // Skip lighthouse: max grade is Bronze
+    if (options.cliFlags?.skipLighthouse) {
+        // Effectively disables Lighthouse grading
+    }
+    return { ...config, ciMode };
+}

package/dist/detect.d.ts

@@ -0,0 +1,10 @@
+export type Framework = "nextjs" | "vite" | "cra" | "sveltekit";
+export type PackageManager = "npm" | "pnpm" | "yarn" | "bun";
+export interface DetectResult {
+    framework: Framework | null;
+    packageManager: PackageManager;
+    buildCmd: string;
+    devCmd: string;
+    port: number;
+}
+export declare function detect(dir: string): DetectResult;

package/dist/detect.js

@@ -0,0 +1,97 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+const FRAMEWORK_DEFAULT_PORTS = {
+    nextjs: 3000,
+    vite: 5173,
+    cra: 3000,
+    sveltekit: 5173,
+};
+function detectPackageManager(dir) {
+    if (fs.existsSync(path.join(dir, "pnpm-lock.yaml")))
+        return "pnpm";
+    if (fs.existsSync(path.join(dir, "yarn.lock")))
+        return "yarn";
+    if (fs.existsSync(path.join(dir, "bun.lockb")) ||
+        fs.existsSync(path.join(dir, "bun.lock")))
+        return "bun";
+    return "npm";
+}
+function detectFramework(packageJson) {
+    const allDeps = {
+        ...(packageJson.dependencies ?? {}),
+        ...(packageJson.devDependencies ?? {}),
+    };
+    const scripts = packageJson.scripts ?? {};
+    const startScript = scripts.start ?? scripts.dev ?? "";
+    if (allDeps["next"])
+        return "nextjs";
+    if (allDeps["@sveltejs/kit"] || allDeps["svelte-kit"])
+        return "sveltekit";
+    // CRA: react-scripts or @craco/craco with react-scripts
+    if (allDeps["react-scripts"])
+        return "cra";
+    // Vite
+    if (allDeps["vite"])
+        return "vite";
+    // Fallback: check start script heuristics
+    if (startScript.includes("next"))
+        return "nextjs";
+    if (startScript.includes("vite"))
+        return "vite";
+    if (startScript.includes("react-scripts"))
+        return "cra";
+    return null;
+}
+function getBuildCommand(framework, packageManager, scripts) {
+    if (scripts.build) {
+        const pmRun = packageManager === "npm" ? "npm run" : packageManager;
+        return `${pmRun} build`;
+    }
+    // Framework defaults
+    const pmRun = packageManager === "npm" ? "npm run" : packageManager;
+    return `${pmRun} build`;
+}
+function getDevCommand(framework, packageManager, scripts) {
+    const pmRun = packageManager === "npm" ? "npm run" : packageManager;
+    if (scripts.dev)
+        return `${pmRun} dev`;
+    if (scripts.start)
+        return `${pmRun} start`;
+    if (scripts.serve)
+        return `${pmRun} serve`;
+    // Framework defaults
+    switch (framework) {
+        case "nextjs":
+            return "next dev";
+        case "vite":
+            return "vite";
+        case "cra":
+            return "react-scripts start";
+        case "sveltekit":
+            return "vite dev";
+    }
+    return `${pmRun} dev`;
+}
+export function detect(dir) {
+    const pkgPath = path.join(dir, "package.json");
+    if (!fs.existsSync(pkgPath)) {
+        throw new Error(`Not a Node.js project: no package.json found at ${pkgPath}`);
+    }
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+    if (!pkg.scripts || !pkg.scripts.build) {
+        throw new Error("No 'build' script found in package.json");
+    }
+    const framework = detectFramework(pkg);
+    const packageManager = detectPackageManager(dir);
+    const scripts = pkg.scripts ?? {};
+    const buildCmd = getBuildCommand(framework, packageManager, scripts);
+    const devCmd = getDevCommand(framework, packageManager, scripts);
+    const defaultPort = framework ? FRAMEWORK_DEFAULT_PORTS[framework] : 3000;
+    return {
+        framework,
+        packageManager,
+        buildCmd,
+        devCmd,
+        port: defaultPort,
+    };
+}

package/dist/github.d.ts

@@ -0,0 +1,8 @@
+export interface GitHubContext {
+    token: string;
+    repository: string;
+    sha: string;
+    eventPath?: string;
+    eventName: string;
+}
+export declare function getGitHubContext(): GitHubContext | null;

package/dist/github.js

@@ -0,0 +1,11 @@
+export function getGitHubContext() {
+    const token = process.env.GITHUB_TOKEN;
+    const repository = process.env.GITHUB_REPOSITORY;
+    const sha = process.env.GITHUB_SHA;
+    const eventPath = process.env.GITHUB_EVENT_PATH;
+    const eventName = process.env.GITHUB_EVENT_NAME ?? "";
+    if (!token || !repository || !sha) {
+        return null;
+    }
+    return { token, repository, sha, eventPath, eventName };
+}

package/dist/grade.d.ts

@@ -0,0 +1,37 @@
+export type VerificationGrade = "gold" | "silver" | "bronze" | "unverified";
+export interface LighthouseScores {
+    performance: number;
+    accessibility: number;
+    bestPractices: number;
+    seo: number;
+}
+export declare function getLighthousePass(scores: LighthouseScores, thresholds: {
+    performance: number;
+    accessibility: number;
+    seo: number;
+    bestPractices: number;
+}): boolean;
+export declare function isWorseOrEqual(actual: VerificationGrade, threshold: VerificationGrade): boolean;
+interface GradeResult {
+    grade: VerificationGrade;
+    exitCode: number;
+}
+export declare function calculateGrade(options: {
+    buildSuccess: boolean;
+    scores?: LighthouseScores;
+    thresholds: {
+        performance: number;
+        accessibility: number;
+        seo: number;
+        bestPractices: number;
+    };
+    failOn: VerificationGrade;
+}): GradeResult;
+export declare function gradeToColor(grade: VerificationGrade): {
+    text: string;
+    bg: string;
+    border: string;
+    hex: string;
+};
+export declare function gradeToLabel(grade: VerificationGrade): string;
+export {};

package/dist/grade.js

@@ -0,0 +1,57 @@
+const GRADE_ORDER = ["gold", "silver", "bronze", "unverified"];
+export function getLighthousePass(scores, thresholds) {
+    return (scores.performance >= thresholds.performance &&
+        scores.accessibility >= thresholds.accessibility &&
+        scores.seo >= thresholds.seo &&
+        scores.bestPractices >= thresholds.bestPractices);
+}
+export function isWorseOrEqual(actual, threshold) {
+    // Returns true if actual is worse than threshold
+    // Grade order (best to worst): gold, silver, bronze, unverified
+    return GRADE_ORDER.indexOf(actual) > GRADE_ORDER.indexOf(threshold);
+}
+export function calculateGrade(options) {
+    const { buildSuccess, scores, thresholds, failOn } = options;
+    let grade;
+    if (!buildSuccess) {
+        grade = "unverified";
+    }
+    else if (scores && getLighthousePass(scores, thresholds)) {
+        grade = "silver";
+    }
+    else if (buildSuccess) {
+        grade = "bronze";
+    }
+    else {
+        grade = "unverified";
+    }
+    // Determine exit code
+    // fail_on: unverified means "never fail" (informational only)
+    // any other fail_on: exit 1 if grade is worse than fail_on
+    const exitCode = failOn === "unverified"
+        ? 0
+        : isWorseOrEqual(grade, failOn)
+            ? 1
+            : 0;
+    return { grade, exitCode };
+}
+export function gradeToColor(grade) {
+    switch (grade) {
+        case "gold":
+            return { text: "text-yellow-400", bg: "bg-yellow-400/10", border: "border-yellow-400/30", hex: "#FACC15" };
+        case "silver":
+            return { text: "text-emerald-400", bg: "bg-emerald-400/10", border: "border-emerald-400/30", hex: "#34D399" };
+        case "bronze":
+            return { text: "text-blue-400", bg: "bg-blue-400/10", border: "border-blue-400/30", hex: "#60A5FA" };
+        default:
+            return { text: "text-gray-400", bg: "bg-gray-500/5", border: "border-gray-500/30", hex: "#9CA3AF" };
+    }
+}
+export function gradeToLabel(grade) {
+    return {
+        gold: "Gold",
+        silver: "Silver",
+        bronze: "Bronze",
+        unverified: "Unverified",
+    }[grade];
+}

package/dist/init.d.ts

@@ -0,0 +1 @@
+export declare function runInit(dir: string): void;

package/dist/init.js

@@ -0,0 +1,85 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { detect } from "./detect.js";
+export function runInit(dir) {
+    const laxyYmlPath = path.join(dir, ".laxy.yml");
+    const workflowDir = path.join(dir, ".github", "workflows");
+    const workflowPath = path.join(workflowDir, "laxy-verify.yml");
+    const gitignorePath = path.join(dir, ".gitignore");
+    // 1. Generate .laxy.yml
+    if (fs.existsSync(laxyYmlPath)) {
+        console.log(".laxy.yml already exists — skipping. Delete it to regenerate.");
+    }
+    else {
+        let detectedFramework = null;
+        let detectedPort = 3000;
+        try {
+            const detected = detect(dir);
+            detectedFramework = detected.framework ?? "auto";
+            detectedPort = detected.port;
+        }
+        catch {
+            // ignore, default to auto
+        }
+        const ymlContent = `# Generated by laxy-verify --init
+# See https://github.com/psungmin24/laxy-verify for full docs
+framework: ${detectedFramework}   # auto-detected
+port: ${detectedPort}
+fail_on: bronze
+
+thresholds:
+  performance: 70
+  accessibility: 85
+  seo: 80
+  best_practices: 80
+`;
+        fs.writeFileSync(laxyYmlPath, ymlContent, "utf-8");
+        console.log("Created .laxy.yml");
+    }
+    // 2. Generate workflow file
+    if (fs.existsSync(workflowPath)) {
+        console.log(".github/workflows/laxy-verify.yml already exists — skipping.");
+    }
+    else {
+        fs.mkdirSync(workflowDir, { recursive: true });
+        const workflowContent = `name: Laxy Verify
+on:
+  pull_request:
+    branches: [main, master]
+  push:
+    branches: [main, master]
+
+permissions:
+  pull-requests: write
+  statuses: write
+
+jobs:
+  verify:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: psungmin24/laxy-verify@v1
+        with:
+          github-token: \${{ secrets.GITHUB_TOKEN }}
+`;
+        fs.writeFileSync(workflowPath, workflowContent, "utf-8");
+        console.log("Created .github/workflows/laxy-verify.yml");
+    }
+    // 3. Append to .gitignore
+    const gitignoreEntries = [".lighthouseci/", ".laxy-result.json"];
+    if (fs.existsSync(gitignorePath)) {
+        const existing = fs.readFileSync(gitignorePath, "utf-8");
+        const lines = existing.split("\n").map(l => l.trim());
+        const missing = gitignoreEntries.filter(e => !lines.includes(e));
+        if (missing.length > 0) {
+            const append = missing.join("\n") + "\n";
+            fs.appendFileSync(gitignorePath, append, "utf-8");
+            console.log(`Appended to .gitignore: ${missing.join(", ")}`);
+        }
+    }
+    else {
+        fs.writeFileSync(gitignorePath, gitignoreEntries.join("\n") + "\n", "utf-8");
+        console.log("Created .gitignore");
+    }
+    console.log("\n Done! Run 'npx laxy-verify .' to verify your project.");
+}

package/dist/lighthouse.d.ts

@@ -0,0 +1,7 @@
+import type { LighthouseScores } from "./grade.js";
+interface LhResult {
+    scores: LighthouseScores | null;
+    errors: string[];
+}
+export declare function runLighthouse(port: number, runs: number): Promise<LhResult>;
+export {};

package/dist/lighthouse.js

@@ -0,0 +1,94 @@
+import { spawn } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { createRequire } from "node:module";
+const req = createRequire(import.meta.url);
+function resolveLhciBin() {
+    try {
+        return req.resolve("@lhci/cli/src/cli.js");
+    }
+    catch {
+        throw new Error("@lhci/cli not found — make sure it is installed in laxy-verify's node_modules");
+    }
+}
+function median(values) {
+    const sorted = [...values].sort((a, b) => a - b);
+    const mid = Math.floor(sorted.length / 2);
+    return sorted.length % 2 !== 0
+        ? sorted[mid]
+        : (sorted[mid - 1] + sorted[mid]) / 2;
+}
+export async function runLighthouse(port, runs) {
+    const lhciBin = resolveLhciBin();
+    console.log(`\n Running Lighthouse (${runs} run${runs > 1 ? "s" : ""})…`);
+    const lhciDir = ".lighthouseci";
+    if (!fs.existsSync(lhciDir)) {
+        fs.mkdirSync(lhciDir, { recursive: true });
+    }
+    const child = spawn("node", [
+        lhciBin,
+        "collect",
+        `--url=http://localhost:${port}`,
+        `--numberOfRuns=${runs}`,
+        `--outputDir=${lhciDir}`,
+    ], { shell: false, stdio: ["ignore", "pipe", "pipe"] });
+    const errors = [];
+    child.stdout?.on("data", (chunk) => {
+        const lines = chunk.toString().split("\n").filter(Boolean);
+        for (const line of lines)
+            console.log(`  [lhci] ${line}`);
+    });
+    child.stderr?.on("data", (chunk) => {
+        const lines = chunk.toString().split("\n").filter(Boolean);
+        errors.push(...lines);
+        for (const line of lines)
+            console.error(`  [lhci] ${line}`);
+    });
+    const exitCode = await new Promise((resolve) => {
+        child.on("exit", (code) => resolve(code ?? 1));
+    });
+    if (exitCode !== 0) {
+        console.error("  Lighthouse exited with an error");
+        return { scores: null, errors };
+    }
+    // Extract median scores from .lighthouseci/lhr-*.json
+    try {
+        if (!fs.existsSync(lhciDir)) {
+            return { scores: null, errors: ["No .lighthouseci/ directory found"] };
+        }
+        const lhrFiles = fs
+            .readdirSync(lhciDir)
+            .filter((f) => f.startsWith("lhr-") && f.endsWith(".json"));
+        if (lhrFiles.length === 0) {
+            return { scores: null, errors: ["No lhr JSON files found in .lighthouseci/"] };
+        }
+        const allScores = lhrFiles.map((f) => {
+            const report = JSON.parse(fs.readFileSync(path.join(lhciDir, f), "utf8"));
+            return {
+                performance: (report.categories.performance?.score ?? 0) * 100,
+                accessibility: (report.categories.accessibility?.score ?? 0) * 100,
+                seo: (report.categories.seo?.score ?? 0) * 100,
+                bestPractices: (report.categories["best-practices"]?.score ?? 0) * 100,
+            };
+        });
+        const scores = {
+            performance: Math.round(median(allScores.map((s) => s.performance))),
+            accessibility: Math.round(median(allScores.map((s) => s.accessibility))),
+            seo: Math.round(median(allScores.map((s) => s.seo))),
+            bestPractices: Math.round(median(allScores.map((s) => s.bestPractices))),
+        };
+        console.log(`  Lighthouse median: P=${scores.performance} A=${scores.accessibility} S=${scores.seo} BP=${scores.bestPractices}`);
+        return { scores, errors: [] };
+    }
+    finally {
+        // Cleanup .lighthouseci/
+        try {
+            if (fs.existsSync(lhciDir)) {
+                fs.rmSync(lhciDir, { recursive: true, force: true });
+            }
+        }
+        catch {
+            // ignore cleanup errors
+        }
+    }
+}

package/dist/serve.d.ts

@@ -0,0 +1,12 @@
+export declare class PortConflictError extends Error {
+    constructor(port: number);
+}
+export declare class DevServerTimeoutError extends Error {
+    constructor(port: number, timeoutSec: number);
+}
+export interface ServeResult {
+    pid: number;
+    port: number;
+}
+export declare function startDevServer(command: string, port: number, timeoutSec: number): Promise<ServeResult>;
+export declare function stopDevServer(pid: number): void;