@evalgate/sdk 2.0.0

package/dist/cli/index.js

@@ -0,0 +1,332 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * evalgate — EvalGate CLI
+ *
+ * Commands:
+ *   evalgate init   — Create evalgate.config.json
+ *   evalgate check  — CI/CD evaluation gate (see evalgate check --help)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const baseline_1 = require("./baseline");
+const check_1 = require("./check");
+const ci_1 = require("./ci");
+const diff_1 = require("./diff");
+const discover_1 = require("./discover");
+const doctor_1 = require("./doctor");
+const explain_1 = require("./explain");
+const impact_analysis_1 = require("./impact-analysis");
+const init_1 = require("./init");
+const migrate_1 = require("./migrate");
+const print_config_1 = require("./print-config");
+const regression_gate_1 = require("./regression-gate");
+const run_1 = require("./run");
+const share_1 = require("./share");
+const upgrade_1 = require("./upgrade");
+const argv = process.argv.slice(2);
+const subcommand = argv[0];
+if (subcommand === "init") {
+    const cwd = process.cwd();
+    const ok = (0, init_1.runInit)(cwd);
+    process.exit(ok ? 0 : 1);
+}
+else if (subcommand === "baseline") {
+    const code = (0, baseline_1.runBaseline)(argv.slice(1));
+    process.exit(code);
+}
+else if (subcommand === "gate") {
+    const code = (0, regression_gate_1.runGate)(argv.slice(1));
+    process.exit(code);
+}
+else if (subcommand === "migrate") {
+    // Handle migrate subcommand
+    const migrateSubcommand = argv[1];
+    if (migrateSubcommand === "config") {
+        // Parse migrate config arguments
+        let inputPath = "";
+        let outputPath = "";
+        let verbose = false;
+        let helpers = true;
+        let preserveIds = true;
+        let provenance = true;
+        for (let i = 2; i < argv.length; i++) {
+            const arg = argv[i];
+            if (arg === "--in" || arg === "-i") {
+                inputPath = argv[++i];
+            }
+            else if (arg === "--out" || arg === "-o") {
+                outputPath = argv[++i];
+            }
+            else if (arg === "--verbose" || arg === "-v") {
+                verbose = true;
+            }
+            else if (arg === "--no-helpers") {
+                helpers = false;
+            }
+            else if (arg === "--no-preserve-ids") {
+                preserveIds = false;
+            }
+            else if (arg === "--no-provenance") {
+                provenance = false;
+            }
+        }
+        if (!inputPath || !outputPath) {
+            console.error("Error: Both --in and --out options are required");
+            console.error("Usage: evalgate migrate config --in <input> --out <output> [options]");
+            process.exit(1);
+        }
+        (0, migrate_1.migrateConfig)({
+            input: inputPath,
+            output: outputPath,
+            verbose,
+            helpers,
+            preserveIds,
+            provenance,
+        }).catch((err) => {
+            console.error(`Migration failed: ${err instanceof Error ? err.message : String(err)}`);
+            process.exit(1);
+        });
+    }
+    else {
+        console.error("Error: Unknown migrate subcommand. Use 'evalgate migrate config'");
+        process.exit(1);
+    }
+}
+else if (subcommand === "upgrade") {
+    const code = (0, upgrade_1.runUpgrade)(argv.slice(1));
+    process.exit(code);
+}
+else if (subcommand === "doctor") {
+    (0, doctor_1.runDoctor)(argv.slice(1))
+        .then((code) => process.exit(code))
+        .catch((err) => {
+        console.error(`EvalGate ERROR: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
+    });
+}
+else if (subcommand === "check") {
+    const parsed = (0, check_1.parseArgs)(argv.slice(1));
+    if (!parsed.ok) {
+        console.error(parsed.message);
+        process.exit(parsed.exitCode);
+    }
+    (0, check_1.runCheck)(parsed.args)
+        .then((code) => process.exit(code))
+        .catch((err) => {
+        console.error(`EvalGate ERROR: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(4);
+    });
+}
+else if (subcommand === "explain") {
+    (0, explain_1.runExplain)(argv.slice(1))
+        .then((code) => process.exit(code))
+        .catch((err) => {
+        console.error(`EvalGate ERROR: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
+    });
+}
+else if (subcommand === "print-config") {
+    const code = (0, print_config_1.runPrintConfig)(argv.slice(1));
+    process.exit(code);
+}
+else if (subcommand === "share") {
+    const parsed = (0, share_1.parseShareArgs)(argv.slice(1));
+    if ("error" in parsed) {
+        console.error(parsed.error);
+        process.exit(1);
+    }
+    (0, share_1.runShare)(parsed)
+        .then((code) => process.exit(code))
+        .catch((err) => {
+        console.error(`EvalGate ERROR: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
+    });
+}
+else if (subcommand === "discover") {
+    // Parse arguments for discover command
+    const args = argv.slice(1);
+    const manifestFlag = args.includes("--manifest");
+    (0, discover_1.discoverSpecs)({ manifest: manifestFlag })
+        .then(() => process.exit(0))
+        .catch((err) => {
+        console.error(`EvalGate ERROR: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
+    });
+}
+else if (subcommand === "impact-analysis") {
+    // Parse arguments for impact-analysis command
+    const args = argv.slice(1);
+    const baseIndex = args.indexOf("--base");
+    const changedFilesIndex = args.indexOf("--changed-files");
+    const formatIndex = args.indexOf("--format");
+    const baseBranch = baseIndex !== -1 ? args[baseIndex + 1] : "main";
+    const changedFiles = changedFilesIndex !== -1
+        ? args[changedFilesIndex + 1]?.split(",")
+        : undefined;
+    const format = formatIndex !== -1 ? args[formatIndex + 1] : "human";
+    (0, impact_analysis_1.runImpactAnalysisCLI)({ baseBranch, changedFiles, format })
+        .then(() => process.exit(0))
+        .catch((err) => {
+        console.error(`EvalGate ERROR: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(2);
+    });
+}
+else if (subcommand === "run") {
+    // Parse arguments for run command
+    const args = argv.slice(1);
+    const specIdsIndex = args.indexOf("--spec-ids");
+    const impactedOnlyIndex = args.indexOf("--impacted-only");
+    const baseIndex = args.indexOf("--base");
+    const formatIndex = args.indexOf("--format");
+    const writeResultsIndex = args.indexOf("--write-results");
+    const specIds = specIdsIndex !== -1 ? args[specIdsIndex + 1]?.split(",") : undefined;
+    const impactedOnly = impactedOnlyIndex !== -1;
+    const baseBranch = baseIndex !== -1 ? args[baseIndex + 1] : undefined;
+    const format = formatIndex !== -1 ? args[formatIndex + 1] : "human";
+    const writeResults = writeResultsIndex !== -1;
+    (0, run_1.runEvaluationsCLI)({
+        specIds,
+        impactedOnly: impactedOnly ? !!baseBranch : false,
+        baseBranch,
+        format,
+        writeResults,
+    })
+        .then(() => process.exit(0))
+        .catch((err) => {
+        console.error(`EvalGate ERROR: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(2);
+    });
+}
+else if (subcommand === "diff") {
+    // Parse arguments for diff command
+    const args = argv.slice(1);
+    const baseIndex = args.indexOf("--base");
+    const headIndex = args.indexOf("--head");
+    const formatIndex = args.indexOf("--format");
+    const base = baseIndex !== -1 ? args[baseIndex + 1] : undefined;
+    const head = headIndex !== -1 ? args[headIndex + 1] : undefined;
+    const format = formatIndex !== -1 ? args[formatIndex + 1] : "human";
+    (0, diff_1.runDiffCLI)({ base, head, format })
+        .then(() => process.exit(0))
+        .catch((err) => {
+        console.error(`EvalGate ERROR: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(2);
+    });
+}
+else if (subcommand === "ci") {
+    // Parse arguments for ci command
+    const args = argv.slice(1);
+    const baseIndex = args.indexOf("--base");
+    const impactedOnlyIndex = args.indexOf("--impacted-only");
+    const formatIndex = args.indexOf("--format");
+    const writeResultsIndex = args.indexOf("--write-results");
+    const base = baseIndex !== -1 ? args[baseIndex + 1] : undefined;
+    const impactedOnly = impactedOnlyIndex !== -1;
+    const format = formatIndex !== -1
+        ? args[formatIndex + 1]
+        : "human";
+    const writeResults = writeResultsIndex !== -1;
+    (0, ci_1.runCICLI)({ base, impactedOnly, format, writeResults })
+        .then(() => process.exit(0))
+        .catch((err) => {
+        console.error(`EvalGate ERROR: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(2);
+    });
+}
+else {
+    console.log(`EvalGate CLI
+
+Usage:
+  evalgate init                Create evalgate.config.json + baseline + CI workflow
+  evalgate discover            Discover behavioral specs in project and show statistics
+  evalgate discover --manifest  Generate evaluation manifest for incremental analysis
+  evalgate impact-analysis     Analyze impact of changes and suggest targeted tests
+    --base <branch>          Base branch to compare against (default: main)
+    --changed-files <files>  Comma-separated list of changed files (for CI)
+    --format <fmt>           Output format: human (default), json
+  evalgate ci                  One-command CI loop (manifest → impact → run → diff)
+    --base <ref>            Base reference for diff (baseline|last|<runId>|<path>|<gitref>)
+    --impacted-only          Run only specs impacted by changes
+    --format <fmt>           Output format: human (default), json, github
+    --write-results          Write run results to .evalgate/last-run.json
+  evalgate run                 Run evaluation specifications
+    --spec-ids <ids>         Comma-separated list of spec IDs to run
+    --impacted-only          Run only specs impacted by changes (requires --base)
+    --base <branch>          Base branch for impact analysis (with --impacted-only)
+    --format <fmt>           Output format: human (default), json
+    --write-results          Write results to .evalgate/last-run.json
+  evalgate diff                Compare two run reports and show behavioral changes
+    --base <branch>          Base branch or report path (default: main)
+    --head <path>            Head report path (default: .evalgate/last-run.json)
+    --format <fmt>           Output format: human (default), json
+  evalgate gate [options]      Run regression gate (local test-based, no API needed)
+  evalgate check [options]     CI/CD evaluation gate (API-based)
+  evalgate explain [options]   Explain last gate/check failure with root causes + fixes
+  evalgate doctor [options]    Comprehensive CI/CD readiness checklist
+  evalgate baseline init       Create starter evals/baseline.json
+  evalgate baseline update     Run tests and update baseline with real scores
+  evalgate upgrade --full      Upgrade from Tier 1 to Tier 2 (full gate)
+  evalgate print-config        Show resolved config with source-of-truth annotations
+  evalgate share [options]     Create share link for a run
+
+Options for gate:
+  --format <fmt>      Output format: human (default), json, github
+
+Options for check:
+  --evaluationId <id>  Evaluation to gate on (or from config)
+  --apiKey <key>      API key (or EVALAI_API_KEY env)
+  --format <fmt>      Output format: human (default), json, github
+  --explain           Show score breakdown and thresholds
+  --onFail import     When gate fails, import run with CI context
+  --minScore <n>      Fail if score < n (0-100)
+  --maxDrop <n>       Fail if score dropped > n from baseline
+  --warnDrop <n>      Warn (exit 8) if score dropped > n but < maxDrop
+  --minN <n>          Fail if total test cases < n
+  --allowWeakEvidence Allow weak evidence level
+  --policy <name>     Enforce policy (HIPAA, SOC2, GDPR, etc.)
+  --baseline <mode>   "published", "previous", or "production"
+  --share <mode>      Share link: always | fail | never (fail = only when gate fails)
+  --baseUrl <url>     API base URL
+
+Options for explain:
+  --report <path>     Path to report JSON (default: evals/regression-report.json)
+  --format <fmt>      Output format: human (default), json
+
+Options for print-config:
+  --format <fmt>      Output format: human (default), json
+
+Options for doctor:
+  --report            Output JSON diagnostic bundle
+  --format <fmt>      Output format: human (default), json
+  --strict            Treat warnings as failures (exit 2)
+  --apiKey <key>      API key (or EVALAI_API_KEY env)
+  --baseUrl <url>     API base URL
+  --evaluationId <id> Evaluation to verify
+
+Examples:
+  evalgate init
+  evalgate discover
+  evalgate discover --manifest
+  evalgate impact-analysis --base main
+  evalgate impact-analysis --base main --format json
+  evalgate impact-analysis --changed-files src/utils.ts,datasets/test.json
+  evalgate run
+  evalgate run --spec-ids spec1,spec2
+  evalgate run --impacted-only --base main
+  evalgate run --format json --write-results
+  evalgate diff
+  evalgate diff --base main
+  evalgate diff --base main --format json
+  evalgate diff --a .evalgate/runs/base.json --b .evalgate/last-run.json
+  evalgate gate
+  evalgate gate --format json
+  evalgate explain
+  evalgate doctor
+  evalgate print-config
+  evalgate doctor --report
+  evalgate check --minScore 92 --evaluationId 42 --apiKey $EVALAI_API_KEY
+  evalgate check --policy HIPAA --evaluationId 42 --apiKey $EVALAI_API_KEY
+  evalgate share --scope run --evaluationId 42 --runId 123 --expires 7d --apiKey $EVALAI_API_KEY
+`);
+    process.exit(subcommand === "--help" || subcommand === "-h" ? 0 : 1);
+}

package/dist/cli/init.d.ts

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+/**
+ * evalgate init — Full project scaffolder
+ *
+ * Zero-to-gate in under 5 minutes:
+ *   npx evalgate init
+ *   git push
+ *   …CI starts blocking regressions.
+ *
+ * What it does:
+ *   1. Detects Node repo + package manager
+ *   2. Creates evals/ directory + baseline.json
+ *   3. Installs .github/workflows/evalgate-gate.yml
+ *   4. Prints next steps (no docs required)
+ */
+export declare function runInit(cwd?: string): boolean;

package/dist/cli/init.js

@@ -0,0 +1,292 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * evalgate init — Full project scaffolder
+ *
+ * Zero-to-gate in under 5 minutes:
+ *   npx evalgate init
+ *   git push
+ *   …CI starts blocking regressions.
+ *
+ * What it does:
+ *   1. Detects Node repo + package manager
+ *   2. Creates evals/ directory + baseline.json
+ *   3. Installs .github/workflows/evalgate-gate.yml
+ *   4. Prints next steps (no docs required)
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runInit = runInit;
+const node_child_process_1 = require("node:child_process");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+function detectProject(cwd) {
+    const pkgPath = path.join(cwd, "package.json");
+    if (!fs.existsSync(pkgPath))
+        return null;
+    let pkg;
+    try {
+        pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+    let pm = "npm";
+    if (fs.existsSync(path.join(cwd, "pnpm-lock.yaml")))
+        pm = "pnpm";
+    else if (fs.existsSync(path.join(cwd, "yarn.lock")))
+        pm = "yarn";
+    const testScript = pkg.scripts?.test ?? "";
+    const hasTestScript = !!testScript && testScript !== 'echo "Error: no test specified" && exit 1';
+    return {
+        cwd,
+        pm,
+        hasTestScript,
+        testScript,
+        name: pkg.name ?? path.basename(cwd),
+    };
+}
+// ── Step helpers ──
+function ok(msg) {
+    console.log(`  ✔ ${msg}`);
+}
+function skip(msg) {
+    console.log(`  – ${msg}`);
+}
+// ── 1. Create evals/ + baseline.json ──
+function createBaseline(cwd, project) {
+    const evalsDir = path.join(cwd, "evals");
+    const baselinePath = path.join(evalsDir, "baseline.json");
+    if (fs.existsSync(baselinePath)) {
+        skip("evals/baseline.json already exists");
+        return true;
+    }
+    if (!fs.existsSync(evalsDir)) {
+        fs.mkdirSync(evalsDir, { recursive: true });
+    }
+    const user = process.env.USER || process.env.USERNAME || "unknown";
+    const now = new Date().toISOString();
+    // Run tests to capture real count if possible
+    let testTotal = 0;
+    let testsPassed = true;
+    if (project.hasTestScript) {
+        const isWin = process.platform === "win32";
+        const result = (0, node_child_process_1.spawnSync)(project.pm, ["test"], {
+            cwd,
+            stdio: "pipe",
+            shell: isWin,
+            timeout: 120000,
+        });
+        testsPassed = result.status === 0;
+        // Try to extract test count from output
+        const output = (result.stdout?.toString() ?? "") + (result.stderr?.toString() ?? "");
+        const countMatch = output.match(/(\d+)\s+(?:tests?|specs?)\s+(?:passed|completed)/i) ??
+            output.match(/Tests:\s+(\d+)\s+passed/i) ??
+            output.match(/(\d+)\s+passing/i);
+        if (countMatch)
+            testTotal = parseInt(countMatch[1], 10);
+    }
+    const baseline = {
+        schemaVersion: 1,
+        description: `Regression gate baseline for ${project.name}`,
+        generatedAt: now,
+        generatedBy: user,
+        commitSha: getHeadSha(cwd),
+        updatedAt: now,
+        updatedBy: user,
+        tolerance: {
+            scoreDrop: 5,
+            passRateDrop: 5,
+            maxLatencyIncreaseMs: 200,
+            maxCostIncreaseUsd: 0.05,
+        },
+        goldenEval: {
+            score: 100,
+            passRate: 100,
+            totalCases: 3,
+            passedCases: 3,
+        },
+        confidenceTests: {
+            passed: testsPassed,
+            total: testTotal,
+        },
+        productMetrics: {},
+    };
+    fs.writeFileSync(baselinePath, `${JSON.stringify(baseline, null, 2)}\n`);
+    ok("Created evals/baseline.json");
+    return true;
+}
+function getHeadSha(cwd) {
+    try {
+        const result = (0, node_child_process_1.spawnSync)("git", ["rev-parse", "--short", "HEAD"], {
+            cwd,
+            stdio: "pipe",
+        });
+        return result.stdout?.toString().trim() || "0000000";
+    }
+    catch {
+        return "0000000";
+    }
+}
+// ── 2. Install GitHub Actions workflow ──
+function installWorkflow(cwd, project) {
+    const workflowDir = path.join(cwd, ".github", "workflows");
+    const workflowPath = path.join(workflowDir, "evalgate-gate.yml");
+    if (fs.existsSync(workflowPath)) {
+        skip(".github/workflows/evalgate-gate.yml already exists");
+        return true;
+    }
+    if (!fs.existsSync(workflowDir)) {
+        fs.mkdirSync(workflowDir, { recursive: true });
+    }
+    const installCmd = project.pm === "pnpm"
+        ? "pnpm install --frozen-lockfile"
+        : project.pm === "yarn"
+            ? "yarn install --frozen-lockfile"
+            : "npm ci";
+    const setupSteps = project.pm === "pnpm"
+        ? `      - uses: pnpm/action-setup@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          cache: pnpm
+      - run: ${installCmd}`
+        : `      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          cache: ${project.pm}
+      - run: ${installCmd}`;
+    const workflow = `# EvalGate Regression Gate
+# Auto-generated by: npx evalgate init
+# Blocks PRs that regress test health.
+name: EvalGate Gate
+
+on:
+  pull_request:
+    branches: [main]
+
+concurrency:
+  group: evalgate-\${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  regression-gate:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+${setupSteps}
+      - name: EvalGate Doctor (preflight)
+        continue-on-error: true  # Strict: set to false, or use: evalgate doctor --strict
+        run: npx -y @evalgate/sdk@^2 doctor
+
+      - name: EvalGate Regression Gate
+        run: npx -y @evalgate/sdk@^2 gate --format github
+
+      - name: Upload report
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: evalgate-report
+          path: |
+            evals/regression-report.json
+            .evalgate/last-report.json
+          if-no-files-found: ignore
+`;
+    fs.writeFileSync(workflowPath, workflow);
+    ok("Created .github/workflows/evalgate-gate.yml");
+    return true;
+}
+// ── 3. Create evalgate.config.json ──
+function createConfig(cwd) {
+    const configPath = path.join(cwd, "evalgate.config.json");
+    if (fs.existsSync(configPath)) {
+        skip("evalgate.config.json already exists");
+        return true;
+    }
+    const config = {
+        evaluationId: "",
+        gate: {
+            baseline: "evals/baseline.json",
+            report: "evals/regression-report.json",
+        },
+    };
+    fs.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`);
+    ok("Created evalgate.config.json");
+    return true;
+}
+// ── Main ──
+function runInit(cwd = process.cwd()) {
+    console.log("");
+    console.log("  evalgate init — setting up regression gate\n");
+    // Detect
+    const project = detectProject(cwd);
+    if (!project) {
+        console.error("  ✖ No package.json found. Run this from a Node.js project root.");
+        return false;
+    }
+    ok(`Detected ${project.pm} project: ${project.name}`);
+    if (!project.hasTestScript) {
+        console.log(`  ⚠ No test script found in package.json`);
+        console.log(`    The gate will still work — add a "test" script later for full coverage.\n`);
+    }
+    // Scaffold
+    createBaseline(cwd, project);
+    installWorkflow(cwd, project);
+    createConfig(cwd);
+    // Next steps
+    console.log("");
+    console.log("  Done! Next:");
+    console.log("");
+    console.log("    npx evalgate doctor             Verify your setup is complete");
+    console.log("");
+    console.log("  Then commit:");
+    console.log("");
+    console.log("    git add evals/ .github/workflows/evalgate-gate.yml evalgate.config.json");
+    console.log("    git commit -m 'chore: add EvalGate regression gate'");
+    console.log("    git push");
+    console.log("");
+    console.log("  That's it. Open a PR and the gate runs automatically.");
+    console.log("");
+    console.log("  Commands:");
+    console.log("    npx evalgate doctor             Preflight check — verify config, baseline, CI");
+    console.log("    npx evalgate gate               Run regression gate locally");
+    console.log("    npx evalgate check              API-based gate (requires account)");
+    console.log("    npx evalgate explain            Explain last failure with root causes + fixes");
+    console.log("    npx evalgate baseline update    Update baseline after intentional changes");
+    console.log("");
+    console.log("  To remove: delete evals/, evalgate.config.json, and .github/workflows/evalgate-gate.yml");
+    console.log("");
+    return true;
+}