@kevinrabun/judges-cli 3.124.0

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

@@ -0,0 +1,211 @@
+/**
+ * Review-team-assign — Assign findings to team members.
+ *
+ * Manages team member assignments for findings based on
+ * expertise areas, load balancing, or manual assignment.
+ */
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { dirname, join } from "path";
+// ─── Helpers ────────────────────────────────────────────────────────────────
+function teamFile() {
+    return join(process.cwd(), ".judges", "team-config.json");
+}
+function assignmentFile() {
+    return join(process.cwd(), ".judges", "team-assignments.json");
+}
+function loadTeam() {
+    const f = teamFile();
+    if (!existsSync(f))
+        return [];
+    try {
+        return JSON.parse(readFileSync(f, "utf-8"));
+    }
+    catch {
+        return [];
+    }
+}
+function saveTeam(team) {
+    const f = teamFile();
+    const d = dirname(f);
+    if (!existsSync(d))
+        mkdirSync(d, { recursive: true });
+    writeFileSync(f, JSON.stringify(team, null, 2));
+}
+function loadAssignments() {
+    const f = assignmentFile();
+    if (!existsSync(f))
+        return [];
+    try {
+        return JSON.parse(readFileSync(f, "utf-8"));
+    }
+    catch {
+        return [];
+    }
+}
+function saveAssignments(assignments) {
+    const f = assignmentFile();
+    const d = dirname(f);
+    if (!existsSync(d))
+        mkdirSync(d, { recursive: true });
+    writeFileSync(f, JSON.stringify(assignments, null, 2));
+}
+function assignByExpertise(team, ruleId) {
+    const rulePrefix = ruleId.split("/")[0].toLowerCase();
+    // Find member with matching expertise (prefer least loaded)
+    const candidates = team
+        .filter((m) => m.expertise.some((e) => rulePrefix.includes(e.toLowerCase()) || e.toLowerCase().includes(rulePrefix)))
+        .sort((a, b) => a.assignedCount - b.assignedCount);
+    if (candidates.length > 0)
+        return candidates[0];
+    // Fall back to least loaded member
+    const sorted = [...team].sort((a, b) => a.assignedCount - b.assignedCount);
+    return sorted.length > 0 ? sorted[0] : null;
+}
+// ─── CLI ────────────────────────────────────────────────────────────────────
+export function runReviewTeamAssign(argv) {
+    const sub = argv[0];
+    if (!sub || sub === "--help" || sub === "-h") {
+        console.log(`
+judges review-team-assign — Assign findings to team members
+
+Usage:
+  judges review-team-assign add-member --name <name> [--expertise <areas>]
+  judges review-team-assign remove-member --name <name>
+  judges review-team-assign list-team
+  judges review-team-assign auto-assign --file <verdict.json>
+  judges review-team-assign show-assignments [--format table|json]
+  judges review-team-assign clear
+
+Options:
+  --name <name>         Team member name
+  --expertise <areas>   Comma-separated expertise areas
+  --file <path>         Verdict JSON file for auto-assignment
+  --format <fmt>        Output format: table (default), json
+  --help, -h            Show this help
+`);
+        return;
+    }
+    const args = argv.slice(1);
+    if (sub === "add-member") {
+        const nameIdx = args.indexOf("--name");
+        const expIdx = args.indexOf("--expertise");
+        const name = nameIdx >= 0 ? args[nameIdx + 1] : undefined;
+        if (!name) {
+            console.error("Error: --name required");
+            process.exitCode = 1;
+            return;
+        }
+        const expertise = expIdx >= 0 ? args[expIdx + 1].split(",") : [];
+        const team = loadTeam();
+        if (team.some((m) => m.name === name)) {
+            console.log(`Member already exists: ${name}`);
+            return;
+        }
+        team.push({ name, expertise, assignedCount: 0 });
+        saveTeam(team);
+        console.log(`Added team member: ${name} (expertise: ${expertise.join(", ") || "general"})`);
+    }
+    else if (sub === "remove-member") {
+        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 team = loadTeam().filter((m) => m.name !== name);
+        saveTeam(team);
+        console.log(`Removed: ${name}`);
+    }
+    else if (sub === "list-team") {
+        const team = loadTeam();
+        if (team.length === 0) {
+            console.log("No team members configured.");
+            return;
+        }
+        console.log(`\nTeam (${team.length} members)`);
+        console.log("═".repeat(50));
+        for (const m of team) {
+            console.log(`  ${m.name} — expertise: ${m.expertise.join(", ") || "general"} (${m.assignedCount} assigned)`);
+        }
+        console.log("═".repeat(50));
+    }
+    else if (sub === "auto-assign") {
+        const fileIdx = args.indexOf("--file");
+        const filePath = fileIdx >= 0 ? args[fileIdx + 1] : undefined;
+        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 team = loadTeam();
+        if (team.length === 0) {
+            console.error("Error: no team members. Use add-member 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 assignments = loadAssignments();
+        let newCount = 0;
+        for (const f of verdict.findings) {
+            const member = assignByExpertise(team, f.ruleId);
+            if (member) {
+                assignments.push({
+                    ruleId: f.ruleId,
+                    title: f.title,
+                    severity: f.severity || "medium",
+                    assignee: member.name,
+                    assignedAt: new Date().toISOString(),
+                });
+                member.assignedCount++;
+                newCount++;
+            }
+        }
+        saveAssignments(assignments);
+        saveTeam(team);
+        console.log(`Auto-assigned ${newCount} findings to ${team.length} team members.`);
+    }
+    else if (sub === "show-assignments") {
+        const formatIdx = args.indexOf("--format");
+        const format = formatIdx >= 0 ? args[formatIdx + 1] : "table";
+        const assignments = loadAssignments();
+        if (assignments.length === 0) {
+            console.log("No assignments.");
+            return;
+        }
+        if (format === "json") {
+            console.log(JSON.stringify(assignments, null, 2));
+            return;
+        }
+        console.log(`\nAssignments (${assignments.length})`);
+        console.log("═".repeat(70));
+        console.log(`${"Assignee".padEnd(20)} ${"Severity".padEnd(10)} Title`);
+        console.log("─".repeat(70));
+        for (const a of assignments) {
+            const title = a.title.length > 35 ? a.title.slice(0, 35) + "…" : a.title;
+            console.log(`${a.assignee.padEnd(20)} ${a.severity.padEnd(10)} ${title}`);
+        }
+        console.log("═".repeat(70));
+    }
+    else if (sub === "clear") {
+        saveAssignments([]);
+        console.log("Assignments cleared.");
+    }
+    else {
+        console.error(`Unknown subcommand: ${sub}. Use --help for usage.`);
+        process.exitCode = 1;
+    }
+}

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

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

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

@@ -0,0 +1,95 @@
+import { readFileSync, existsSync, readdirSync } from "fs";
+import { join } from "path";
+function gatherCoverage(historyDir) {
+    const reviewerMap = new Map();
+    if (!existsSync(historyDir))
+        return [];
+    const files = readdirSync(historyDir);
+    for (const file of files) {
+        if (typeof file !== "string" || !file.endsWith(".json"))
+            continue;
+        try {
+            const raw = JSON.parse(readFileSync(join(historyDir, file), "utf-8"));
+            const reviewer = raw.reviewer ?? "unassigned";
+            const existing = reviewerMap.get(reviewer) ?? {
+                reviews: 0,
+                files: new Set(),
+                findings: 0,
+                scores: [],
+                lastDate: "",
+            };
+            existing.reviews++;
+            existing.findings += (raw.findings ?? []).length;
+            existing.scores.push(raw.overallScore ?? 0);
+            for (const f of raw.filesReviewed ?? [])
+                existing.files.add(f);
+            const date = raw.timestamp ?? file.replace(".json", "");
+            if (date > existing.lastDate)
+                existing.lastDate = date;
+            reviewerMap.set(reviewer, existing);
+        }
+        catch {
+            // Skip malformed files
+        }
+    }
+    const entries = [];
+    for (const [reviewer, data] of reviewerMap) {
+        const avg = data.scores.length > 0 ? data.scores.reduce((a, b) => a + b, 0) / data.scores.length : 0;
+        entries.push({
+            reviewer,
+            reviewCount: data.reviews,
+            filesReviewed: data.files.size,
+            findingsRaised: data.findings,
+            avgScore: Math.round(avg * 100) / 100,
+            lastActive: data.lastDate,
+        });
+    }
+    entries.sort((a, b) => b.reviewCount - a.reviewCount);
+    return entries;
+}
+export function runReviewTeamCoverage(argv) {
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`Usage: judges review-team-coverage [options]
+
+Show review coverage distribution across team members.
+
+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 entries = gatherCoverage(historyDir);
+    if (format === "json") {
+        console.log(JSON.stringify(entries, null, 2));
+        return;
+    }
+    console.log(`\n=== Team Review Coverage (${entries.length} reviewers) ===\n`);
+    if (entries.length === 0) {
+        console.log("No review history found. Reviews will be tracked locally as they occur.");
+        return;
+    }
+    console.log("  " +
+        "Reviewer".padEnd(20) +
+        "Reviews".padEnd(10) +
+        "Files".padEnd(8) +
+        "Findings".padEnd(10) +
+        "Avg Score".padEnd(12) +
+        "Last Active");
+    console.log("  " + "-".repeat(75));
+    for (const e of entries) {
+        console.log("  " +
+            e.reviewer.padEnd(20) +
+            String(e.reviewCount).padEnd(10) +
+            String(e.filesReviewed).padEnd(8) +
+            String(e.findingsRaised).padEnd(10) +
+            String(e.avgScore).padEnd(12) +
+            e.lastActive);
+    }
+}

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

@@ -0,0 +1,4 @@
+/**
+ * Review-team-dashboard — Team-level review dashboard with aggregated metrics.
+ */
+export declare function runReviewTeamDashboard(argv: string[]): void;

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

@@ -0,0 +1,98 @@
+/**
+ * Review-team-dashboard — Team-level review dashboard with aggregated metrics.
+ */
+import { readFileSync, existsSync, readdirSync } from "fs";
+import { join } from "path";
+// ─── CLI ────────────────────────────────────────────────────────────────────
+export function runReviewTeamDashboard(argv) {
+    const dirIdx = argv.indexOf("--dir");
+    const formatIdx = argv.indexOf("--format");
+    const dirPath = dirIdx >= 0 ? argv[dirIdx + 1] : process.cwd();
+    const format = formatIdx >= 0 ? argv[formatIdx + 1] : "table";
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`
+judges review-team-dashboard — Team review dashboard
+
+Usage:
+  judges review-team-dashboard [--dir <path>] [--format table|json]
+
+Options:
+  --dir <path>     Directory with review JSON files (default: cwd)
+  --format <fmt>   Output format: table (default), json
+  --help, -h       Show this help
+`);
+        return;
+    }
+    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"));
+    const verdicts = [];
+    for (const file of files) {
+        try {
+            const v = JSON.parse(readFileSync(join(dirPath, file), "utf-8"));
+            if (v.overallVerdict !== undefined && v.findings !== undefined) {
+                verdicts.push(v);
+            }
+        }
+        catch {
+            // skip
+        }
+    }
+    if (verdicts.length === 0) {
+        console.log("No review files found. Generate reviews first.");
+        return;
+    }
+    const ruleCounts = {};
+    const severityCounts = {};
+    const dateCounts = {};
+    let scoreSum = 0;
+    let passCount = 0;
+    for (const v of verdicts) {
+        scoreSum += v.overallScore;
+        if (v.overallVerdict === "pass")
+            passCount++;
+        const date = v.timestamp ? v.timestamp.split("T")[0] : "unknown";
+        dateCounts[date] = (dateCounts[date] ?? 0) + 1;
+        for (const f of v.findings) {
+            ruleCounts[f.ruleId] = (ruleCounts[f.ruleId] ?? 0) + 1;
+            severityCounts[f.severity] = (severityCounts[f.severity] ?? 0) + 1;
+        }
+    }
+    const metrics = {
+        totalReviews: verdicts.length,
+        totalFindings: verdicts.reduce((s, v) => s + v.findings.length, 0),
+        avgScore: Math.round((scoreSum / verdicts.length) * 100) / 100,
+        passRate: Math.round((passCount / verdicts.length) * 100),
+        topIssues: Object.entries(ruleCounts)
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 10)
+            .map(([ruleId, count]) => ({ ruleId, count })),
+        severityTrend: severityCounts,
+        reviewsPerDay: dateCounts,
+    };
+    if (format === "json") {
+        console.log(JSON.stringify(metrics, null, 2));
+        return;
+    }
+    console.log(`\nTeam Review Dashboard`);
+    console.log("═".repeat(55));
+    console.log(`  Reviews:      ${metrics.totalReviews}`);
+    console.log(`  Findings:     ${metrics.totalFindings}`);
+    console.log(`  Avg Score:    ${metrics.avgScore}`);
+    console.log(`  Pass Rate:    ${metrics.passRate}%`);
+    console.log(`\n  Severity Distribution:`);
+    for (const [sev, count] of Object.entries(metrics.severityTrend)) {
+        const bar = "█".repeat(Math.min(count, 30));
+        console.log(`    ${sev.padEnd(10)} ${String(count).padStart(4)} ${bar}`);
+    }
+    if (metrics.topIssues.length > 0) {
+        console.log(`\n  Top Issues:`);
+        for (const issue of metrics.topIssues) {
+            console.log(`    ${issue.ruleId.padEnd(25)} ${issue.count}`);
+        }
+    }
+    console.log("═".repeat(55));
+}

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

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

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

@@ -0,0 +1,99 @@
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+const DEFAULT_CONFIG = {
+    members: [],
+    strategy: "round-robin",
+};
+function loadConfig(configPath) {
+    if (existsSync(configPath)) {
+        try {
+            return JSON.parse(readFileSync(configPath, "utf-8"));
+        }
+        catch {
+            console.log("Warning: could not parse rotation config, using defaults");
+        }
+    }
+    return DEFAULT_CONFIG;
+}
+function selectNext(config) {
+    const available = config.members.filter((m) => m.available);
+    if (available.length === 0)
+        return undefined;
+    switch (config.strategy) {
+        case "least-recent": {
+            const sorted = [...available].sort((a, b) => {
+                if (!a.lastReviewDate)
+                    return -1;
+                if (!b.lastReviewDate)
+                    return 1;
+                return a.lastReviewDate.localeCompare(b.lastReviewDate);
+            });
+            return sorted[0];
+        }
+        case "least-loaded": {
+            const sorted = [...available].sort((a, b) => a.reviewCount - b.reviewCount);
+            return sorted[0];
+        }
+        case "round-robin":
+        default: {
+            const sorted = [...available].sort((a, b) => {
+                if (!a.lastReviewDate)
+                    return -1;
+                if (!b.lastReviewDate)
+                    return 1;
+                return a.lastReviewDate.localeCompare(b.lastReviewDate);
+            });
+            return sorted[0];
+        }
+    }
+}
+export function runReviewTeamRotation(argv) {
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`Usage: judges review-team-rotation [options]
+
+Manage reviewer rotation schedules.
+
+Options:
+  --config <path>      Path to rotation config JSON
+  --format <fmt>       Output format: table (default) or json
+  -h, --help           Show this help message
+
+Config file format:
+{
+  "strategy": "round-robin" | "least-recent" | "least-loaded",
+  "members": [
+    { "name": "Alice", "lastReviewDate": "2025-01-01", "reviewCount": 5, "available": true }
+  ]
+}`);
+        return;
+    }
+    const formatIdx = argv.indexOf("--format");
+    const format = formatIdx !== -1 && argv[formatIdx + 1] ? argv[formatIdx + 1] : "table";
+    const configIdx = argv.indexOf("--config");
+    const configPath = configIdx !== -1 && argv[configIdx + 1]
+        ? join(process.cwd(), argv[configIdx + 1])
+        : join(process.cwd(), ".judges", "rotation.json");
+    const config = loadConfig(configPath);
+    if (config.members.length === 0) {
+        console.log("No team members configured. Create a rotation config at .judges/rotation.json");
+        return;
+    }
+    const next = selectNext(config);
+    if (format === "json") {
+        console.log(JSON.stringify({ strategy: config.strategy, nextReviewer: next?.name ?? null, members: config.members }, null, 2));
+        return;
+    }
+    console.log(`\n=== Team Rotation (strategy: ${config.strategy}) ===\n`);
+    console.log("  " + "Name".padEnd(20) + "Reviews".padEnd(10) + "Last Review".padEnd(14) + "Available");
+    console.log("  " + "-".repeat(55));
+    for (const m of config.members) {
+        const avail = m.available ? "Yes" : "No";
+        console.log("  " + m.name.padEnd(20) + String(m.reviewCount).padEnd(10) + (m.lastReviewDate || "never").padEnd(14) + avail);
+    }
+    if (next) {
+        console.log(`\n  → Next reviewer: ${next.name}`);
+    }
+    else {
+        console.log("\n  No available reviewers.");
+    }
+}

package/dist/commands/review-team-skill-map.d.ts

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

package/dist/commands/review-team-skill-map.js

@@ -0,0 +1,102 @@
+import { readFileSync, existsSync, readdirSync } from "fs";
+import { join } from "path";
+function extractDomain(ruleId) {
+    const parts = ruleId.split("/");
+    return parts.length > 1 ? parts[0] : "general";
+}
+function buildSkillMaps(historyDir) {
+    if (!existsSync(historyDir))
+        return [];
+    const files = readdirSync(historyDir);
+    const jsonFiles = files.filter((f) => String(f).endsWith(".json"));
+    const memberData = {};
+    for (const file of jsonFiles) {
+        const member = String(file)
+            .replace(/\.json$/, "")
+            .replace(/[-_]\d+$/, "");
+        const raw = readFileSync(join(historyDir, String(file)), "utf-8");
+        let verdict;
+        try {
+            verdict = JSON.parse(raw);
+        }
+        catch {
+            continue;
+        }
+        if (!memberData[member])
+            memberData[member] = {};
+        const domainCounts = {};
+        for (const f of verdict.findings ?? []) {
+            const domain = extractDomain(f.ruleId);
+            domainCounts[domain] = (domainCounts[domain] ?? 0) + 1;
+        }
+        const allDomains = new Set(Object.keys(domainCounts));
+        if (allDomains.size === 0)
+            allDomains.add("general");
+        for (const domain of allDomains) {
+            if (!memberData[member][domain]) {
+                memberData[member][domain] = { reviews: 0, findings: 0 };
+            }
+            memberData[member][domain].reviews += 1;
+            memberData[member][domain].findings += domainCounts[domain] ?? 0;
+        }
+    }
+    const maps = [];
+    for (const [member, domains] of Object.entries(memberData)) {
+        const skills = [];
+        for (const [domain, stats] of Object.entries(domains)) {
+            const rate = stats.reviews > 0 ? stats.findings / stats.reviews : 0;
+            let level;
+            if (rate <= 0.5)
+                level = "expert";
+            else if (rate <= 1.5)
+                level = "proficient";
+            else if (rate <= 3)
+                level = "developing";
+            else
+                level = "beginner";
+            skills.push({ domain, level, findingRate: Math.round(rate * 10) / 10, reviewCount: stats.reviews });
+        }
+        skills.sort((a, b) => a.findingRate - b.findingRate);
+        const strongest = skills.length > 0 ? skills[0].domain : "none";
+        const weakest = skills.length > 0 ? skills[skills.length - 1].domain : "none";
+        maps.push({ member, skills, strongestDomain: strongest, weakestDomain: weakest });
+    }
+    return maps;
+}
+export function runReviewTeamSkillMap(argv) {
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`Usage: judges review-team-skill-map [options]
+
+Build a team skill map from review history.
+
+Options:
+  --history <dir>      Directory with verdict JSON files (default: .judges/history)
+  --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 maps = buildSkillMaps(historyDir);
+    if (format === "json") {
+        console.log(JSON.stringify(maps, null, 2));
+        return;
+    }
+    console.log(`\n=== Team Skill Map (${maps.length} members) ===\n`);
+    if (maps.length === 0) {
+        console.log("No review history found. Run some reviews first.");
+        return;
+    }
+    for (const m of maps) {
+        console.log(`  ${m.member}`);
+        console.log(`    Strongest: ${m.strongestDomain}  |  Weakest: ${m.weakestDomain}`);
+        for (const s of m.skills) {
+            console.log(`    ${s.domain.padEnd(20)} ${s.level.padEnd(12)} (rate: ${s.findingRate}, reviews: ${s.reviewCount})`);
+        }
+        console.log();
+    }
+}

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

@@ -0,0 +1,4 @@
+/**
+ * Review-team-stats — Aggregate review statistics for team visibility.
+ */
+export declare function runReviewTeamStats(argv: string[]): void;