@kevinrabun/judges-cli 3.124.0

package/dist/commands/review-team-stats.js

@@ -0,0 +1,97 @@
+/**
+ * Review-team-stats — Aggregate review statistics for team visibility.
+ */
+import { readFileSync, existsSync, readdirSync } from "fs";
+// ─── Analysis ───────────────────────────────────────────────────────────────
+function computeTeamStats(verdicts) {
+    const totalReviews = verdicts.length;
+    const scores = verdicts.map((v) => v.overallScore);
+    const avgScore = Math.round(scores.reduce((a, b) => a + b, 0) / totalReviews);
+    const allFindings = verdicts.flatMap((v) => v.findings);
+    const totalFindings = allFindings.length;
+    const avgFindings = Math.round(totalFindings / totalReviews);
+    const verdictBreakdown = {};
+    for (const v of verdicts) {
+        verdictBreakdown[v.overallVerdict] = (verdictBreakdown[v.overallVerdict] || 0) + 1;
+    }
+    const ruleCounts = new Map();
+    for (const f of allFindings) {
+        ruleCounts.set(f.ruleId, (ruleCounts.get(f.ruleId) || 0) + 1);
+    }
+    const topRules = [...ruleCounts.entries()]
+        .map(([ruleId, count]) => ({ ruleId, count }))
+        .sort((a, b) => b.count - a.count)
+        .slice(0, 10);
+    const scoreDistribution = {
+        high: scores.filter((s) => s >= 80).length,
+        medium: scores.filter((s) => s >= 50 && s < 80).length,
+        low: scores.filter((s) => s < 50).length,
+    };
+    return { totalReviews, avgScore, totalFindings, avgFindings, verdictBreakdown, topRules, scoreDistribution };
+}
+// ─── CLI ────────────────────────────────────────────────────────────────────
+export function runReviewTeamStats(argv) {
+    const dirIdx = argv.indexOf("--dir");
+    const formatIdx = argv.indexOf("--format");
+    const dirPath = dirIdx >= 0 ? argv[dirIdx + 1] : undefined;
+    const format = formatIdx >= 0 ? argv[formatIdx + 1] : "table";
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`
+judges review-team-stats — Team review statistics
+
+Usage:
+  judges review-team-stats --dir <verdicts-dir> [--format table|json]
+
+Options:
+  --dir <path>         Directory of verdict JSON files (required)
+  --format <fmt>       Output format: table (default), json
+  --help, -h           Show this help
+`);
+        return;
+    }
+    if (!dirPath) {
+        console.error("Error: --dir required");
+        process.exitCode = 1;
+        return;
+    }
+    if (!existsSync(dirPath)) {
+        console.error(`Error: not found: ${dirPath}`);
+        process.exitCode = 1;
+        return;
+    }
+    const files = readdirSync(dirPath).filter((f) => f.endsWith(".json"));
+    const verdicts = [];
+    for (const file of files) {
+        try {
+            verdicts.push(JSON.parse(readFileSync(`${dirPath}/${file}`, "utf-8")));
+        }
+        catch {
+            // skip
+        }
+    }
+    if (verdicts.length === 0) {
+        console.error("Error: no valid verdict files found");
+        process.exitCode = 1;
+        return;
+    }
+    const stats = computeTeamStats(verdicts);
+    if (format === "json") {
+        console.log(JSON.stringify(stats, null, 2));
+        return;
+    }
+    console.log(`\nTeam Review Stats (${stats.totalReviews} reviews)`);
+    console.log("═".repeat(55));
+    console.log(`  Avg Score:       ${stats.avgScore}`);
+    console.log(`  Total Findings:  ${stats.totalFindings}`);
+    console.log(`  Avg Findings:    ${stats.avgFindings}`);
+    console.log(`  Score Dist:      High: ${stats.scoreDistribution.high}  Med: ${stats.scoreDistribution.medium}  Low: ${stats.scoreDistribution.low}`);
+    console.log(`  Verdicts:        ${Object.entries(stats.verdictBreakdown)
+        .map(([v, c]) => `${v}:${c}`)
+        .join(", ")}`);
+    console.log(`\n  Top Rules:`);
+    for (const r of stats.topRules) {
+        const rule = r.ruleId.length > 30 ? r.ruleId.slice(0, 30) + "…" : r.ruleId;
+        console.log(`    ${rule.padEnd(32)} ${r.count}`);
+    }
+    console.log("═".repeat(55));
+}

package/dist/commands/review-team-summary.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Review-team-summary — Aggregate team review metrics.
+ */
+export declare function runReviewTeamSummary(argv: string[]): void;

package/dist/commands/review-team-summary.js

@@ -0,0 +1,155 @@
+/**
+ * Review-team-summary — Aggregate team review metrics.
+ */
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join, dirname } from "path";
+// ─── Storage ────────────────────────────────────────────────────────────────
+const STORE_FILE = join(".judges", "team-reviews.json");
+function loadStore() {
+    if (!existsSync(STORE_FILE))
+        return { version: "1.0.0", entries: [] };
+    try {
+        return JSON.parse(readFileSync(STORE_FILE, "utf-8"));
+    }
+    catch {
+        return { version: "1.0.0", entries: [] };
+    }
+}
+function saveStore(store) {
+    mkdirSync(dirname(STORE_FILE), { recursive: true });
+    writeFileSync(STORE_FILE, JSON.stringify(store, null, 2), "utf-8");
+}
+// ─── CLI ────────────────────────────────────────────────────────────────────
+export function runReviewTeamSummary(argv) {
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`
+judges review-team-summary — Aggregate team review metrics
+
+Usage:
+  judges review-team-summary                         Show team summary
+  judges review-team-summary add --reviewer alice --score 8.5 --findings 3
+  judges review-team-summary list                    List all entries
+  judges review-team-summary clear                   Clear all data
+
+Subcommands:
+  (default)             Show aggregated team summary
+  add                   Add a review entry
+  list                  List raw entries
+  clear                 Clear all team data
+
+Options:
+  --reviewer <name>     Reviewer name
+  --score <n>           Review score
+  --findings <n>        Number of findings
+  --tags <t1,t2>        Comma-separated tags
+  --days <n>            Recent activity window (default: 30)
+  --format json         JSON output
+  --help, -h            Show this help
+
+Data stored locally in .judges/team-reviews.json.
+Note: Judges does not store or process user data — all team data
+is local and managed by the user.
+`);
+        return;
+    }
+    const subcommand = argv.find((a) => ["add", "list", "clear"].includes(a));
+    const format = argv.find((_a, i) => argv[i - 1] === "--format") || "text";
+    const store = loadStore();
+    if (subcommand === "add") {
+        const reviewer = argv.find((_a, i) => argv[i - 1] === "--reviewer") || "";
+        const score = parseFloat(argv.find((_a, i) => argv[i - 1] === "--score") || "0");
+        const findingCount = parseInt(argv.find((_a, i) => argv[i - 1] === "--findings") || "0", 10);
+        const tagsArg = argv.find((_a, i) => argv[i - 1] === "--tags") || "";
+        const tags = tagsArg
+            ? tagsArg
+                .split(",")
+                .map((t) => t.trim())
+                .filter(Boolean)
+            : [];
+        if (!reviewer) {
+            console.error("Error: --reviewer is required.");
+            process.exitCode = 1;
+            return;
+        }
+        store.entries.push({ reviewer, score, findingCount, date: new Date().toISOString(), tags });
+        saveStore(store);
+        console.log(`Added review entry for "${reviewer}" (score=${score}, findings=${findingCount}).`);
+        return;
+    }
+    if (subcommand === "list") {
+        if (store.entries.length === 0) {
+            console.log("No team review entries.");
+            return;
+        }
+        if (format === "json") {
+            console.log(JSON.stringify(store.entries, null, 2));
+            return;
+        }
+        console.log("\nTeam Review Entries:");
+        console.log("─".repeat(70));
+        for (const e of store.entries) {
+            console.log(`  ${e.date.slice(0, 10)}  ${e.reviewer.padEnd(15)} score=${e.score.toFixed(1)}  findings=${e.findingCount}`);
+        }
+        console.log("─".repeat(70));
+        return;
+    }
+    if (subcommand === "clear") {
+        saveStore({ version: "1.0.0", entries: [] });
+        console.log("Team review data cleared.");
+        return;
+    }
+    // Default: show summary
+    if (store.entries.length === 0) {
+        console.log("No team review data. Use 'judges review-team-summary add' to add entries.");
+        return;
+    }
+    const days = parseInt(argv.find((_a, i) => argv[i - 1] === "--days") || "30", 10);
+    const cutoff = new Date(Date.now() - days * 86400000).toISOString();
+    // Aggregate by reviewer
+    const byReviewer = new Map();
+    for (const e of store.entries) {
+        const list = byReviewer.get(e.reviewer) || [];
+        list.push(e);
+        byReviewer.set(e.reviewer, list);
+    }
+    const members = [];
+    for (const [reviewer, entries] of byReviewer) {
+        const avgScore = entries.reduce((s, e) => s + e.score, 0) / entries.length;
+        const totalFindings = entries.reduce((s, e) => s + e.findingCount, 0);
+        const lastActive = entries.sort((a, b) => b.date.localeCompare(a.date))[0].date;
+        members.push({ reviewer, reviewCount: entries.length, avgScore, totalFindings, lastActive });
+    }
+    members.sort((a, b) => b.avgScore - a.avgScore);
+    const totalReviews = store.entries.length;
+    const avgScore = store.entries.reduce((s, e) => s + e.score, 0) / totalReviews;
+    const recentActivity = store.entries.filter((e) => e.date >= cutoff).length;
+    const topPerformer = members.length > 0 ? members[0].reviewer : "N/A";
+    const report = {
+        timestamp: new Date().toISOString(),
+        teamSize: members.length,
+        totalReviews,
+        avgScore,
+        members,
+        topPerformer,
+        recentActivity,
+    };
+    if (format === "json") {
+        console.log(JSON.stringify(report, null, 2));
+        return;
+    }
+    console.log("\nTeam Review Summary:");
+    console.log("═".repeat(70));
+    console.log(`  Team size: ${members.length}  Total reviews: ${totalReviews}  Avg score: ${avgScore.toFixed(1)}`);
+    console.log(`  Recent activity (${days}d): ${recentActivity} review(s)  Top: ${topPerformer}`);
+    console.log("═".repeat(70));
+    console.log("\n  Members:");
+    console.log("  " + "─".repeat(68));
+    console.log(`  ${"Reviewer".padEnd(18)} ${"Reviews".padEnd(10)} ${"Avg Score".padEnd(12)} ${"Findings".padEnd(10)} Last Active`);
+    console.log("  " + "─".repeat(68));
+    for (const m of members) {
+        console.log(`  ${m.reviewer.padEnd(18)} ${String(m.reviewCount).padEnd(10)} ${m.avgScore.toFixed(1).padEnd(12)} ${String(m.totalFindings).padEnd(10)} ${m.lastActive.slice(0, 10)}`);
+    }
+    console.log("  " + "─".repeat(68));
+    console.log(`\n  Report saved to ${STORE_FILE}`);
+    writeFileSync(join(".judges", "team-summary.json"), JSON.stringify(report, null, 2), "utf-8");
+}

package/dist/commands/review-team-velocity.d.ts

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

package/dist/commands/review-team-velocity.js

@@ -0,0 +1,103 @@
+import { readFileSync, existsSync, readdirSync } from "fs";
+import { join } from "path";
+function computeVelocity(historyDir) {
+    const empty = {
+        totalReviews: 0,
+        periods: [],
+        avgReviewsPerPeriod: 0,
+        acceleration: "unknown",
+    };
+    if (!existsSync(historyDir))
+        return empty;
+    const files = readdirSync(historyDir)
+        .filter((f) => typeof f === "string" && f.endsWith(".json"))
+        .sort();
+    if (files.length === 0)
+        return empty;
+    // Group by month from timestamps
+    const monthMap = new Map();
+    for (const file of files) {
+        try {
+            const data = JSON.parse(readFileSync(join(historyDir, file), "utf-8"));
+            const ts = data.timestamp ?? file.replace(".json", "");
+            const month = ts.slice(0, 7) || "unknown";
+            const entry = monthMap.get(month) ?? { reviews: 0, findings: 0, scores: [], passes: 0 };
+            entry.reviews++;
+            entry.findings += (data.findings ?? []).length;
+            entry.scores.push(data.overallScore ?? 0);
+            if (data.overallVerdict === "pass")
+                entry.passes++;
+            monthMap.set(month, entry);
+        }
+        catch {
+            // Skip
+        }
+    }
+    const periods = [];
+    for (const [month, data] of monthMap) {
+        const avgScore = data.scores.length > 0 ? Math.round(data.scores.reduce((a, b) => a + b, 0) / data.scores.length) : 0;
+        periods.push({
+            period: month,
+            reviews: data.reviews,
+            findings: data.findings,
+            avgScore,
+            passRate: data.reviews > 0 ? Math.round((data.passes / data.reviews) * 100) : 0,
+        });
+    }
+    periods.sort((a, b) => a.period.localeCompare(b.period));
+    const totalReviews = periods.reduce((s, p) => s + p.reviews, 0);
+    const avgPerPeriod = periods.length > 0 ? Math.round(totalReviews / periods.length) : 0;
+    let acceleration = "stable";
+    if (periods.length >= 2) {
+        const firstHalf = periods.slice(0, Math.floor(periods.length / 2));
+        const secondHalf = periods.slice(Math.floor(periods.length / 2));
+        const firstAvg = firstHalf.reduce((s, p) => s + p.reviews, 0) / firstHalf.length;
+        const secondAvg = secondHalf.reduce((s, p) => s + p.reviews, 0) / secondHalf.length;
+        if (secondAvg > firstAvg * 1.1)
+            acceleration = "accelerating";
+        else if (secondAvg < firstAvg * 0.9)
+            acceleration = "decelerating";
+    }
+    return { totalReviews, periods, avgReviewsPerPeriod: avgPerPeriod, acceleration };
+}
+export function runReviewTeamVelocity(argv) {
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`Usage: judges review-team-velocity [options]
+
+Track team review velocity metrics.
+
+Options:
+  --history <path>     Path to review history directory
+  --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 histIdx = argv.indexOf("--history");
+    const historyDir = histIdx !== -1 && argv[histIdx + 1]
+        ? join(process.cwd(), argv[histIdx + 1])
+        : join(process.cwd(), ".judges", "history");
+    const report = computeVelocity(historyDir);
+    if (format === "json") {
+        console.log(JSON.stringify(report, null, 2));
+        return;
+    }
+    console.log(`\n=== Team Velocity (${report.totalReviews} reviews, ${report.acceleration}) ===\n`);
+    if (report.periods.length === 0) {
+        console.log("No review history found.");
+        return;
+    }
+    console.log("  " + "Period".padEnd(12) + "Reviews".padEnd(10) + "Findings".padEnd(10) + "Avg Score".padEnd(12) + "Pass Rate");
+    console.log("  " + "-".repeat(55));
+    for (const p of report.periods) {
+        console.log("  " +
+            p.period.padEnd(12) +
+            String(p.reviews).padEnd(10) +
+            String(p.findings).padEnd(10) +
+            String(p.avgScore).padEnd(12) +
+            `${p.passRate}%`);
+    }
+    console.log(`\n  Avg Reviews/Period: ${report.avgReviewsPerPeriod}`);
+    console.log(`  Trend: ${report.acceleration}`);
+}

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

@@ -0,0 +1,4 @@
+/**
+ * Review-template-export — Export review templates for reuse.
+ */
+export declare function runReviewTemplateExport(argv: string[]): void;

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

@@ -0,0 +1,146 @@
+/**
+ * Review-template-export — Export review templates for reuse.
+ */
+import { readFileSync, writeFileSync, existsSync } from "fs";
+import { defaultRegistry } from "../judge-registry.js";
+// ─── Helpers ────────────────────────────────────────────────────────────────
+function generateTemplate(name, verdict) {
+    const judges = defaultRegistry.getJudges();
+    const activeJudges = judges.map((j) => j.id);
+    const ruleOverrides = {};
+    if (verdict !== undefined) {
+        for (const f of verdict.findings) {
+            if (!ruleOverrides[f.ruleId]) {
+                ruleOverrides[f.ruleId] = (f.severity || "medium").toLowerCase();
+            }
+        }
+    }
+    return {
+        name,
+        version: 1,
+        judges: activeJudges,
+        ruleOverrides,
+        minSeverity: "low",
+        description: `Review template: ${name}`,
+        createdAt: new Date().toISOString(),
+    };
+}
+function presetTemplates() {
+    return [
+        {
+            name: "security-focused",
+            version: 1,
+            judges: ["cybersecurity", "data-security", "authentication", "api-security"],
+            ruleOverrides: {},
+            minSeverity: "medium",
+            description: "Security-focused review — only security judges active",
+            createdAt: new Date().toISOString(),
+        },
+        {
+            name: "full-review",
+            version: 1,
+            judges: defaultRegistry.getJudges().map((j) => j.id),
+            ruleOverrides: {},
+            minSeverity: "low",
+            description: "Full review with all judges active",
+            createdAt: new Date().toISOString(),
+        },
+        {
+            name: "quick-scan",
+            version: 1,
+            judges: ["cybersecurity", "code-quality"],
+            ruleOverrides: {},
+            minSeverity: "high",
+            description: "Quick scan — critical and high severity only",
+            createdAt: new Date().toISOString(),
+        },
+    ];
+}
+// ─── CLI ────────────────────────────────────────────────────────────────────
+export function runReviewTemplateExport(argv) {
+    const actionIdx = argv.indexOf("--action");
+    const nameIdx = argv.indexOf("--name");
+    const fileIdx = argv.indexOf("--file");
+    const outputIdx = argv.indexOf("--output");
+    const formatIdx = argv.indexOf("--format");
+    const action = actionIdx >= 0 ? argv[actionIdx + 1] : "list";
+    const name = nameIdx >= 0 ? argv[nameIdx + 1] : "default";
+    const filePath = fileIdx >= 0 ? argv[fileIdx + 1] : undefined;
+    const outputPath = outputIdx >= 0 ? argv[outputIdx + 1] : undefined;
+    const format = formatIdx >= 0 ? argv[formatIdx + 1] : "table";
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`
+judges review-template-export — Export review templates
+
+Usage:
+  judges review-template-export --action <action> [options]
+
+Actions:
+  list       Show preset templates (default)
+  create     Create template from verdict
+  export     Export template to file
+
+Options:
+  --action <act>     Action: list, create, export
+  --name <name>      Template name (for create)
+  --file <path>      Verdict JSON file (for create)
+  --output <path>    Output file path (for export)
+  --format <fmt>     Output format: table (default), json
+  --help, -h         Show this help
+`);
+        return;
+    }
+    if (action === "create") {
+        let verdict;
+        if (filePath && existsSync(filePath)) {
+            try {
+                verdict = JSON.parse(readFileSync(filePath, "utf-8"));
+            }
+            catch {
+                console.error("Error: invalid JSON");
+                process.exitCode = 1;
+                return;
+            }
+        }
+        const template = generateTemplate(name, verdict);
+        if (outputPath) {
+            writeFileSync(outputPath, JSON.stringify(template, null, 2));
+            console.log(`Template exported to ${outputPath}`);
+            return;
+        }
+        console.log(JSON.stringify(template, null, 2));
+        return;
+    }
+    if (action === "export") {
+        const presets = presetTemplates();
+        const target = presets.find((p) => p.name === name);
+        if (target === undefined) {
+            console.error(`Error: preset not found: ${name}`);
+            console.error(`Available: ${presets.map((p) => p.name).join(", ")}`);
+            process.exitCode = 1;
+            return;
+        }
+        if (outputPath) {
+            writeFileSync(outputPath, JSON.stringify(target, null, 2));
+            console.log(`Template "${name}" exported to ${outputPath}`);
+            return;
+        }
+        console.log(JSON.stringify(target, null, 2));
+        return;
+    }
+    // default: list
+    const presets = presetTemplates();
+    if (format === "json") {
+        console.log(JSON.stringify(presets, null, 2));
+        return;
+    }
+    console.log(`\nReview Templates`);
+    console.log("═".repeat(70));
+    console.log(`${"Name".padEnd(22)} ${"Judges".padEnd(8)} ${"Min Sev".padEnd(10)} Description`);
+    console.log("─".repeat(70));
+    for (const t of presets) {
+        const desc = t.description.length > 30 ? t.description.slice(0, 30) + "…" : t.description;
+        console.log(`${t.name.padEnd(22)} ${String(t.judges.length).padEnd(8)} ${t.minSeverity.padEnd(10)} ${desc}`);
+    }
+    console.log("═".repeat(70));
+}

package/dist/commands/review-template-library.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Review-template-library — Library of reusable review templates.
+ */
+export declare function runReviewTemplateLibrary(argv: string[]): void;

package/dist/commands/review-template-library.js

@@ -0,0 +1,155 @@
+/**
+ * Review-template-library — Library of reusable review templates.
+ */
+import { readFileSync, writeFileSync, existsSync, readdirSync } from "fs";
+import { join } from "path";
+// ─── Built-in Templates ─────────────────────────────────────────────────────
+function getBuiltinTemplates() {
+    return [
+        {
+            name: "ai-code-review",
+            description: "Optimized for reviewing AI-generated code",
+            preset: "strict",
+            minSeverity: "medium",
+            disabledRules: [],
+            tags: ["ai", "code-generation", "copilot"],
+        },
+        {
+            name: "security-audit",
+            description: "Deep security review with all severity levels",
+            preset: "security-focused",
+            minSeverity: "low",
+            disabledRules: [],
+            tags: ["security", "audit", "compliance"],
+        },
+        {
+            name: "quick-scan",
+            description: "Fast scan for critical issues only",
+            preset: "default",
+            minSeverity: "critical",
+            disabledRules: [],
+            tags: ["quick", "ci", "fast"],
+        },
+        {
+            name: "pr-review",
+            description: "Balanced review for pull requests",
+            preset: "default",
+            minSeverity: "medium",
+            disabledRules: [],
+            tags: ["pr", "pull-request", "review"],
+        },
+        {
+            name: "onboarding",
+            description: "Gentle review for new team members",
+            preset: "default",
+            minSeverity: "high",
+            disabledRules: [],
+            tags: ["onboarding", "learning", "gentle"],
+        },
+    ];
+}
+// ─── CLI ────────────────────────────────────────────────────────────────────
+export function runReviewTemplateLibrary(argv) {
+    const dirIdx = argv.indexOf("--dir");
+    const nameIdx = argv.indexOf("--name");
+    const exportIdx = argv.indexOf("--export");
+    const importIdx = argv.indexOf("--import");
+    const tagIdx = argv.indexOf("--tag");
+    const formatIdx = argv.indexOf("--format");
+    const templateDir = dirIdx >= 0 ? argv[dirIdx + 1] : join(process.cwd(), ".judges-templates");
+    const format = formatIdx >= 0 ? argv[formatIdx + 1] : "table";
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`
+judges review-template-library — Reusable review templates
+
+Usage:
+  judges review-template-library [--dir <path>] [--name <template>]
+                                 [--tag <tag>] [--export <file>]
+                                 [--import <file>] [--format table|json]
+
+Options:
+  --dir <path>       Template directory (default: .judges-templates/)
+  --name <template>  Show or use specific template
+  --tag <tag>        Filter by tag
+  --export <file>    Export template to file
+  --import <file>    Import template from file
+  --format <fmt>     Output format: table (default), json
+  --help, -h         Show this help
+`);
+        return;
+    }
+    // Import a template
+    if (importIdx >= 0) {
+        const importPath = argv[importIdx + 1];
+        if (!existsSync(importPath)) {
+            console.error(`Error: file not found: ${importPath}`);
+            process.exitCode = 1;
+            return;
+        }
+        try {
+            const template = JSON.parse(readFileSync(importPath, "utf-8"));
+            const outPath = join(templateDir, `${template.name}.json`);
+            writeFileSync(outPath, JSON.stringify(template, null, 2));
+            console.log(`Imported template "${template.name}" to ${outPath}`);
+        }
+        catch {
+            console.error(`Error: failed to parse template file: ${importPath}`);
+            process.exitCode = 1;
+        }
+        return;
+    }
+    // Collect all templates (builtin + user)
+    let templates = getBuiltinTemplates();
+    if (existsSync(templateDir)) {
+        const files = readdirSync(templateDir);
+        for (const file of files) {
+            if (typeof file === "string" && file.endsWith(".json")) {
+                try {
+                    const t = JSON.parse(readFileSync(join(templateDir, file), "utf-8"));
+                    if (t.name !== undefined) {
+                        templates = templates.filter((bt) => bt.name !== t.name);
+                        templates.push(t);
+                    }
+                }
+                catch {
+                    // skip invalid
+                }
+            }
+        }
+    }
+    // Filter by tag
+    if (tagIdx >= 0) {
+        const tag = argv[tagIdx + 1];
+        templates = templates.filter((t) => t.tags.includes(tag));
+    }
+    // Show specific template
+    const templateName = nameIdx >= 0 ? argv[nameIdx + 1] : undefined;
+    if (templateName) {
+        const template = templates.find((t) => t.name === templateName);
+        if (!template) {
+            console.error(`Error: template not found: ${templateName}`);
+            process.exitCode = 1;
+            return;
+        }
+        if (exportIdx >= 0) {
+            const exportPath = argv[exportIdx + 1];
+            writeFileSync(exportPath, JSON.stringify(template, null, 2));
+            console.log(`Exported "${template.name}" to ${exportPath}`);
+            return;
+        }
+        console.log(JSON.stringify(template, null, 2));
+        return;
+    }
+    // List all templates
+    if (format === "json") {
+        console.log(JSON.stringify(templates, null, 2));
+        return;
+    }
+    console.log(`\nReview Template Library: ${templates.length} template(s)`);
+    console.log("═".repeat(65));
+    for (const t of templates) {
+        console.log(`  ${t.name.padEnd(20)} ${t.description}`);
+        console.log(`  ${"".padEnd(20)} preset: ${t.preset}  minSeverity: ${t.minSeverity}  tags: ${t.tags.join(", ")}`);
+    }
+    console.log("═".repeat(65));
+}

package/dist/commands/review-template-suggest.d.ts

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