@kevinrabun/judges-cli 3.124.0

package/dist/commands/review-annotation-export.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Review-annotation-export — Export review findings as code annotations.
+ */
+export declare function runReviewAnnotationExport(argv: string[]): void;

package/dist/commands/review-annotation-export.js

@@ -0,0 +1,105 @@
+/**
+ * Review-annotation-export — Export review findings as code annotations.
+ */
+import { readFileSync, writeFileSync, existsSync } from "fs";
+// ─── Analysis ───────────────────────────────────────────────────────────────
+function toAnnotations(verdict) {
+    const annotations = [];
+    for (const f of verdict.findings) {
+        const lines = f.lineNumbers || [];
+        const sev = (f.severity || "medium").toLowerCase();
+        const type = sev === "critical" || sev === "high" ? "error" : sev === "medium" ? "warning" : "notice";
+        if (lines.length === 0) {
+            annotations.push({
+                type,
+                ruleId: f.ruleId,
+                title: f.title,
+                message: `${f.description}\n\nRecommendation: ${f.recommendation}`,
+                line: 1,
+            });
+        }
+        else {
+            annotations.push({
+                type,
+                ruleId: f.ruleId,
+                title: f.title,
+                message: `${f.description}\n\nRecommendation: ${f.recommendation}`,
+                line: lines[0],
+                endLine: lines.length > 1 ? lines[lines.length - 1] : undefined,
+            });
+        }
+    }
+    return annotations;
+}
+function toGitHubFormat(annotations) {
+    return annotations
+        .map((a) => {
+        const lineRef = a.endLine ? `line=${a.line},endLine=${a.endLine}` : `line=${a.line}`;
+        return `::${a.type} ${lineRef},title=${a.ruleId}: ${a.title}::${a.message.replace(/\n/g, "%0A")}`;
+    })
+        .join("\n");
+}
+function toInlineComments(annotations) {
+    return annotations.map((a) => `// [${a.type.toUpperCase()}] L${a.line}: ${a.ruleId} — ${a.title}`).join("\n");
+}
+// ─── CLI ────────────────────────────────────────────────────────────────────
+export function runReviewAnnotationExport(argv) {
+    const fileIdx = argv.indexOf("--file");
+    const outputIdx = argv.indexOf("--output");
+    const formatIdx = argv.indexOf("--format");
+    const filePath = fileIdx >= 0 ? argv[fileIdx + 1] : undefined;
+    const outputPath = outputIdx >= 0 ? argv[outputIdx + 1] : undefined;
+    const format = formatIdx >= 0 ? argv[formatIdx + 1] : "github";
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`
+judges review-annotation-export — Export findings as annotations
+
+Usage:
+  judges review-annotation-export --file <verdict.json> [--output <file>]
+                                  [--format github|inline|json]
+
+Options:
+  --file <path>      Path to verdict JSON file (required)
+  --output <path>    Write annotations to file
+  --format <fmt>     Format: github (default), inline, json
+  --help, -h         Show this help
+`);
+        return;
+    }
+    if (!filePath) {
+        console.error("Error: --file required");
+        process.exitCode = 1;
+        return;
+    }
+    if (!existsSync(filePath)) {
+        console.error(`Error: not found: ${filePath}`);
+        process.exitCode = 1;
+        return;
+    }
+    let verdict;
+    try {
+        verdict = JSON.parse(readFileSync(filePath, "utf-8"));
+    }
+    catch {
+        console.error("Error: invalid JSON");
+        process.exitCode = 1;
+        return;
+    }
+    const annotations = toAnnotations(verdict);
+    let output;
+    if (format === "json") {
+        output = JSON.stringify(annotations, null, 2);
+    }
+    else if (format === "inline") {
+        output = toInlineComments(annotations);
+    }
+    else {
+        output = toGitHubFormat(annotations);
+    }
+    if (outputPath) {
+        writeFileSync(outputPath, output);
+        console.log(`Annotations written to ${outputPath} (${annotations.length} annotations)`);
+        return;
+    }
+    console.log(output);
+}

package/dist/commands/review-annotation.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Review-annotation — Add annotations to review result files.
+ */
+export declare function runReviewAnnotation(argv: string[]): void;

package/dist/commands/review-annotation.js

@@ -0,0 +1,133 @@
+/**
+ * Review-annotation — Add annotations to review result files.
+ */
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { dirname, join } from "path";
+// ─── Helpers ────────────────────────────────────────────────────────────────
+function annotationFile() {
+    return join(process.cwd(), ".judges", "annotations.json");
+}
+function loadAnnotations() {
+    const f = annotationFile();
+    if (!existsSync(f))
+        return [];
+    try {
+        return JSON.parse(readFileSync(f, "utf-8"));
+    }
+    catch {
+        return [];
+    }
+}
+function saveAnnotations(annotations) {
+    const f = annotationFile();
+    const d = dirname(f);
+    if (!existsSync(d))
+        mkdirSync(d, { recursive: true });
+    writeFileSync(f, JSON.stringify(annotations, null, 2));
+}
+// ─── CLI ────────────────────────────────────────────────────────────────────
+export function runReviewAnnotation(argv) {
+    const sub = argv[0];
+    if (!sub || sub === "--help" || sub === "-h") {
+        console.log(`
+judges review-annotation — Annotate review results
+
+Usage:
+  judges review-annotation add    --file <path> --rule <ruleId> --note <text> [--author <name>]
+  judges review-annotation list   [--file <path>] [--rule <ruleId>]
+  judges review-annotation remove --id <id>
+  judges review-annotation clear  [--file <path>]
+  judges review-annotation export [--format json]
+
+Options:
+  --file <path>      Target result file
+  --rule <ruleId>    Rule ID to annotate
+  --note <text>      Annotation text
+  --author <name>    Author name (default: anonymous)
+  --id <id>          Annotation ID for removal
+  --format json      JSON output
+  --help, -h         Show this help
+`);
+        return;
+    }
+    const args = argv.slice(1);
+    const annotations = loadAnnotations();
+    if (sub === "add") {
+        const file = args.find((_a, i) => args[i - 1] === "--file") || "";
+        const rule = args.find((_a, i) => args[i - 1] === "--rule") || "";
+        const note = args.find((_a, i) => args[i - 1] === "--note");
+        const author = args.find((_a, i) => args[i - 1] === "--author") || "anonymous";
+        if (!note) {
+            console.error("Error: --note required");
+            process.exitCode = 1;
+            return;
+        }
+        const id = `ann-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`;
+        annotations.push({ id, targetFile: file, ruleId: rule, note, author, createdAt: new Date().toISOString() });
+        saveAnnotations(annotations);
+        console.log(`Annotation added: ${id}`);
+    }
+    else if (sub === "list") {
+        const file = args.find((_a, i) => args[i - 1] === "--file");
+        const rule = args.find((_a, i) => args[i - 1] === "--rule");
+        let filtered = annotations;
+        if (file)
+            filtered = filtered.filter((a) => a.targetFile === file);
+        if (rule)
+            filtered = filtered.filter((a) => a.ruleId === rule);
+        if (filtered.length === 0) {
+            console.log("No annotations found.");
+            return;
+        }
+        console.log(`\nAnnotations (${filtered.length}):`);
+        console.log("═".repeat(65));
+        for (const a of filtered) {
+            console.log(`  [${a.id}] ${a.ruleId || "(any)"}  by ${a.author}  ${a.createdAt.slice(0, 10)}`);
+            console.log(`    ${a.note}`);
+        }
+        console.log("═".repeat(65));
+    }
+    else if (sub === "remove") {
+        const id = args.find((_a, i) => args[i - 1] === "--id");
+        if (!id) {
+            console.error("Error: --id required");
+            process.exitCode = 1;
+            return;
+        }
+        const filtered = annotations.filter((a) => a.id !== id);
+        if (filtered.length === annotations.length) {
+            console.error(`Annotation "${id}" not found.`);
+            process.exitCode = 1;
+            return;
+        }
+        saveAnnotations(filtered);
+        console.log(`Removed annotation: ${id}`);
+    }
+    else if (sub === "clear") {
+        const file = args.find((_a, i) => args[i - 1] === "--file");
+        if (file) {
+            const filtered = annotations.filter((a) => a.targetFile !== file);
+            saveAnnotations(filtered);
+            console.log(`Cleared annotations for: ${file}`);
+        }
+        else {
+            saveAnnotations([]);
+            console.log("All annotations cleared.");
+        }
+    }
+    else if (sub === "export") {
+        const format = args.find((_a, i) => args[i - 1] === "--format") || "json";
+        if (format === "json") {
+            console.log(JSON.stringify(annotations, null, 2));
+        }
+        else {
+            for (const a of annotations) {
+                console.log(`${a.id}\t${a.ruleId}\t${a.author}\t${a.note}`);
+            }
+        }
+    }
+    else {
+        console.error(`Unknown subcommand: ${sub}. Use --help for usage.`);
+        process.exitCode = 1;
+    }
+}

package/dist/commands/review-api-export.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Review-api-export — Export review data in API-compatible JSON format.
+ */
+export declare function runReviewApiExport(argv: string[]): void;

package/dist/commands/review-api-export.js

@@ -0,0 +1,98 @@
+/**
+ * Review-api-export — Export review data in API-compatible JSON format.
+ */
+import { readFileSync, writeFileSync, existsSync, readdirSync } from "fs";
+import { join } from "path";
+// ─── CLI ────────────────────────────────────────────────────────────────────
+export function runReviewApiExport(argv) {
+    const fileIdx = argv.indexOf("--file");
+    const dirIdx = argv.indexOf("--dir");
+    const outputIdx = argv.indexOf("--output");
+    const filePath = fileIdx >= 0 ? argv[fileIdx + 1] : undefined;
+    const dirPath = dirIdx >= 0 ? argv[dirIdx + 1] : undefined;
+    const outputPath = outputIdx >= 0 ? argv[outputIdx + 1] : undefined;
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`
+judges review-api-export — Export review data in API format
+
+Usage:
+  judges review-api-export --file <review.json> [--output <file>]
+  judges review-api-export --dir <path> [--output <file>]
+
+Options:
+  --file <path>     Single review JSON file
+  --dir <path>      Directory of review JSON files
+  --output <path>   Write API export to file
+  --help, -h        Show this help
+`);
+        return;
+    }
+    const verdicts = [];
+    if (filePath) {
+        if (!existsSync(filePath)) {
+            console.error(`Error: file not found: ${filePath}`);
+            process.exitCode = 1;
+            return;
+        }
+        try {
+            verdicts.push(JSON.parse(readFileSync(filePath, "utf-8")));
+        }
+        catch {
+            console.error(`Error: failed to parse: ${filePath}`);
+            process.exitCode = 1;
+            return;
+        }
+    }
+    else if (dirPath) {
+        if (!existsSync(dirPath)) {
+            console.error(`Error: directory not found: ${dirPath}`);
+            process.exitCode = 1;
+            return;
+        }
+        const files = readdirSync(dirPath).filter((f) => typeof f === "string" && f.endsWith(".json"));
+        for (const file of files) {
+            try {
+                const v = JSON.parse(readFileSync(join(dirPath, file), "utf-8"));
+                if (v.overallVerdict !== undefined) {
+                    verdicts.push(v);
+                }
+            }
+            catch {
+                // skip
+            }
+        }
+    }
+    else {
+        console.error("Error: --file or --dir is required");
+        process.exitCode = 1;
+        return;
+    }
+    const apiExport = {
+        version: "1.0",
+        exportedAt: new Date().toISOString(),
+        reviews: verdicts.map((v) => ({
+            verdict: v.overallVerdict,
+            score: v.overallScore,
+            findingCount: v.findings.length,
+            criticalCount: v.criticalCount,
+            highCount: v.highCount,
+            timestamp: v.timestamp ?? new Date().toISOString(),
+            findings: v.findings.map((f) => ({
+                ruleId: f.ruleId,
+                severity: f.severity,
+                title: f.title,
+                description: f.description,
+                recommendation: f.recommendation,
+                lineNumbers: f.lineNumbers,
+                confidence: f.confidence,
+            })),
+        })),
+    };
+    const output = JSON.stringify(apiExport, null, 2);
+    if (outputPath) {
+        writeFileSync(outputPath, output);
+        console.log(`API export written to ${outputPath} (${verdicts.length} review(s))`);
+        return;
+    }
+    console.log(output);
+}

package/dist/commands/review-approval-criteria.d.ts

@@ -0,0 +1 @@
+export declare function runReviewApprovalCriteria(argv: string[]): void;

package/dist/commands/review-approval-criteria.js

@@ -0,0 +1,99 @@
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+function checkApproval(verdict, criteria) {
+    const checks = [];
+    const score = verdict.overallScore ?? 0;
+    checks.push({
+        check: "Minimum score",
+        passed: score >= criteria.minScore,
+        detail: `${score} >= ${criteria.minScore}`,
+    });
+    const criticalCount = verdict.criticalCount ?? 0;
+    checks.push({
+        check: "Critical findings limit",
+        passed: criticalCount <= criteria.maxCritical,
+        detail: `${criticalCount} <= ${criteria.maxCritical}`,
+    });
+    const highCount = verdict.highCount ?? 0;
+    checks.push({
+        check: "High findings limit",
+        passed: highCount <= criteria.maxHigh,
+        detail: `${highCount} <= ${criteria.maxHigh}`,
+    });
+    if (criteria.requirePass) {
+        checks.push({
+            check: "Overall verdict pass",
+            passed: verdict.overallVerdict === "pass",
+            detail: `verdict: ${verdict.overallVerdict}`,
+        });
+    }
+    const approved = checks.every((c) => c.passed);
+    return { approved, criteria, checks };
+}
+export function runReviewApprovalCriteria(argv) {
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`Usage: judges review-approval-criteria [options]
+
+Check review against approval criteria.
+
+Options:
+  --report <path>        Path to verdict JSON file
+  --config <path>        Path to criteria config JSON
+  --min-score <n>        Minimum score (default: 70)
+  --max-critical <n>     Max critical findings (default: 0)
+  --max-high <n>         Max high findings (default: 3)
+  --require-pass         Require overall pass verdict
+  --format <fmt>         Output format: table (default) or json
+  -h, --help             Show this help message`);
+        return;
+    }
+    const formatIdx = argv.indexOf("--format");
+    const format = formatIdx !== -1 && argv[formatIdx + 1] ? argv[formatIdx + 1] : "table";
+    const reportIdx = argv.indexOf("--report");
+    const reportPath = reportIdx !== -1 && argv[reportIdx + 1]
+        ? join(process.cwd(), argv[reportIdx + 1])
+        : join(process.cwd(), ".judges", "last-verdict.json");
+    if (!existsSync(reportPath)) {
+        console.log(`No report found at: ${reportPath}`);
+        return;
+    }
+    let criteria = {
+        minScore: 70,
+        maxCritical: 0,
+        maxHigh: 3,
+        requirePass: false,
+    };
+    const configIdx = argv.indexOf("--config");
+    if (configIdx !== -1 && argv[configIdx + 1]) {
+        const configPath = join(process.cwd(), argv[configIdx + 1]);
+        if (existsSync(configPath)) {
+            criteria = { ...criteria, ...JSON.parse(readFileSync(configPath, "utf-8")) };
+        }
+    }
+    const minScoreIdx = argv.indexOf("--min-score");
+    if (minScoreIdx !== -1 && argv[minScoreIdx + 1]) {
+        criteria.minScore = parseInt(argv[minScoreIdx + 1], 10);
+    }
+    const maxCritIdx = argv.indexOf("--max-critical");
+    if (maxCritIdx !== -1 && argv[maxCritIdx + 1]) {
+        criteria.maxCritical = parseInt(argv[maxCritIdx + 1], 10);
+    }
+    const maxHighIdx = argv.indexOf("--max-high");
+    if (maxHighIdx !== -1 && argv[maxHighIdx + 1]) {
+        criteria.maxHigh = parseInt(argv[maxHighIdx + 1], 10);
+    }
+    if (argv.includes("--require-pass")) {
+        criteria.requirePass = true;
+    }
+    const verdict = JSON.parse(readFileSync(reportPath, "utf-8"));
+    const result = checkApproval(verdict, criteria);
+    if (format === "json") {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    console.log(`\n=== Approval Check: ${result.approved ? "APPROVED" : "BLOCKED"} ===\n`);
+    for (const check of result.checks) {
+        const icon = check.passed ? "✓" : "✗";
+        console.log(`  ${icon} ${check.check}: ${check.detail}`);
+    }
+}

package/dist/commands/review-approval-gate.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Review-approval-gate — Gate reviews with configurable approval criteria.
+ *
+ * Evaluates whether a review verdict meets predefined quality gates
+ * and provides pass/fail determination for CI/CD integration.
+ */
+export declare function runReviewApprovalGate(argv: string[]): void;

package/dist/commands/review-approval-gate.js

@@ -0,0 +1,190 @@
+/**
+ * Review-approval-gate — Gate reviews with configurable approval criteria.
+ *
+ * Evaluates whether a review verdict meets predefined quality gates
+ * and provides pass/fail determination for CI/CD integration.
+ */
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { dirname, join } from "path";
+// ─── Helpers ────────────────────────────────────────────────────────────────
+function gateFile() {
+    return join(process.cwd(), ".judges", "approval-gates.json");
+}
+function loadGates() {
+    const f = gateFile();
+    if (!existsSync(f))
+        return [];
+    try {
+        return JSON.parse(readFileSync(f, "utf-8"));
+    }
+    catch {
+        return [];
+    }
+}
+function saveGates(gates) {
+    const f = gateFile();
+    const d = dirname(f);
+    if (!existsSync(d))
+        mkdirSync(d, { recursive: true });
+    writeFileSync(f, JSON.stringify(gates, null, 2));
+}
+function evaluateGate(verdict, gate) {
+    const reasons = [];
+    let passed = true;
+    if (verdict.criticalCount > gate.maxCritical) {
+        passed = false;
+        reasons.push(`Critical findings: ${verdict.criticalCount} > max ${gate.maxCritical}`);
+    }
+    if (verdict.highCount > gate.maxHigh) {
+        passed = false;
+        reasons.push(`High findings: ${verdict.highCount} > max ${gate.maxHigh}`);
+    }
+    if (verdict.overallScore < gate.minScore) {
+        passed = false;
+        reasons.push(`Score: ${verdict.overallScore} < min ${gate.minScore}`);
+    }
+    if (verdict.findings.length > gate.maxTotal) {
+        passed = false;
+        reasons.push(`Total findings: ${verdict.findings.length} > max ${gate.maxTotal}`);
+    }
+    if (gate.requiredVerdict !== "any" && verdict.overallVerdict !== gate.requiredVerdict) {
+        passed = false;
+        reasons.push(`Verdict: ${verdict.overallVerdict} !== required ${gate.requiredVerdict}`);
+    }
+    if (passed)
+        reasons.push("All criteria met");
+    return { gateName: gate.name, passed, reasons };
+}
+// ─── CLI ────────────────────────────────────────────────────────────────────
+export function runReviewApprovalGate(argv) {
+    const sub = argv[0];
+    if (!sub || sub === "--help" || sub === "-h") {
+        console.log(`
+judges review-approval-gate — Configurable review approval gates
+
+Usage:
+  judges review-approval-gate add     --name <name> [gate options]
+  judges review-approval-gate remove  --name <name>
+  judges review-approval-gate list
+  judges review-approval-gate check   --file <verdict.json> [--format table|json]
+  judges review-approval-gate clear
+
+Gate Options:
+  --max-critical <n>     Max critical findings allowed (default: 0)
+  --max-high <n>         Max high findings allowed (default: 5)
+  --min-score <n>        Minimum score required (default: 50)
+  --max-total <n>        Max total findings allowed (default: 50)
+  --require-verdict <v>  Required verdict: pass, fail, any (default: any)
+  --help, -h             Show this help
+`);
+        return;
+    }
+    const args = argv.slice(1);
+    if (sub === "add") {
+        const nameIdx = args.indexOf("--name");
+        const name = nameIdx >= 0 ? args[nameIdx + 1] : undefined;
+        if (!name) {
+            console.error("Error: --name required");
+            process.exitCode = 1;
+            return;
+        }
+        const maxCritIdx = args.indexOf("--max-critical");
+        const maxHighIdx = args.indexOf("--max-high");
+        const minScoreIdx = args.indexOf("--min-score");
+        const maxTotalIdx = args.indexOf("--max-total");
+        const reqIdx = args.indexOf("--require-verdict");
+        const gate = {
+            name,
+            maxCritical: maxCritIdx >= 0 ? parseInt(args[maxCritIdx + 1], 10) : 0,
+            maxHigh: maxHighIdx >= 0 ? parseInt(args[maxHighIdx + 1], 10) : 5,
+            minScore: minScoreIdx >= 0 ? parseInt(args[minScoreIdx + 1], 10) : 50,
+            maxTotal: maxTotalIdx >= 0 ? parseInt(args[maxTotalIdx + 1], 10) : 50,
+            requiredVerdict: reqIdx >= 0 ? args[reqIdx + 1] : "any",
+        };
+        const gates = loadGates().filter((g) => g.name !== name);
+        gates.push(gate);
+        saveGates(gates);
+        console.log(`Gate added: ${name}`);
+    }
+    else if (sub === "remove") {
+        const nameIdx = args.indexOf("--name");
+        const name = nameIdx >= 0 ? args[nameIdx + 1] : undefined;
+        if (!name) {
+            console.error("Error: --name required");
+            process.exitCode = 1;
+            return;
+        }
+        const gates = loadGates().filter((g) => g.name !== name);
+        saveGates(gates);
+        console.log(`Gate removed: ${name}`);
+    }
+    else if (sub === "list") {
+        const gates = loadGates();
+        if (gates.length === 0) {
+            console.log("No approval gates configured.");
+            return;
+        }
+        console.log(`\nApproval Gates (${gates.length})`);
+        console.log("═".repeat(60));
+        for (const g of gates) {
+            console.log(`  ${g.name}: max-crit=${g.maxCritical} max-high=${g.maxHigh} min-score=${g.minScore} max-total=${g.maxTotal} verdict=${g.requiredVerdict}`);
+        }
+        console.log("═".repeat(60));
+    }
+    else if (sub === "check") {
+        const fileIdx = args.indexOf("--file");
+        const formatIdx = args.indexOf("--format");
+        const filePath = fileIdx >= 0 ? args[fileIdx + 1] : undefined;
+        const format = formatIdx >= 0 ? args[formatIdx + 1] : "table";
+        if (!filePath) {
+            console.error("Error: --file required");
+            process.exitCode = 1;
+            return;
+        }
+        if (!existsSync(filePath)) {
+            console.error(`Error: not found: ${filePath}`);
+            process.exitCode = 1;
+            return;
+        }
+        const gates = loadGates();
+        if (gates.length === 0) {
+            console.error("Error: no gates configured. Use 'add' first.");
+            process.exitCode = 1;
+            return;
+        }
+        let verdict;
+        try {
+            verdict = JSON.parse(readFileSync(filePath, "utf-8"));
+        }
+        catch {
+            console.error("Error: invalid JSON");
+            process.exitCode = 1;
+            return;
+        }
+        const results = gates.map((g) => evaluateGate(verdict, g));
+        if (format === "json") {
+            console.log(JSON.stringify(results, null, 2));
+            return;
+        }
+        const allPassed = results.every((r) => r.passed);
+        console.log(`\nApproval Gate Results: ${allPassed ? "APPROVED" : "BLOCKED"}`);
+        console.log("═".repeat(60));
+        for (const r of results) {
+            const status = r.passed ? "PASS" : "FAIL";
+            console.log(`\n  [${status}] ${r.gateName}`);
+            for (const reason of r.reasons)
+                console.log(`    ${reason}`);
+        }
+        console.log("\n" + "═".repeat(60));
+        if (!allPassed)
+            process.exitCode = 1;
+    }
+    else if (sub === "clear") {
+        saveGates([]);
+        console.log("Approval gates cleared.");
+    }
+    else {
+        console.error(`Unknown subcommand: ${sub}. Use --help for usage.`);
+        process.exitCode = 1;
+    }
+}

package/dist/commands/review-approval.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Review-approval — Approval workflows for review results.
+ */
+export declare function runReviewApproval(argv: string[]): void;