@kevinrabun/judges-cli 3.124.0

package/dist/commands/review-code-health-score.js

@@ -0,0 +1,100 @@
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+function computeHealthScore(verdict) {
+    const findings = verdict.findings ?? [];
+    const total = findings.length;
+    const severityWeights = {
+        critical: 10,
+        high: 7,
+        medium: 4,
+        low: 2,
+        info: 0.5,
+    };
+    let severitySum = 0;
+    let confidenceSum = 0;
+    for (const f of findings) {
+        severitySum += severityWeights[f.severity] ?? 1;
+        confidenceSum += f.confidence ?? 0.5;
+    }
+    const maxSeverity = total * 10;
+    const severityScore = maxSeverity > 0 ? Math.max(0, 100 - (severitySum / maxSeverity) * 100) : 100;
+    const densityScore = total === 0 ? 100 : Math.max(0, 100 - total * 5);
+    const avgConfidence = total > 0 ? confidenceSum / total : 1;
+    const confidenceScore = avgConfidence * 100;
+    const passRateScore = verdict.overallVerdict === "pass" ? 100 : verdict.overallVerdict === "warning" ? 60 : 20;
+    const overall = Math.round(severityScore * 0.35 + densityScore * 0.25 + confidenceScore * 0.2 + passRateScore * 0.2);
+    let grade;
+    if (overall >= 90)
+        grade = "A";
+    else if (overall >= 80)
+        grade = "B";
+    else if (overall >= 70)
+        grade = "C";
+    else if (overall >= 60)
+        grade = "D";
+    else
+        grade = "F";
+    const recommendations = [];
+    if (severityScore < 50)
+        recommendations.push("Address critical/high severity findings urgently");
+    if (densityScore < 50)
+        recommendations.push("High finding density — consider breaking into smaller changes");
+    if (confidenceScore < 60)
+        recommendations.push("Low confidence findings — manual validation recommended");
+    if (passRateScore < 50)
+        recommendations.push("Review failing — resolve blockers before merge");
+    if (overall >= 90)
+        recommendations.push("Excellent code health — safe to proceed");
+    return {
+        overall,
+        grade,
+        breakdown: {
+            severityScore: Math.round(severityScore),
+            densityScore: Math.round(densityScore),
+            confidenceScore: Math.round(confidenceScore),
+            passRateScore: Math.round(passRateScore),
+        },
+        recommendations,
+    };
+}
+export function runReviewCodeHealthScore(argv) {
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`Usage: judges review-code-health-score [options]
+
+Compute aggregated code health score from review verdicts.
+
+Options:
+  --report <path>    Path to verdict JSON file
+  --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}`);
+        console.log("Run a review first or provide --report.");
+        return;
+    }
+    const verdict = JSON.parse(readFileSync(reportPath, "utf-8"));
+    const health = computeHealthScore(verdict);
+    if (format === "json") {
+        console.log(JSON.stringify(health, null, 2));
+        return;
+    }
+    console.log("\n=== Code Health Score ===\n");
+    console.log(`Overall: ${health.overall}/100 (Grade: ${health.grade})\n`);
+    console.log("Breakdown:");
+    console.log(`  Severity:   ${health.breakdown.severityScore}/100`);
+    console.log(`  Density:    ${health.breakdown.densityScore}/100`);
+    console.log(`  Confidence: ${health.breakdown.confidenceScore}/100`);
+    console.log(`  Pass Rate:  ${health.breakdown.passRateScore}/100`);
+    console.log("\nRecommendations:");
+    for (const r of health.recommendations) {
+        console.log(`  → ${r}`);
+    }
+}

package/dist/commands/review-code-owner.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Review-code-owner — Map findings to CODEOWNERS entries.
+ *
+ * Cross-references findings with CODEOWNERS file to identify
+ * responsible teams/individuals for each finding.
+ */
+export declare function runReviewCodeOwner(argv: string[]): void;

package/dist/commands/review-code-owner.js

@@ -0,0 +1,164 @@
+/**
+ * Review-code-owner — Map findings to CODEOWNERS entries.
+ *
+ * Cross-references findings with CODEOWNERS file to identify
+ * responsible teams/individuals for each finding.
+ */
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+// ─── Helpers ────────────────────────────────────────────────────────────────
+function parseCodeowners(content) {
+    const rules = [];
+    for (const line of content.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#"))
+            continue;
+        const parts = trimmed.split(/\s+/);
+        if (parts.length >= 2) {
+            rules.push({ pattern: parts[0], owners: parts.slice(1) });
+        }
+    }
+    return rules;
+}
+function findCodeownersFile() {
+    const candidates = [
+        join(process.cwd(), "CODEOWNERS"),
+        join(process.cwd(), ".github", "CODEOWNERS"),
+        join(process.cwd(), "docs", "CODEOWNERS"),
+    ];
+    for (const c of candidates) {
+        if (existsSync(c))
+            return c;
+    }
+    return null;
+}
+function matchPattern(filePath, pattern) {
+    if (pattern === "*")
+        return true;
+    if (pattern.endsWith("/"))
+        return filePath.startsWith(pattern) || filePath.includes("/" + pattern);
+    if (pattern.startsWith("*."))
+        return filePath.endsWith(pattern.slice(1));
+    if (pattern.includes("*")) {
+        const prefix = pattern.split("*")[0];
+        return filePath.startsWith(prefix) || filePath.includes(prefix);
+    }
+    return filePath.includes(pattern);
+}
+function inferFilePath(title) {
+    const match = title.match(/in\s+[`']?(\S+\.\w{1,5})[`']?/i);
+    return match ? match[1] : "";
+}
+// ─── CLI ────────────────────────────────────────────────────────────────────
+export function runReviewCodeOwner(argv) {
+    const verdictIdx = argv.indexOf("--verdict");
+    const ownersIdx = argv.indexOf("--owners");
+    const formatIdx = argv.indexOf("--format");
+    const verdictPath = verdictIdx >= 0 ? argv[verdictIdx + 1] : undefined;
+    const ownersPath = ownersIdx >= 0 ? argv[ownersIdx + 1] : findCodeownersFile();
+    const format = formatIdx >= 0 ? argv[formatIdx + 1] : "table";
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`
+judges review-code-owner — Map findings to CODEOWNERS
+
+Usage:
+  judges review-code-owner --verdict <verdict.json> [--owners <CODEOWNERS>]
+                            [--format table|json]
+
+Options:
+  --verdict <path>   Path to verdict JSON file (required)
+  --owners <path>    Path to CODEOWNERS file (auto-detected)
+  --format <fmt>     Output format: table (default), json
+  --help, -h         Show this help
+`);
+        return;
+    }
+    if (!verdictPath) {
+        console.error("Error: --verdict required");
+        process.exitCode = 1;
+        return;
+    }
+    if (!existsSync(verdictPath)) {
+        console.error(`Error: verdict not found: ${verdictPath}`);
+        process.exitCode = 1;
+        return;
+    }
+    if (!ownersPath) {
+        console.error("Error: CODEOWNERS file not found. Use --owners to specify.");
+        process.exitCode = 1;
+        return;
+    }
+    if (!existsSync(ownersPath)) {
+        console.error(`Error: CODEOWNERS not found: ${ownersPath}`);
+        process.exitCode = 1;
+        return;
+    }
+    let verdict;
+    try {
+        verdict = JSON.parse(readFileSync(verdictPath, "utf-8"));
+    }
+    catch {
+        console.error("Error: invalid verdict JSON");
+        process.exitCode = 1;
+        return;
+    }
+    const rules = parseCodeowners(readFileSync(ownersPath, "utf-8"));
+    const results = [];
+    for (const f of verdict.findings) {
+        const filePath = inferFilePath(f.title);
+        let matched = false;
+        // Match against CODEOWNERS rules (last match wins, per GitHub convention)
+        for (let i = rules.length - 1; i >= 0; i--) {
+            if (filePath && matchPattern(filePath, rules[i].pattern)) {
+                results.push({
+                    ruleId: f.ruleId,
+                    title: f.title,
+                    severity: f.severity || "medium",
+                    owners: rules[i].owners,
+                    matchedPattern: rules[i].pattern,
+                });
+                matched = true;
+                break;
+            }
+        }
+        if (!matched) {
+            // Check for wildcard default owner
+            const defaultRule = rules.find((r) => r.pattern === "*");
+            results.push({
+                ruleId: f.ruleId,
+                title: f.title,
+                severity: f.severity || "medium",
+                owners: defaultRule ? defaultRule.owners : ["unassigned"],
+                matchedPattern: defaultRule ? "*" : "none",
+            });
+        }
+    }
+    if (format === "json") {
+        console.log(JSON.stringify(results, null, 2));
+        return;
+    }
+    console.log(`\nFinding Ownership (${results.length} findings)`);
+    console.log("═".repeat(70));
+    console.log(`${"Owner(s)".padEnd(25)} ${"Severity".padEnd(10)} Title`);
+    console.log("─".repeat(70));
+    for (const r of results) {
+        const owners = r.owners.join(", ");
+        const ownerStr = owners.length > 23 ? owners.slice(0, 23) + "…" : owners;
+        const sev = (r.severity || "medium").padEnd(10);
+        const title = r.title.length > 30 ? r.title.slice(0, 30) + "…" : r.title;
+        console.log(`${ownerStr.padEnd(25)} ${sev} ${title}`);
+    }
+    // Owner summary
+    const ownerCounts = new Map();
+    for (const r of results) {
+        for (const o of r.owners) {
+            ownerCounts.set(o, (ownerCounts.get(o) || 0) + 1);
+        }
+    }
+    console.log("\n" + "─".repeat(70));
+    console.log("Owner Summary:");
+    for (const [owner, count] of [...ownerCounts.entries()].sort((a, b) => b[1] - a[1])) {
+        console.log(`  ${owner}: ${count} finding(s)`);
+    }
+    console.log("═".repeat(70));
+}

package/dist/commands/review-code-ownership.d.ts

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

package/dist/commands/review-code-ownership.js

@@ -0,0 +1,88 @@
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+function matchOwner(ruleId, rules) {
+    for (const rule of rules) {
+        if (ruleId.toUpperCase().startsWith(rule.pattern.toUpperCase())) {
+            return rule.owners;
+        }
+    }
+    return ["unassigned"];
+}
+function mapOwnership(findings, ownerRules) {
+    const ownerMap = new Map();
+    for (const f of findings) {
+        const owners = matchOwner(f.ruleId, ownerRules);
+        for (const owner of owners) {
+            const list = ownerMap.get(owner) ?? [];
+            list.push({ ruleId: f.ruleId, title: f.title, severity: f.severity });
+            ownerMap.set(owner, list);
+        }
+    }
+    const mappings = [];
+    for (const [owner, ownerFindings] of ownerMap) {
+        const criticalCount = ownerFindings.filter((f) => f.severity === "critical").length;
+        mappings.push({
+            owner,
+            findingCount: ownerFindings.length,
+            criticalCount,
+            findings: ownerFindings,
+        });
+    }
+    mappings.sort((a, b) => b.findingCount - a.findingCount);
+    return mappings;
+}
+export function runReviewCodeOwnership(argv) {
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`Usage: judges review-code-ownership [options]
+
+Map findings to code owners.
+
+Options:
+  --report <path>      Path to verdict JSON file
+  --owners <path>      Path to ownership rules JSON
+  --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");
+    const ownIdx = argv.indexOf("--owners");
+    const ownPath = ownIdx !== -1 && argv[ownIdx + 1]
+        ? join(process.cwd(), argv[ownIdx + 1])
+        : join(process.cwd(), ".judges", "code-owners.json");
+    if (!existsSync(reportPath)) {
+        console.log(`No report found at: ${reportPath}`);
+        return;
+    }
+    const data = JSON.parse(readFileSync(reportPath, "utf-8"));
+    const findings = data.findings ?? [];
+    let ownerRules;
+    if (existsSync(ownPath)) {
+        const ownData = JSON.parse(readFileSync(ownPath, "utf-8"));
+        ownerRules = ownData.rules ?? [];
+    }
+    else {
+        ownerRules = [
+            { pattern: "SEC", owners: ["security-team"] },
+            { pattern: "PERF", owners: ["performance-team"] },
+        ];
+        console.log(`No ownership config found. Using defaults.\nCreate ${ownPath} for custom mappings.\n`);
+    }
+    const mappings = mapOwnership(findings, ownerRules);
+    if (format === "json") {
+        console.log(JSON.stringify(mappings, null, 2));
+        return;
+    }
+    console.log("\n=== Code Ownership ===\n");
+    for (const m of mappings) {
+        console.log(`${m.owner}: ${m.findingCount} findings (${m.criticalCount} critical)`);
+        for (const f of m.findings) {
+            console.log(`  [${f.severity.toUpperCase()}] ${f.ruleId}: ${f.title}`);
+        }
+        console.log();
+    }
+}

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

@@ -0,0 +1,4 @@
+/**
+ * Review-comment — Generate inline source code comments from review findings.
+ */
+export declare function runReviewComment(argv: string[]): void;

package/dist/commands/review-comment.js

@@ -0,0 +1,165 @@
+/**
+ * Review-comment — Generate inline source code comments from review findings.
+ */
+import { readFileSync, writeFileSync, existsSync } from "fs";
+const COMMENT_STYLES = {
+    javascript: { line: "//", blockStart: "/*", blockEnd: "*/" },
+    typescript: { line: "//", blockStart: "/*", blockEnd: "*/" },
+    python: { line: "#", blockStart: '"""', blockEnd: '"""' },
+    ruby: { line: "#", blockStart: "=begin", blockEnd: "=end" },
+    java: { line: "//", blockStart: "/*", blockEnd: "*/" },
+    csharp: { line: "//", blockStart: "/*", blockEnd: "*/" },
+    go: { line: "//", blockStart: "/*", blockEnd: "*/" },
+    rust: { line: "//", blockStart: "/*", blockEnd: "*/" },
+    cpp: { line: "//", blockStart: "/*", blockEnd: "*/" },
+    c: { line: "//", blockStart: "/*", blockEnd: "*/" },
+};
+function getCommentStyle(lang) {
+    return COMMENT_STYLES[lang.toLowerCase()] || COMMENT_STYLES["javascript"];
+}
+function formatComment(finding, style, commentStyle) {
+    const severity = (finding.severity || "info").toUpperCase();
+    const rule = finding.ruleId || "JUDGES";
+    const title = finding.title || "Finding";
+    if (commentStyle === "line") {
+        const lines = [`${style.line} JUDGES [${severity}] ${rule}: ${title}`];
+        if (finding.recommendation) {
+            lines.push(`${style.line}   Fix: ${finding.recommendation}`);
+        }
+        return lines.join("\n");
+    }
+    if (commentStyle === "jsdoc") {
+        const lines = [`/** JUDGES [${severity}] ${rule}: ${title}`];
+        if (finding.recommendation) {
+            lines.push(` *  Fix: ${finding.recommendation}`);
+        }
+        lines.push(" */");
+        return lines.join("\n");
+    }
+    // block
+    const lines = [`/* JUDGES [${severity}] ${rule}: ${title}`];
+    if (finding.recommendation) {
+        lines.push(`   Fix: ${finding.recommendation}`);
+    }
+    lines.push("*/");
+    return lines.join("\n");
+}
+function generateComments(findings, lang, style) {
+    const cs = getCommentStyle(lang);
+    const blocks = [];
+    for (const f of findings) {
+        const line = f.lineNumbers && f.lineNumbers.length > 0 ? f.lineNumbers[0] : 1;
+        blocks.push({ line, text: formatComment(f, cs, style) });
+    }
+    // Sort by line descending so insertions don't shift subsequent lines
+    blocks.sort((a, b) => b.line - a.line);
+    return blocks;
+}
+// ─── CLI ────────────────────────────────────────────────────────────────────
+export function runReviewComment(argv) {
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`
+judges review-comment — Generate inline code comments from findings
+
+Usage:
+  judges review-comment --verdict verdict.json --source app.ts
+  judges review-comment --verdict verdict.json --source app.py --lang python
+  judges review-comment --verdict verdict.json --preview
+
+Options:
+  --verdict <path>       Verdict JSON file
+  --source <path>        Source file to annotate (optional; preview without)
+  --lang <language>      Language (auto-detected from extension)
+  --style line|block|jsdoc  Comment style (default: line)
+  --output <path>        Write annotated file to path (default: modifies in-place)
+  --preview              Show comments without modifying files
+  --min-severity <sev>   Only include findings at this severity or above
+  --format json          JSON output
+  --help, -h             Show this help
+
+Generates inline code comments from review findings. Comments include
+severity, rule ID, title, and fix recommendation.
+`);
+        return;
+    }
+    const format = argv.find((_a, i) => argv[i - 1] === "--format") || "text";
+    const verdictFile = argv.find((_a, i) => argv[i - 1] === "--verdict");
+    const sourceFile = argv.find((_a, i) => argv[i - 1] === "--source");
+    const lang = argv.find((_a, i) => argv[i - 1] === "--lang") || "";
+    const styleArg = argv.find((_a, i) => argv[i - 1] === "--style") || "line";
+    const outputFile = argv.find((_a, i) => argv[i - 1] === "--output");
+    const preview = argv.includes("--preview");
+    const minSev = argv.find((_a, i) => argv[i - 1] === "--min-severity");
+    if (!verdictFile) {
+        console.error("Error: --verdict is required.");
+        process.exitCode = 1;
+        return;
+    }
+    if (!existsSync(verdictFile)) {
+        console.error(`Error: File not found: ${verdictFile}`);
+        process.exitCode = 1;
+        return;
+    }
+    let verdict;
+    try {
+        verdict = JSON.parse(readFileSync(verdictFile, "utf-8"));
+    }
+    catch {
+        console.error(`Error: Could not parse ${verdictFile}`);
+        process.exitCode = 1;
+        return;
+    }
+    let findings = verdict.findings || [];
+    // Severity filter
+    if (minSev) {
+        const sevOrder = { critical: 4, high: 3, medium: 2, low: 1, info: 0 };
+        const threshold = sevOrder[minSev.toLowerCase()] ?? 0;
+        findings = findings.filter((f) => (sevOrder[(f.severity || "").toLowerCase()] ?? 0) >= threshold);
+    }
+    // Detect language from source file extension
+    const detectedLang = lang || (sourceFile ? sourceFile.split(".").pop() || "ts" : "ts");
+    const languageMap = {
+        ts: "typescript",
+        js: "javascript",
+        py: "python",
+        rb: "ruby",
+        java: "java",
+        cs: "csharp",
+        go: "go",
+        rs: "rust",
+        cpp: "cpp",
+        c: "c",
+    };
+    const resolvedLang = languageMap[detectedLang] || detectedLang;
+    const commentStyle = (["line", "block", "jsdoc"].includes(styleArg) ? styleArg : "line");
+    const comments = generateComments(findings, resolvedLang, commentStyle);
+    if (format === "json") {
+        console.log(JSON.stringify({ language: resolvedLang, style: commentStyle, comments }, null, 2));
+        return;
+    }
+    if (preview || !sourceFile) {
+        console.log(`\n  Review Comments Preview (${resolvedLang}, ${commentStyle} style)\n  ─────────────────────────────`);
+        for (const c of [...comments].reverse()) {
+            console.log(`\n  Line ${c.line}:`);
+            for (const line of c.text.split("\n")) {
+                console.log(`    ${line}`);
+            }
+        }
+        console.log(`\n  Total: ${comments.length} comment(s)\n`);
+        return;
+    }
+    // Insert comments into source file
+    if (!existsSync(sourceFile)) {
+        console.error(`Error: Source file not found: ${sourceFile}`);
+        process.exitCode = 1;
+        return;
+    }
+    const sourceLines = readFileSync(sourceFile, "utf-8").split("\n");
+    for (const c of comments) {
+        const insertAt = Math.max(0, c.line - 1);
+        sourceLines.splice(insertAt, 0, c.text);
+    }
+    const dest = outputFile || sourceFile;
+    writeFileSync(dest, sourceLines.join("\n"), "utf-8");
+    console.log(`Inserted ${comments.length} comment(s) into ${dest}`);
+}

package/dist/commands/review-commit-hook.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Review-commit-hook — Generate git commit hook configuration for Judges.
+ *
+ * Creates pre-commit or pre-push hook scripts that automatically
+ * run Judges review on staged/changed files.
+ */
+export declare function runReviewCommitHook(argv: string[]): void;

package/dist/commands/review-commit-hook.js

@@ -0,0 +1,134 @@
+/**
+ * Review-commit-hook — Generate git commit hook configuration for Judges.
+ *
+ * Creates pre-commit or pre-push hook scripts that automatically
+ * run Judges review on staged/changed files.
+ */
+import { writeFileSync, existsSync, mkdirSync, chmodSync } from "fs";
+import { join } from "path";
+// ─── Helpers ────────────────────────────────────────────────────────────────
+const PRE_COMMIT_SCRIPT = `#!/bin/sh
+# Judges Panel pre-commit hook
+# Runs code review on staged files
+
+STAGED=$(git diff --cached --name-only --diff-filter=ACM | grep -E '\\.(ts|js|tsx|jsx|py|java|go|rs|cs|cpp|c|rb|php)$')
+
+if [ -z "$STAGED" ]; then
+  exit 0
+fi
+
+echo "Running Judges review on staged files..."
+
+FAILED=0
+for FILE in $STAGED; do
+  npx judges eval --file "$FILE" --fail-on-findings 2>/dev/null
+  if [ $? -ne 0 ]; then
+    FAILED=1
+  fi
+done
+
+if [ $FAILED -ne 0 ]; then
+  echo ""
+  echo "Judges found issues. Fix them or use --no-verify to skip."
+  exit 1
+fi
+
+exit 0
+`;
+const PRE_PUSH_SCRIPT = `#!/bin/sh
+# Judges Panel pre-push hook
+# Runs code review on changed files before push
+
+CHANGED=$(git diff --name-only HEAD~1 | grep -E '\\.(ts|js|tsx|jsx|py|java|go|rs|cs|cpp|c|rb|php)$')
+
+if [ -z "$CHANGED" ]; then
+  exit 0
+fi
+
+echo "Running Judges review before push..."
+
+FAILED=0
+for FILE in $CHANGED; do
+  if [ -f "$FILE" ]; then
+    npx judges eval --file "$FILE" --fail-on-findings 2>/dev/null
+    if [ $? -ne 0 ]; then
+      FAILED=1
+    fi
+  fi
+done
+
+if [ $FAILED -ne 0 ]; then
+  echo ""
+  echo "Judges found issues. Fix or use --no-verify to skip."
+  exit 1
+fi
+
+exit 0
+`;
+// ─── CLI ────────────────────────────────────────────────────────────────────
+export function runReviewCommitHook(argv) {
+    const sub = argv[0];
+    if (!sub || sub === "--help" || sub === "-h") {
+        console.log(`
+judges review-commit-hook — Set up git hooks for Judges
+
+Usage:
+  judges review-commit-hook install [--type pre-commit|pre-push|both]
+  judges review-commit-hook show    [--type pre-commit|pre-push]
+  judges review-commit-hook remove  [--type pre-commit|pre-push|both]
+
+Options:
+  --type <hook>    Hook type (default: pre-commit)
+  --help, -h       Show this help
+`);
+        return;
+    }
+    const args = argv.slice(1);
+    const typeIdx = args.indexOf("--type");
+    const hookType = typeIdx >= 0 ? args[typeIdx + 1] : "pre-commit";
+    if (sub === "install") {
+        const hooksDir = join(process.cwd(), ".git", "hooks");
+        if (!existsSync(join(process.cwd(), ".git"))) {
+            console.error("Error: not a git repository");
+            process.exitCode = 1;
+            return;
+        }
+        if (!existsSync(hooksDir))
+            mkdirSync(hooksDir, { recursive: true });
+        const types = hookType === "both" ? ["pre-commit", "pre-push"] : [hookType];
+        for (const t of types) {
+            const script = t === "pre-push" ? PRE_PUSH_SCRIPT : PRE_COMMIT_SCRIPT;
+            const hookPath = join(hooksDir, t);
+            writeFileSync(hookPath, script);
+            try {
+                chmodSync(hookPath, 0o755);
+            }
+            catch {
+                /* Windows doesn't need chmod */
+            }
+            console.log(`Installed ${t} hook: ${hookPath}`);
+        }
+    }
+    else if (sub === "show") {
+        const script = hookType === "pre-push" ? PRE_PUSH_SCRIPT : PRE_COMMIT_SCRIPT;
+        console.log(script);
+    }
+    else if (sub === "remove") {
+        const hooksDir = join(process.cwd(), ".git", "hooks");
+        const types = hookType === "both" ? ["pre-commit", "pre-push"] : [hookType];
+        for (const t of types) {
+            const hookPath = join(hooksDir, t);
+            if (existsSync(hookPath)) {
+                writeFileSync(hookPath, "#!/bin/sh\nexit 0\n");
+                console.log(`Removed ${t} hook`);
+            }
+            else {
+                console.log(`No ${t} hook found`);
+            }
+        }
+    }
+    else {
+        console.error(`Unknown subcommand: ${sub}. Use --help for usage.`);
+        process.exitCode = 1;
+    }
+}

package/dist/commands/review-commit-quality.d.ts

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