@pauly4010/evalai-sdk 1.4.1 → 1.5.5

package/dist/cli/config.js

@@ -0,0 +1,207 @@
+"use strict";
+/**
+ * EvalAI config loader
+ * Discovery: evalai.config.json → evalai.config.js → evalai.config.cjs → package.json evalai
+ */
+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.findConfigPath = findConfigPath;
+exports.loadConfig = loadConfig;
+exports.mergeConfigWithArgs = mergeConfigWithArgs;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const profiles_1 = require("./profiles");
+const CONFIG_FILES = ["evalai.config.json", "evalai.config.js", "evalai.config.cjs"];
+/**
+ * Find config file path in directory, walking up to root
+ */
+function findConfigPath(cwd = process.cwd()) {
+    let dir = path.resolve(cwd);
+    const root = path.parse(dir).root;
+    while (dir !== root) {
+        for (const file of CONFIG_FILES) {
+            const filePath = path.join(dir, file);
+            if (fs.existsSync(filePath)) {
+                return filePath;
+            }
+        }
+        // Check package.json for evalai field
+        const pkgPath = path.join(dir, "package.json");
+        if (fs.existsSync(pkgPath)) {
+            try {
+                const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+                if (pkg.evalai != null) {
+                    return pkgPath;
+                }
+            }
+            catch {
+                // ignore
+            }
+        }
+        dir = path.dirname(dir);
+    }
+    return null;
+}
+/**
+ * Load config from file system
+ */
+function loadConfig(cwd = process.cwd()) {
+    const configPath = findConfigPath(cwd);
+    if (!configPath)
+        return null;
+    try {
+        let config = null;
+        if (configPath.endsWith("package.json")) {
+            const pkg = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+            config = pkg.evalai ?? null;
+        }
+        else {
+            const content = fs.readFileSync(configPath, "utf-8");
+            if (configPath.endsWith(".json")) {
+                config = JSON.parse(content);
+            }
+            else if (configPath.endsWith(".js") || configPath.endsWith(".cjs")) {
+                try {
+                    config = JSON.parse(content);
+                }
+                catch {
+                    return null;
+                }
+            }
+        }
+        if (!config)
+            return null;
+        if (config.packages && Object.keys(config.packages).length > 0) {
+            const configDir = path.dirname(configPath);
+            const rel = path.relative(configDir, path.resolve(cwd));
+            const relNorm = rel.split(path.sep).join("/");
+            const pkgConfig = config.packages[relNorm];
+            if (pkgConfig) {
+                return { ...config, ...pkgConfig, packages: config.packages };
+            }
+            for (const key of Object.keys(config.packages)) {
+                if (relNorm === key || relNorm.startsWith(`${key}/`)) {
+                    return { ...config, ...config.packages[key], packages: config.packages };
+                }
+            }
+        }
+        return config;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Merge config with CLI args. Priority: args > profile > config > defaults.
+ */
+function mergeConfigWithArgs(config, args) {
+    const merged = {};
+    if (config) {
+        if (config.evaluationId)
+            merged.evaluationId = config.evaluationId;
+        if (config.baseUrl)
+            merged.baseUrl = config.baseUrl;
+        if (config.minScore != null)
+            merged.minScore = config.minScore;
+        if (config.minN != null)
+            merged.minN = config.minN;
+        if (config.maxDrop != null)
+            merged.maxDrop = config.maxDrop;
+        if (config.warnDrop != null)
+            merged.warnDrop = config.warnDrop;
+        if (config.allowWeakEvidence != null)
+            merged.allowWeakEvidence = config.allowWeakEvidence;
+        if (config.baseline)
+            merged.baseline = config.baseline;
+        if (config.profile)
+            merged.profile = config.profile;
+    }
+    // Profile defaults (from --profile or config.profile). Apply before args override.
+    const profileName = (args.profile ?? merged.profile);
+    if (profileName && profileName in profiles_1.PROFILES) {
+        const profile = profiles_1.PROFILES[profileName];
+        if (merged.minScore === undefined && args.minScore === undefined)
+            merged.minScore = profile.minScore;
+        if (merged.maxDrop === undefined && args.maxDrop === undefined)
+            merged.maxDrop = profile.maxDrop;
+        if (merged.warnDrop === undefined && args.warnDrop === undefined && "warnDrop" in profile)
+            merged.warnDrop = profile.warnDrop;
+        if (merged.minN === undefined && args.minN === undefined)
+            merged.minN = profile.minN;
+        if (merged.allowWeakEvidence === undefined && args.allowWeakEvidence === undefined)
+            merged.allowWeakEvidence = profile.allowWeakEvidence;
+    }
+    // Args override
+    if (args.evaluationId !== undefined && args.evaluationId !== "") {
+        merged.evaluationId = String(args.evaluationId);
+    }
+    if (args.baseUrl !== undefined && args.baseUrl !== "") {
+        merged.baseUrl = String(args.baseUrl);
+    }
+    if (args.minScore !== undefined) {
+        merged.minScore =
+            typeof args.minScore === "number" ? args.minScore : parseInt(String(args.minScore), 10);
+    }
+    if (args.maxDrop !== undefined) {
+        merged.maxDrop =
+            typeof args.maxDrop === "number" ? args.maxDrop : parseInt(String(args.maxDrop), 10);
+    }
+    if (args.warnDrop !== undefined) {
+        merged.warnDrop =
+            typeof args.warnDrop === "number" ? args.warnDrop : parseInt(String(args.warnDrop), 10);
+    }
+    if (args.minN !== undefined) {
+        merged.minN = typeof args.minN === "number" ? args.minN : parseInt(String(args.minN), 10);
+    }
+    if (args.allowWeakEvidence !== undefined) {
+        merged.allowWeakEvidence =
+            args.allowWeakEvidence === true ||
+                args.allowWeakEvidence === "true" ||
+                args.allowWeakEvidence === "1";
+    }
+    if (args.baseline !== undefined && args.baseline !== "") {
+        const b = String(args.baseline);
+        if (b === "auto" || b === "previous" || b === "production") {
+            merged.baseline = b;
+        }
+        else {
+            merged.baseline = "published";
+        }
+    }
+    if (args.profile !== undefined && args.profile !== "") {
+        merged.profile = String(args.profile);
+    }
+    return merged;
+}

package/dist/cli/constants.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Standardized exit codes for evalai check.
+ */
+export declare const EXIT: {
+    readonly PASS: 0;
+    readonly SCORE_BELOW: 1;
+    readonly REGRESSION: 2;
+    readonly POLICY_VIOLATION: 3;
+    readonly API_ERROR: 4;
+    readonly BAD_ARGS: 5;
+    readonly LOW_N: 6;
+    readonly WEAK_EVIDENCE: 7;
+    /** Near-regression: score dropped within warn band (warnDrop ≤ drop < maxDrop) */
+    readonly WARN_REGRESSION: 8;
+};

package/dist/cli/constants.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EXIT = void 0;
+/**
+ * Standardized exit codes for evalai check.
+ */
+exports.EXIT = {
+    PASS: 0,
+    SCORE_BELOW: 1,
+    REGRESSION: 2,
+    POLICY_VIOLATION: 3,
+    API_ERROR: 4,
+    BAD_ARGS: 5,
+    LOW_N: 6,
+    WEAK_EVIDENCE: 7,
+    /** Near-regression: score dropped within warn band (warnDrop ≤ drop < maxDrop) */
+    WARN_REGRESSION: 8,
+};

package/dist/cli/doctor.d.ts

@@ -0,0 +1,11 @@
+/**
+ * evalai doctor — Verify CI/CD setup.
+ * Uses the same quality endpoint as check — if doctor passes, check works.
+ */
+export type DoctorArgs = {
+    baseUrl: string;
+    apiKey: string;
+    evaluationId: string;
+    baseline: "published" | "previous" | "production";
+};
+export declare function runDoctor(argv: string[]): Promise<number>;

package/dist/cli/doctor.js

@@ -0,0 +1,82 @@
+"use strict";
+/**
+ * evalai doctor — Verify CI/CD setup.
+ * Uses the same quality endpoint as check — if doctor passes, check works.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runDoctor = runDoctor;
+const api_1 = require("./api");
+const config_1 = require("./config");
+function parseDoctorArgs(argv) {
+    const args = {};
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg.startsWith("--")) {
+            const key = arg.slice(2);
+            const next = argv[i + 1];
+            if (next !== undefined && !next.startsWith("--")) {
+                args[key] = next;
+                i++;
+            }
+            else {
+                args[key] = "true";
+            }
+        }
+    }
+    const baseUrl = args.baseUrl || process.env.EVALAI_BASE_URL || "http://localhost:3000";
+    const apiKey = args.apiKey || process.env.EVALAI_API_KEY || "";
+    let evaluationId = args.evaluationId || "";
+    const baseline = (args.baseline === "previous"
+        ? "previous"
+        : args.baseline === "production"
+            ? "production"
+            : "published");
+    if (!evaluationId) {
+        const config = (0, config_1.loadConfig)(process.cwd());
+        const merged = (0, config_1.mergeConfigWithArgs)(config, {
+            evaluationId: args.evaluationId,
+            baseUrl: args.baseUrl || process.env.EVALAI_BASE_URL,
+            baseline: args.baseline,
+        });
+        if (merged.evaluationId)
+            evaluationId = String(merged.evaluationId);
+    }
+    if (!apiKey) {
+        return { ok: false, message: "Set EVALAI_API_KEY" };
+    }
+    if (!evaluationId) {
+        const configPath = (0, config_1.findConfigPath)(process.cwd());
+        if (!configPath) {
+            return { ok: false, message: "Run npx evalai init" };
+        }
+        return { ok: false, message: "Set evaluationId in evalai.config.json" };
+    }
+    return { baseUrl, apiKey, evaluationId, baseline };
+}
+async function runDoctor(argv) {
+    const parsed = parseDoctorArgs(argv);
+    if (!("baseUrl" in parsed)) {
+        console.error(parsed.message);
+        return 1;
+    }
+    const args = parsed;
+    // Call exact quality endpoint: GET /api/quality?action=latest&evaluationId=&baseline=
+    const result = await (0, api_1.fetchQualityLatest)(args.baseUrl, args.apiKey, args.evaluationId, args.baseline);
+    if (!result.ok) {
+        if (result.status === 0) {
+            console.error(`Quality API: Network failure — ${result.body}`);
+        }
+        else {
+            console.error(`Quality API: ${result.status} — ${result.body}`);
+        }
+        return 1;
+    }
+    const { data } = result;
+    // Baseline: if quality returns baselineMissing, suggest fix
+    if (data.baselineMissing === true) {
+        console.error("Publish a run or use --baseline previous");
+        return 1;
+    }
+    console.log("✓ EvalAI doctor: OK");
+    return 0;
+}

package/dist/cli/formatters/github.d.ts

@@ -0,0 +1,8 @@
+/**
+ * GitHub formatter for evalai check.
+ * - stdout: minimal (verdict + score + link) + ::error annotations for failed cases
+ * - Step summary: full Markdown written to GITHUB_STEP_SUMMARY (not stdout)
+ */
+import type { CheckReport } from "./types";
+export declare function appendStepSummary(report: CheckReport): void;
+export declare function formatGitHub(report: CheckReport): string;

package/dist/cli/formatters/github.js

@@ -0,0 +1,130 @@
+"use strict";
+/**
+ * GitHub formatter for evalai check.
+ * - stdout: minimal (verdict + score + link) + ::error annotations for failed cases
+ * - Step summary: full Markdown written to GITHUB_STEP_SUMMARY (not stdout)
+ */
+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.appendStepSummary = appendStepSummary;
+exports.formatGitHub = formatGitHub;
+const fs = __importStar(require("node:fs"));
+const snippet_1 = require("../render/snippet");
+const ANNOTATION_MAX = 10;
+function escapeAnnotationMessage(s) {
+    return s.replace(/\r/g, "").replace(/\n/g, "%0A");
+}
+function formatAnnotation(fc) {
+    const id = fc.testCaseId ?? fc.name ?? "unknown";
+    const reason = fc.reason ?? fc.outputSnippet ?? fc.output ?? "no output";
+    const msg = escapeAnnotationMessage(`TestCase ${id} failed - ${(0, snippet_1.truncateSnippet)(reason, 100)}`);
+    return `::error title=EvalAI regression::${msg}`;
+}
+function appendStepSummary(report) {
+    const path = typeof process !== "undefined" && process.env?.GITHUB_STEP_SUMMARY;
+    if (!path)
+        return;
+    const lines = [];
+    const passed = report.verdict === "pass";
+    const warned = report.verdict === "warn";
+    lines.push("## EvalAI Gate");
+    lines.push("");
+    lines.push(passed && !warned
+        ? "✅ **PASSED**"
+        : warned
+            ? `⚠️ **WARNED**: ${report.reasonMessage ?? report.reasonCode}`
+            : `❌ **FAILED**: ${report.reasonMessage ?? report.reasonCode}`);
+    lines.push("");
+    const deltaStr = report.baselineScore != null && report.delta != null
+        ? ` (baseline ${report.baselineScore}, ${report.delta >= 0 ? "+" : ""}${report.delta} pts)`
+        : "";
+    lines.push(`**Score:** ${report.score ?? 0}/100${deltaStr}`);
+    lines.push("");
+    const failedCases = report.failedCases ?? [];
+    if (failedCases.length > 0) {
+        lines.push(`### ${failedCases.length} failing case${failedCases.length === 1 ? "" : "s"}`);
+        lines.push("");
+        for (const fc of failedCases.slice(0, 10)) {
+            const label = fc.name ?? fc.input ?? "(unnamed)";
+            const exp = (0, snippet_1.truncateSnippet)(fc.expectedOutput ?? fc.expectedSnippet, 80);
+            const out = (0, snippet_1.truncateSnippet)(fc.output ?? fc.outputSnippet, 80);
+            const reason = out ? `got "${out}"` : "no output";
+            lines.push(`- **${(0, snippet_1.truncateSnippet)(label, 60)}** — expected: ${exp || "(any)"}, ${reason}`);
+        }
+        if (failedCases.length > 10) {
+            lines.push(`- _+ ${failedCases.length - 10} more_`);
+        }
+        lines.push("");
+    }
+    if (report.dashboardUrl) {
+        lines.push(`[View Dashboard](${report.dashboardUrl})`);
+        lines.push("");
+    }
+    try {
+        fs.appendFileSync(path, lines.join("\n"), "utf8");
+    }
+    catch {
+        // Non-fatal: step summary is best-effort
+    }
+}
+function formatGitHub(report) {
+    const stdoutLines = [];
+    // Emit ::error annotations for failed cases (up to N)
+    const failedCases = report.failedCases ?? [];
+    const toAnnotate = failedCases.slice(0, ANNOTATION_MAX);
+    for (const fc of toAnnotate) {
+        stdoutLines.push(formatAnnotation(fc));
+    }
+    // Minimal summary: verdict + score + link
+    const passed = report.verdict === "pass";
+    const warned = report.verdict === "warn";
+    const failReason = report.reasonMessage ?? report.reasonCode;
+    if (passed && !warned)
+        stdoutLines.push("\n✓ EvalAI gate PASSED");
+    else if (warned)
+        stdoutLines.push(`\n⚠ EvalAI gate WARNED: ${failReason}`);
+    else
+        stdoutLines.push(`\n✗ EvalAI gate FAILED: ${failReason}`);
+    const deltaStr = report.baselineScore != null && report.delta != null
+        ? ` (baseline ${report.baselineScore}, ${report.delta >= 0 ? "+" : ""}${report.delta} pts)`
+        : "";
+    stdoutLines.push(`Score: ${report.score ?? 0}/100${deltaStr}`);
+    if (report.dashboardUrl) {
+        stdoutLines.push(`Dashboard: ${report.dashboardUrl}`);
+    }
+    // Write full markdown to GITHUB_STEP_SUMMARY (not stdout)
+    appendStepSummary(report);
+    return stdoutLines.join("\n");
+}

package/dist/cli/formatters/human.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Human-readable formatter for evalai check output.
+ * Deterministic: verdict → score → failures → link → hint.
+ */
+import type { CheckReport } from "./types";
+export declare function formatHuman(report: CheckReport): string;

package/dist/cli/formatters/human.js

@@ -0,0 +1,107 @@
+"use strict";
+/**
+ * Human-readable formatter for evalai check output.
+ * Deterministic: verdict → score → failures → link → hint.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatHuman = formatHuman;
+const snippet_1 = require("../render/snippet");
+const TOP_N = 3;
+function formatHuman(report) {
+    const lines = [];
+    const passed = report.verdict === "pass";
+    const warned = report.verdict === "warn";
+    const failReason = report.reasonMessage;
+    lines.push(passed && !warned
+        ? "\n✓ EvalAI gate PASSED"
+        : warned
+            ? `\n⚠ EvalAI gate WARNED: ${failReason ?? report.reasonCode}`
+            : `\n✗ EvalAI gate FAILED: ${failReason ?? report.reasonCode}`);
+    const deltaStr = report.baselineScore != null && report.delta != null
+        ? ` (baseline ${report.baselineScore}, ${report.delta >= 0 ? "+" : ""}${report.delta} pts)`
+        : "";
+    lines.push(`Score: ${report.score ?? 0}/100${deltaStr}`);
+    const failedCases = report.failedCases ?? [];
+    if (failedCases.length > 0) {
+        const toShow = failedCases.slice(0, TOP_N);
+        lines.push(`${failedCases.length} failing case${failedCases.length === 1 ? "" : "s"}:`);
+        for (const fc of toShow) {
+            const label = fc.name ?? fc.input ?? "(unnamed)";
+            const exp = (0, snippet_1.truncateSnippet)(fc.expectedOutput ?? fc.expectedSnippet, 50);
+            const out = (0, snippet_1.truncateSnippet)(fc.output ?? fc.outputSnippet, 50);
+            const reason = out ? `got "${out}"` : "no output";
+            lines.push(`  - "${(0, snippet_1.truncateSnippet)(label, 50)}" → expected: ${exp || "(any)"}, ${reason}`);
+        }
+        if (failedCases.length > toShow.length) {
+            lines.push(`  + ${failedCases.length - toShow.length} more`);
+        }
+    }
+    if (report.dashboardUrl) {
+        lines.push(`Dashboard: ${report.dashboardUrl}`);
+    }
+    if (!passed || warned) {
+        lines.push("Next: View full report above, fix failing cases, or adjust gate with --minScore / --maxDrop / --warnDrop");
+    }
+    if (report.explain &&
+        (report.breakdown01 || report.contribPts || report.flags?.length || report.policyEvidence)) {
+        lines.push("");
+        lines.push("--- Explain ---");
+        if (report.contribPts) {
+            const cp = report.contribPts;
+            const pts = [];
+            if (cp.passRatePts != null)
+                pts.push(`passRate: ${cp.passRatePts}`);
+            if (cp.safetyPts != null)
+                pts.push(`safety: ${cp.safetyPts}`);
+            if (cp.compliancePts != null)
+                pts.push(`compliance: ${cp.compliancePts}`);
+            if (cp.performancePts != null)
+                pts.push(`performance: ${cp.performancePts}`);
+            if (pts.length)
+                lines.push(`Contrib pts: ${pts.join(", ")}`);
+        }
+        if (report.breakdown01) {
+            const b = report.breakdown01;
+            const parts = [];
+            if (b.passRate != null)
+                parts.push(`passRate=${b.passRate}`);
+            if (b.safety != null)
+                parts.push(`safety=${b.safety}`);
+            if (b.judge != null)
+                parts.push(`judge=${b.judge}`);
+            if (b.schema != null)
+                parts.push(`schema=${b.schema}`);
+            if (b.latency != null)
+                parts.push(`latency=${b.latency}`);
+            if (b.cost != null)
+                parts.push(`cost=${b.cost}`);
+            if (parts.length)
+                lines.push(`Breakdown: ${parts.join(", ")}`);
+        }
+        if (report.flags && report.flags.length > 0) {
+            lines.push(`Flags: ${report.flags.join(", ")}`);
+        }
+        if (report.thresholds) {
+            const t = report.thresholds;
+            const parts = [];
+            if (t.minScore != null)
+                parts.push(`minScore=${t.minScore}`);
+            if (t.maxDrop != null)
+                parts.push(`maxDrop=${t.maxDrop}`);
+            if (t.minN != null)
+                parts.push(`minN=${t.minN}`);
+            if (parts.length)
+                lines.push(`Thresholds: ${parts.join(", ")}`);
+        }
+        if (report.policyEvidence) {
+            const pe = report.policyEvidence;
+            lines.push(`Policy sub-check failed: ${pe.failedCheck ?? "unknown"}`);
+            if (pe.remediation)
+                lines.push(`Remediation: ${pe.remediation}`);
+            if (pe.snapshot && Object.keys(pe.snapshot).length > 0) {
+                lines.push(`Snapshot: ${JSON.stringify(pe.snapshot)}`);
+            }
+        }
+    }
+    return lines.join("\n");
+}

package/dist/cli/formatters/json.d.ts

@@ -0,0 +1,6 @@
+/**
+ * JSON formatter for evalai check.
+ * Outputs only JSON, no extra logs.
+ */
+import type { CheckReport } from "./types";
+export declare function formatJson(report: CheckReport): string;

package/dist/cli/formatters/json.js

@@ -0,0 +1,10 @@
+"use strict";
+/**
+ * JSON formatter for evalai check.
+ * Outputs only JSON, no extra logs.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatJson = formatJson;
+function formatJson(report) {
+    return JSON.stringify(report, null, 0);
+}

package/dist/cli/formatters/pr-comment.d.ts

@@ -0,0 +1,12 @@
+/**
+ * PR comment markdown builder for evalai check --pr-comment-out.
+ * Produces deterministic markdown for GitHub Action to post as PR comment.
+ */
+import type { CheckReport } from "./types";
+/**
+ * Hidden marker for GitHub Action to find and update existing comment (sticky update).
+ * Action should: 1) post body from file 2) search PR comments for this marker 3) update if found, else create.
+ * Export for use in Action scripts.
+ */
+export declare const PR_COMMENT_MARKER = "<!-- evalai-gate-comment -->";
+export declare function buildPrComment(report: CheckReport): string;