@kevinrabun/judges-cli 3.124.0

package/dist/commands/triage.d.ts

@@ -0,0 +1,15 @@
+/**
+ * `judges triage` — Finding triage workflow.
+ *
+ * Allows developers and teams to set triage status on tracked findings,
+ * recording decisions like accepted-risk, deferred, won't-fix, or
+ * false-positive with reason and attribution.
+ *
+ * Usage:
+ *   judges triage set --rule SEC-001 --status accepted-risk --reason "Mitigated by WAF"
+ *   judges triage set --rule AUTH-002 --file src/api.ts --status deferred
+ *   judges triage list                              # Show all triaged findings
+ *   judges triage list --status deferred            # Show only deferred findings
+ *   judges triage summary                           # Triage summary
+ */
+export declare function runTriage(argv: string[]): void;

package/dist/commands/triage.js

@@ -0,0 +1,171 @@
+/**
+ * `judges triage` — Finding triage workflow.
+ *
+ * Allows developers and teams to set triage status on tracked findings,
+ * recording decisions like accepted-risk, deferred, won't-fix, or
+ * false-positive with reason and attribution.
+ *
+ * Usage:
+ *   judges triage set --rule SEC-001 --status accepted-risk --reason "Mitigated by WAF"
+ *   judges triage set --rule AUTH-002 --file src/api.ts --status deferred
+ *   judges triage list                              # Show all triaged findings
+ *   judges triage list --status deferred            # Show only deferred findings
+ *   judges triage summary                           # Triage summary
+ */
+import { triageFinding, getTriagedFindings, formatTriageSummary, loadFindingStore } from "../finding-lifecycle.js";
+const VALID_TRIAGE_STATUSES = new Set(["accepted-risk", "deferred", "wont-fix", "false-positive"]);
+function parseTriageArgs(argv) {
+    const args = {
+        subcommand: argv[3] || "summary",
+        format: "text",
+    };
+    for (let i = 4; i < argv.length; i++) {
+        const arg = argv[i];
+        switch (arg) {
+            case "--rule":
+            case "-r":
+                args.ruleId = argv[++i];
+                break;
+            case "--file":
+            case "-f":
+                args.filePath = argv[++i];
+                break;
+            case "--status":
+            case "-s":
+                args.status = argv[++i];
+                break;
+            case "--reason":
+            case "-m":
+                args.reason = argv[++i];
+                break;
+            case "--by":
+                args.triagedBy = argv[++i];
+                break;
+            case "--format":
+            case "-o":
+                args.format = argv[++i];
+                break;
+            default:
+                break;
+        }
+    }
+    return args;
+}
+function printTriageHelp() {
+    console.log(`
+Judges Panel — Finding Triage Workflow
+
+USAGE:
+  judges triage set --rule <id> --status <status>    Set triage status on a finding
+  judges triage list [--status <status>]             List triaged findings
+  judges triage summary                              Show triage summary
+
+TRIAGE STATUSES:
+  accepted-risk   Acknowledged risk, intentionally retained
+  deferred        Will be addressed in a future iteration
+  wont-fix        Team decided not to address
+  false-positive  Confirmed false positive (feeds calibration)
+
+SET OPTIONS:
+  --rule, -r <id>         Rule ID to triage (e.g. SEC-001)
+  --file, -f <path>       File path (disambiguates when same rule in multiple files)
+  --status, -s <status>   Triage status (see above)
+  --reason, -m <text>     Reason for the triage decision
+  --by <name>             Who triaged this finding
+  --format, -o <fmt>      Output format: text, json
+
+EXAMPLES:
+  judges triage set --rule SEC-001 --status accepted-risk --reason "Mitigated by WAF"
+  judges triage set --rule AUTH-002 --file src/api.ts --status deferred --by "kevin"
+  judges triage list --status false-positive
+  judges triage summary
+`);
+}
+// ─── CLI Handler ────────────────────────────────────────────────────────────
+export function runTriage(argv) {
+    const args = parseTriageArgs(argv);
+    if (args.subcommand === "--help" || args.subcommand === "-h") {
+        printTriageHelp();
+        process.exit(0);
+    }
+    switch (args.subcommand) {
+        case "set": {
+            if (!args.ruleId) {
+                console.error("Error: --rule is required for triage set");
+                process.exit(1);
+            }
+            if (!args.status || !VALID_TRIAGE_STATUSES.has(args.status)) {
+                console.error(`Error: --status must be one of: ${[...VALID_TRIAGE_STATUSES].join(", ")}`);
+                process.exit(1);
+            }
+            const result = triageFinding(".", { ruleId: args.ruleId.toUpperCase(), filePath: args.filePath }, args.status, args.reason, args.triagedBy);
+            if (result) {
+                const statusLabels = {
+                    "accepted-risk": "accepted risk",
+                    deferred: "deferred",
+                    "wont-fix": "won't fix",
+                    "false-positive": "false positive",
+                };
+                console.log(`✓ Triaged ${result.ruleId} in ${result.filePath} as ${statusLabels[args.status]}`);
+                if (args.reason) {
+                    console.log(`  Reason: ${args.reason}`);
+                }
+            }
+            else {
+                console.error(`Error: No open finding found for rule ${args.ruleId.toUpperCase()}${args.filePath ? ` in ${args.filePath}` : ""}`);
+                console.error("  Run 'judges eval' first to populate the findings store.");
+                process.exit(1);
+            }
+            process.exit(0);
+            break;
+        }
+        case "list": {
+            const findings = getTriagedFindings(".", args.status);
+            if (args.format === "json") {
+                console.log(JSON.stringify(findings, null, 2));
+            }
+            else {
+                if (findings.length === 0) {
+                    console.log(args.status ? `  No findings with status "${args.status}".` : "  No triaged findings.");
+                }
+                else {
+                    const statusFilter = args.status ? ` (${args.status})` : "";
+                    console.log(`\n  Triaged Findings${statusFilter}: ${findings.length}\n`);
+                    for (const f of findings) {
+                        console.log(`  [${f.severity.toUpperCase()}] ${f.ruleId}: ${f.title} → ${f.status}`);
+                        if (f.triageReason)
+                            console.log(`    Reason: ${f.triageReason}`);
+                        if (f.triagedBy)
+                            console.log(`    By: ${f.triagedBy}`);
+                        console.log(`    File: ${f.filePath}`);
+                        console.log("");
+                    }
+                }
+            }
+            process.exit(0);
+            break;
+        }
+        case "summary": {
+            const store = loadFindingStore(".");
+            if (args.format === "json") {
+                const triageStatuses = new Set(["accepted-risk", "deferred", "wont-fix", "false-positive"]);
+                const triaged = store.findings.filter((f) => triageStatuses.has(f.status));
+                const byStatus = {};
+                for (const f of triaged) {
+                    byStatus[f.status] = (byStatus[f.status] || 0) + 1;
+                }
+                console.log(JSON.stringify({ total: triaged.length, byStatus }, null, 2));
+            }
+            else {
+                console.log("");
+                console.log(formatTriageSummary(store));
+            }
+            process.exit(0);
+            break;
+        }
+        default:
+            console.error(`Unknown triage subcommand: ${args.subcommand}`);
+            printTriageHelp();
+            process.exit(1);
+    }
+}

package/dist/commands/trust-adaptive.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Trust-adaptive — adjust judge sensitivity based on historical
+ * accuracy of developers or AI models. High-trust actors skip
+ * non-critical judges; low-trust get stricter scrutiny.
+ *
+ * All data stored locally in `.judges-trust/`.
+ */
+export declare function runTrustAdaptive(argv: string[]): void;

package/dist/commands/trust-adaptive.js

@@ -0,0 +1,193 @@
+/**
+ * Trust-adaptive — adjust judge sensitivity based on historical
+ * accuracy of developers or AI models. High-trust actors skip
+ * non-critical judges; low-trust get stricter scrutiny.
+ *
+ * All data stored locally in `.judges-trust/`.
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+// ─── Storage ────────────────────────────────────────────────────────────────
+const DATA_DIR = ".judges-trust";
+function ensureDir() {
+    if (!existsSync(DATA_DIR))
+        mkdirSync(DATA_DIR, { recursive: true });
+}
+function loadRecords() {
+    const file = join(DATA_DIR, "records.json");
+    if (!existsSync(file))
+        return [];
+    try {
+        return JSON.parse(readFileSync(file, "utf-8"));
+    }
+    catch {
+        return [];
+    }
+}
+function saveRecords(records) {
+    ensureDir();
+    writeFileSync(join(DATA_DIR, "records.json"), JSON.stringify(records, null, 2));
+}
+// ─── Analysis ───────────────────────────────────────────────────────────────
+// Non-critical judges that can be skipped for high-trust actors
+const NON_CRITICAL_JUDGES = [
+    "style-consistency",
+    "naming-convention",
+    "comment-coverage",
+    "line-length",
+    "function-length",
+    "import-order",
+];
+function computeProfile(record) {
+    const passRate = record.evaluations > 0 ? record.passCount / record.evaluations : 0;
+    const fpRate = record.evaluations > 0 ? record.falsePositives / record.evaluations : 0;
+    // Trust score: weighted combination
+    const trustScore = Math.round(passRate * 40 + record.avgScore * 0.4 + fpRate * 20);
+    let trustLevel;
+    let sensitivity;
+    let skipJudges = [];
+    let escalate = false;
+    let detail;
+    if (record.evaluations < 5) {
+        trustLevel = "unknown";
+        sensitivity = "normal";
+        detail = `Only ${record.evaluations} evaluations — need ≥5 for trust assignment`;
+    }
+    else if (trustScore >= 75) {
+        trustLevel = "high";
+        sensitivity = "relaxed";
+        skipJudges = NON_CRITICAL_JUDGES;
+        detail = `High trust (${trustScore}) — skip ${skipJudges.length} non-critical judges`;
+    }
+    else if (trustScore >= 45) {
+        trustLevel = "medium";
+        sensitivity = "normal";
+        detail = `Medium trust (${trustScore}) — standard evaluation`;
+    }
+    else {
+        trustLevel = "low";
+        sensitivity = "strict";
+        escalate = true;
+        detail = `Low trust (${trustScore}) — strict evaluation with human escalation`;
+    }
+    return { actor: record.actor, trustLevel, trustScore, sensitivity, skipJudges, escalate, detail };
+}
+// ─── CLI ────────────────────────────────────────────────────────────────────
+export function runTrustAdaptive(argv) {
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`
+judges trust-adaptive — Adaptive trust scoring for actors
+
+Usage:
+  judges trust-adaptive --record --actor "copilot" --score 85 --pass
+  judges trust-adaptive --record --actor "dev-alice" --score 40 --fail
+  judges trust-adaptive --record --actor "copilot" --fp (record false positive)
+  judges trust-adaptive --show
+  judges trust-adaptive --profile "copilot"
+
+Options:
+  --record              Record evaluation result
+  --actor <name>        Actor name (developer, AI model, team)
+  --score <n>           Evaluation score (0-100)
+  --pass                Record a pass
+  --fail                Record a fail
+  --fp                  Record a false positive
+  --show                Show all trust profiles
+  --profile <name>      Show specific actor profile
+  --format json         JSON output
+  --help, -h            Show this help
+
+Trust Levels:
+  high    → Skip non-critical judges, relaxed thresholds
+  medium  → Standard evaluation
+  low     → Strict evaluation, escalation to human reviewer
+  unknown → <5 evaluations, standard evaluation
+`);
+        return;
+    }
+    const format = argv.find((_a, i) => argv[i - 1] === "--format") || "text";
+    const record = argv.includes("--record");
+    const _show = argv.includes("--show");
+    const profileName = argv.find((_a, i) => argv[i - 1] === "--profile");
+    const actor = argv.find((_a, i) => argv[i - 1] === "--actor") || "";
+    const scoreArg = parseInt(argv.find((_a, i) => argv[i - 1] === "--score") || "0");
+    const isPass = argv.includes("--pass");
+    const isFail = argv.includes("--fail");
+    const isFp = argv.includes("--fp");
+    if (record) {
+        if (!actor) {
+            console.error("  --actor is required for --record");
+            return;
+        }
+        const records = loadRecords();
+        let rec = records.find((r) => r.actor === actor);
+        if (!rec) {
+            rec = { actor, evaluations: 0, passCount: 0, failCount: 0, falsePositives: 0, avgScore: 0, lastUpdated: "" };
+            records.push(rec);
+        }
+        rec.evaluations++;
+        if (isPass)
+            rec.passCount++;
+        if (isFail)
+            rec.failCount++;
+        if (isFp)
+            rec.falsePositives++;
+        rec.avgScore = Math.round((rec.avgScore * (rec.evaluations - 1) + scoreArg) / rec.evaluations);
+        rec.lastUpdated = new Date().toISOString();
+        saveRecords(records);
+        console.log(`  ✅ Recorded for ${actor}: eval #${rec.evaluations} (score: ${scoreArg}${isPass ? ", pass" : ""}${isFail ? ", fail" : ""}${isFp ? ", FP" : ""})`);
+        return;
+    }
+    const records = loadRecords();
+    if (records.length === 0) {
+        console.log("  No trust records yet. Use --record to add evaluations.");
+        return;
+    }
+    if (profileName) {
+        const rec = records.find((r) => r.actor === profileName);
+        if (!rec) {
+            console.error(`  Actor "${profileName}" not found.`);
+            return;
+        }
+        const profile = computeProfile(rec);
+        if (format === "json") {
+            console.log(JSON.stringify(profile, null, 2));
+        }
+        else {
+            const icon = profile.trustLevel === "high"
+                ? "🟢"
+                : profile.trustLevel === "medium"
+                    ? "🟡"
+                    : profile.trustLevel === "low"
+                        ? "🔴"
+                        : "⚪";
+            console.log(`\n    ${icon} ${profile.actor}`);
+            console.log(`        Trust: ${profile.trustLevel} (${profile.trustScore}/100)`);
+            console.log(`        Sensitivity: ${profile.sensitivity}`);
+            console.log(`        ${profile.detail}`);
+            if (profile.skipJudges.length > 0)
+                console.log(`        Skip: ${profile.skipJudges.join(", ")}`);
+            if (profile.escalate)
+                console.log(`        ⚠ Human escalation required`);
+            console.log(`        Stats: ${rec.evaluations} evals, ${rec.passCount} pass, ${rec.failCount} fail, ${rec.falsePositives} FP`);
+            console.log("");
+        }
+        return;
+    }
+    // Show all
+    const profiles = records.map(computeProfile);
+    profiles.sort((a, b) => b.trustScore - a.trustScore);
+    if (format === "json") {
+        console.log(JSON.stringify({ profiles, timestamp: new Date().toISOString() }, null, 2));
+    }
+    else {
+        console.log(`\n  Trust Profiles — ${profiles.length} actors\n  ──────────────────────────`);
+        console.log(`    ${"Actor".padEnd(25)} ${"Level".padEnd(10)} ${"Score".padEnd(8)} ${"Sensitivity".padEnd(12)} ${"Evals".padEnd(8)} Detail`);
+        console.log(`    ${"─".repeat(25)} ${"─".repeat(10)} ${"─".repeat(8)} ${"─".repeat(12)} ${"─".repeat(8)} ${"─".repeat(30)}`);
+        for (const p of profiles) {
+            const icon = p.trustLevel === "high" ? "🟢" : p.trustLevel === "medium" ? "🟡" : p.trustLevel === "low" ? "🔴" : "⚪";
+            console.log(`    ${icon} ${p.actor.padEnd(23)} ${p.trustLevel.padEnd(10)} ${String(p.trustScore).padEnd(8)} ${p.sensitivity.padEnd(12)} ${String(records.find((r) => r.actor === p.actor)?.evaluations || 0).padEnd(8)} ${p.detail}`);
+        }
+        console.log("");
+    }
+}

package/dist/commands/trust-ramp.d.ts

@@ -0,0 +1,29 @@
+/**
+ * `judges trust-ramp` — Generate a graduated trust configuration.
+ *
+ * Produces a phased .judgesrc progression that starts with advisory-only
+ * (no CI gating) and ramps up to full enforcement over 30/60/90 days.
+ * All data stays local — phases are encoded as config files you commit.
+ *
+ * Phases:
+ *   1. Advisory    (days 0-30)  — high+critical only, no fail, baseline created
+ *   2. Selective   (days 30-60) — medium+, fail on critical, auto-fix enabled
+ *   3. Enforcing   (days 60-90) — all severities, fail on findings, score gate
+ *   4. Full trust  (day 90+)    — strict preset, full gating, baseline removed
+ */
+import type { JudgesConfig } from "../types.js";
+export interface TrustPhase {
+    /** Phase number (1-4) */
+    phase: number;
+    /** Human-readable name */
+    name: string;
+    /** Day range description */
+    days: string;
+    /** What this phase enables */
+    description: string;
+    /** The generated .judgesrc config */
+    config: JudgesConfig;
+    /** CI workflow snippet (optional) */
+    ciTip: string;
+}
+export declare function runTrustRamp(argv: string[]): void;

package/dist/commands/trust-ramp.js

@@ -0,0 +1,189 @@
+/**
+ * `judges trust-ramp` — Generate a graduated trust configuration.
+ *
+ * Produces a phased .judgesrc progression that starts with advisory-only
+ * (no CI gating) and ramps up to full enforcement over 30/60/90 days.
+ * All data stays local — phases are encoded as config files you commit.
+ *
+ * Phases:
+ *   1. Advisory    (days 0-30)  — high+critical only, no fail, baseline created
+ *   2. Selective   (days 30-60) — medium+, fail on critical, auto-fix enabled
+ *   3. Enforcing   (days 60-90) — all severities, fail on findings, score gate
+ *   4. Full trust  (day 90+)    — strict preset, full gating, baseline removed
+ */
+import { writeFileSync } from "fs";
+import { join, resolve } from "path";
+function buildPhases(basePreset) {
+    return [
+        {
+            phase: 1,
+            name: "Advisory",
+            days: "Days 0–30",
+            description: "Report only critical and high severity findings. No CI gating. " +
+                "Creates a baseline of existing issues so new introductions are visible.",
+            config: {
+                ...(basePreset ? { preset: basePreset } : {}),
+                minSeverity: "high",
+                failOnFindings: false,
+            },
+            ciTip: "# Phase 1: advisory only — do NOT add --fail-on-findings to CI",
+        },
+        {
+            phase: 2,
+            name: "Selective Enforcement",
+            days: "Days 30–60",
+            description: "Lower threshold to medium severity. Gate CI on critical findings only " +
+                "via failOnScoreBelow. Auto-fix suggestions become available.",
+            config: {
+                ...(basePreset ? { preset: basePreset } : {}),
+                minSeverity: "medium",
+                failOnFindings: false,
+                failOnScoreBelow: 3,
+            },
+            ciTip: "# Phase 2: gate on score — blocks PRs scoring below 3/10",
+        },
+        {
+            phase: 3,
+            name: "Enforcing",
+            days: "Days 60–90",
+            description: "Report all severities. Fail on any findings. Score gate raised to 6. " +
+                "Team should be comfortable with judges output by now.",
+            config: {
+                ...(basePreset ? { preset: basePreset } : {}),
+                minSeverity: "low",
+                failOnFindings: true,
+                failOnScoreBelow: 6,
+            },
+            ciTip: "# Phase 3: enforcing — PR merges blocked on findings or low score",
+        },
+        {
+            phase: 4,
+            name: "Full Trust",
+            days: "Day 90+",
+            description: "Strict mode with all judges and all severities. Full gating enabled. " +
+                "Remove the baseline file — all findings are real.",
+            config: {
+                preset: "strict",
+                failOnFindings: true,
+                failOnScoreBelow: 7,
+            },
+            ciTip: "# Phase 4: full trust — judges is your primary reviewer",
+        },
+    ];
+}
+// ─── Output Formats ─────────────────────────────────────────────────────────
+function formatPhasesText(phases) {
+    const lines = [
+        "╔══════════════════════════════════════════════════════════════╗",
+        "║            Judges — Graduated Trust Ramp Plan               ║",
+        "╚══════════════════════════════════════════════════════════════╝",
+        "",
+    ];
+    for (const p of phases) {
+        lines.push(`── Phase ${p.phase}: ${p.name} (${p.days}) ${"─".repeat(Math.max(0, 40 - p.name.length - p.days.length))}`);
+        lines.push(`   ${p.description}`);
+        lines.push("");
+        lines.push("   .judgesrc:");
+        lines.push(`   ${JSON.stringify(p.config, null, 2).replace(/\n/g, "\n   ")}`);
+        lines.push("");
+        lines.push(`   ${p.ciTip}`);
+        lines.push("");
+    }
+    lines.push("── Getting Started ──────────────────────────────────────────");
+    lines.push("   1. Run: judges trust-ramp --emit phase-1");
+    lines.push("   2. Commit the generated .judgesrc to your repo");
+    lines.push("   3. When ready to advance, run: judges trust-ramp --emit phase-2");
+    lines.push("   4. Repeat until full trust is achieved");
+    lines.push("");
+    return lines.join("\n");
+}
+function formatPhasesJson(phases) {
+    return JSON.stringify(phases.map((p) => ({
+        phase: p.phase,
+        name: p.name,
+        days: p.days,
+        description: p.description,
+        config: p.config,
+    })), null, 2);
+}
+// ─── Emit a Phase Config ─────────────────────────────────────────────────
+function emitPhaseConfig(phase, targetDir) {
+    const configPath = join(targetDir, ".judgesrc");
+    const content = JSON.stringify(phase.config, null, 2);
+    writeFileSync(configPath, content + "\n", "utf-8");
+    return configPath;
+}
+// ─── CLI Entry ──────────────────────────────────────────────────────────────
+export function runTrustRamp(argv) {
+    const args = parseArgs(argv);
+    const phases = buildPhases(args.preset);
+    if (args.emit) {
+        const match = /^phase-?(\d)$/i.exec(args.emit);
+        if (!match) {
+            console.error(`Error: --emit expects "phase-1" through "phase-4", got "${args.emit}"`);
+            process.exit(1);
+        }
+        const num = parseInt(match[1], 10);
+        const phase = phases.find((p) => p.phase === num);
+        if (!phase) {
+            console.error(`Error: no phase ${num}. Valid: 1-4`);
+            process.exit(1);
+        }
+        const dir = resolve(args.dir || ".");
+        const path = emitPhaseConfig(phase, dir);
+        console.log(`✔ Phase ${num} (${phase.name}) config written to ${path}`);
+        console.log(`  ${phase.ciTip}`);
+        return;
+    }
+    // Default: show the plan
+    if (args.format === "json") {
+        console.log(formatPhasesJson(phases));
+    }
+    else {
+        console.log(formatPhasesText(phases));
+    }
+}
+function parseArgs(argv) {
+    const result = { format: "text" };
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === "--emit" && argv[i + 1]) {
+            result.emit = argv[++i];
+        }
+        else if (arg === "--preset" && argv[i + 1]) {
+            result.preset = argv[++i];
+        }
+        else if (arg === "--format" && argv[i + 1]) {
+            const fmt = argv[++i];
+            if (fmt === "json" || fmt === "text")
+                result.format = fmt;
+        }
+        else if (arg === "--dir" && argv[i + 1]) {
+            result.dir = argv[++i];
+        }
+        else if (arg === "--help" || arg === "-h") {
+            printHelp();
+            process.exit(0);
+        }
+    }
+    return result;
+}
+function printHelp() {
+    console.log(`
+judges trust-ramp — Generate a graduated trust configuration
+
+Usage:
+  judges trust-ramp                        Show the 4-phase ramp plan
+  judges trust-ramp --format json          Output plan as JSON
+  judges trust-ramp --emit phase-1         Write Phase 1 .judgesrc to cwd
+  judges trust-ramp --emit phase-2 --dir . Write Phase 2 .judgesrc to dir
+  judges trust-ramp --preset security-only Base phases on a preset
+
+Options:
+  --emit <phase>     Emit a phase config: phase-1, phase-2, phase-3, phase-4
+  --preset <name>    Base the ramp on a named preset (e.g. security-only)
+  --format <fmt>     Output format: text (default), json
+  --dir <path>       Target directory for --emit (default: cwd)
+  -h, --help         Show this help
+`);
+}

package/dist/commands/tune.d.ts

@@ -0,0 +1,24 @@
+/**
+ * `judges tune` — Analyze your project and suggest optimal .judgesrc.json configuration.
+ *
+ * Runs an initial evaluation on a sample of project files, then recommends:
+ * - Which preset best fits your project
+ * - Rules to disable based on consistent FP patterns
+ * - Severity overrides for noisy rules
+ * - Framework-specific settings
+ *
+ * Usage:
+ *   judges tune                        # Analyze current directory
+ *   judges tune --dir ./src            # Analyze specific directory
+ *   judges tune --apply                # Write .judgesrc.json automatically
+ *   judges tune --max-files 20         # Limit sample size
+ */
+interface TuneArgs {
+    dir: string;
+    apply: boolean;
+    maxFiles: number;
+    verbose: boolean;
+}
+export declare function parseTuneArgs(argv: string[]): TuneArgs;
+export declare function runTune(argv: string[]): void;
+export {};