@kevinrabun/judges-cli 3.124.0

package/dist/commands/finding-age-report.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Finding-age-report — Report on finding ages and staleness.
+ */
+export declare function runFindingAgeReport(argv: string[]): void;

package/dist/commands/finding-age-report.js

@@ -0,0 +1,154 @@
+/**
+ * Finding-age-report — Report on finding ages and staleness.
+ */
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { dirname } from "path";
+// ─── Storage ────────────────────────────────────────────────────────────────
+const AGE_FILE = ".judges/finding-ages.json";
+function loadStore() {
+    if (!existsSync(AGE_FILE))
+        return { version: "1.0.0", entries: [] };
+    try {
+        return JSON.parse(readFileSync(AGE_FILE, "utf-8"));
+    }
+    catch {
+        return { version: "1.0.0", entries: [] };
+    }
+}
+function saveStore(store) {
+    mkdirSync(dirname(AGE_FILE), { recursive: true });
+    writeFileSync(AGE_FILE, JSON.stringify(store, null, 2), "utf-8");
+}
+// ─── CLI ────────────────────────────────────────────────────────────────────
+export function runFindingAgeReport(argv) {
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`
+judges finding-age-report — Report on finding ages
+
+Usage:
+  judges finding-age-report                         Show age report
+  judges finding-age-report update --file <results>  Update ages from results
+  judges finding-age-report stale --days <n>         Show findings older than N days
+  judges finding-age-report clear                    Clear age data
+
+Options:
+  --file <path>     Results file
+  --days <n>        Staleness threshold (default: 30)
+  --format json     JSON output
+  --help, -h        Show this help
+`);
+        return;
+    }
+    const subcommand = argv.find((a) => ["update", "stale", "clear"].includes(a));
+    const format = argv.find((_a, i) => argv[i - 1] === "--format") || "text";
+    const store = loadStore();
+    if (subcommand === "update") {
+        const file = argv.find((_a, i) => argv[i - 1] === "--file");
+        if (!file) {
+            console.error("Error: --file required");
+            process.exitCode = 1;
+            return;
+        }
+        if (!existsSync(file)) {
+            console.error(`Error: file not found: ${file}`);
+            process.exitCode = 1;
+            return;
+        }
+        let findings;
+        try {
+            const data = JSON.parse(readFileSync(file, "utf-8"));
+            findings = Array.isArray(data) ? data : data.findings || [];
+        }
+        catch {
+            console.error("Error: could not parse results file");
+            process.exitCode = 1;
+            return;
+        }
+        const now = new Date().toISOString();
+        let newCount = 0;
+        let updatedCount = 0;
+        for (const f of findings) {
+            const id = f.ruleId || f.title || "unknown";
+            const existing = store.entries.find((e) => e.findingId === id);
+            if (existing) {
+                existing.lastSeen = now;
+                updatedCount++;
+            }
+            else {
+                store.entries.push({
+                    findingId: id,
+                    ruleId: f.ruleId || "",
+                    severity: f.severity || "medium",
+                    firstSeen: now,
+                    lastSeen: now,
+                });
+                newCount++;
+            }
+        }
+        saveStore(store);
+        console.log(`Updated: ${newCount} new, ${updatedCount} existing findings.`);
+        return;
+    }
+    if (subcommand === "stale") {
+        const days = parseInt(argv.find((_a, i) => argv[i - 1] === "--days") || "30", 10);
+        const cutoff = Date.now() - days * 24 * 60 * 60 * 1000;
+        const stale = store.entries.filter((e) => new Date(e.firstSeen).getTime() < cutoff);
+        if (stale.length === 0) {
+            console.log(`No findings older than ${days} days.`);
+            return;
+        }
+        if (format === "json") {
+            console.log(JSON.stringify(stale, null, 2));
+            return;
+        }
+        console.log(`\nStale Findings (> ${days} days): ${stale.length}`);
+        console.log("═".repeat(65));
+        for (const e of stale) {
+            const ageDays = Math.round((Date.now() - new Date(e.firstSeen).getTime()) / 86400000);
+            console.log(`  ${e.findingId.padEnd(30)} ${e.severity.padEnd(10)} ${ageDays} days old`);
+        }
+        console.log("═".repeat(65));
+        return;
+    }
+    if (subcommand === "clear") {
+        saveStore({ version: "1.0.0", entries: [] });
+        console.log("Age data cleared.");
+        return;
+    }
+    // Default: show report
+    if (store.entries.length === 0) {
+        console.log("No age data. Use 'judges finding-age-report update --file <f>' to start tracking.");
+        return;
+    }
+    if (format === "json") {
+        console.log(JSON.stringify(store.entries, null, 2));
+        return;
+    }
+    // Group by age bucket
+    const now = Date.now();
+    const buckets = { "< 1 day": 0, "1-7 days": 0, "7-30 days": 0, "30-90 days": 0, "> 90 days": 0 };
+    for (const e of store.entries) {
+        const ageDays = (now - new Date(e.firstSeen).getTime()) / 86400000;
+        if (ageDays < 1)
+            buckets["< 1 day"]++;
+        else if (ageDays < 7)
+            buckets["1-7 days"]++;
+        else if (ageDays < 30)
+            buckets["7-30 days"]++;
+        else if (ageDays < 90)
+            buckets["30-90 days"]++;
+        else
+            buckets["> 90 days"]++;
+    }
+    console.log(`\nFinding Age Report (${store.entries.length} tracked):`);
+    console.log("═".repeat(40));
+    for (const [bucket, count] of Object.entries(buckets)) {
+        if (count > 0)
+            console.log(`  ${bucket.padEnd(15)} ${count}`);
+    }
+    console.log("═".repeat(40));
+    const avgAge = store.entries.reduce((sum, e) => sum + (now - new Date(e.firstSeen).getTime()), 0) /
+        store.entries.length /
+        86400000;
+    console.log(`  Average age: ${avgAge.toFixed(1)} days`);
+}

package/dist/commands/finding-age-tracker.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Finding-age-tracker — Track the age of findings over time.
+ *
+ * Records when findings first appear and tracks their age,
+ * helping prioritize long-standing issues.
+ */
+export declare function runFindingAgeTracker(argv: string[]): void;

package/dist/commands/finding-age-tracker.js

@@ -0,0 +1,152 @@
+/**
+ * Finding-age-tracker — Track the age of findings over time.
+ *
+ * Records when findings first appear and tracks their age,
+ * helping prioritize long-standing issues.
+ */
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { dirname, join } from "path";
+// ─── Helpers ────────────────────────────────────────────────────────────────
+function ageFile() {
+    return join(process.cwd(), ".judges", "finding-ages.json");
+}
+function loadAges() {
+    const f = ageFile();
+    if (!existsSync(f))
+        return [];
+    try {
+        return JSON.parse(readFileSync(f, "utf-8"));
+    }
+    catch {
+        return [];
+    }
+}
+function saveAges(ages) {
+    const f = ageFile();
+    const d = dirname(f);
+    if (!existsSync(d))
+        mkdirSync(d, { recursive: true });
+    writeFileSync(f, JSON.stringify(ages, null, 2));
+}
+function daysBetween(d1, d2) {
+    const ms = new Date(d2).getTime() - new Date(d1).getTime();
+    return Math.floor(ms / (1000 * 60 * 60 * 24));
+}
+function ageLabel(days) {
+    if (days === 0)
+        return "new";
+    if (days <= 7)
+        return `${days}d`;
+    if (days <= 30)
+        return `${Math.floor(days / 7)}w`;
+    return `${Math.floor(days / 30)}mo`;
+}
+// ─── CLI ────────────────────────────────────────────────────────────────────
+export function runFindingAgeTracker(argv) {
+    const sub = argv[0];
+    if (!sub || sub === "--help" || sub === "-h") {
+        console.log(`
+judges finding-age-tracker — Track finding ages
+
+Usage:
+  judges finding-age-tracker update --file <verdict.json>
+  judges finding-age-tracker show   [--min-age <days>] [--format table|json]
+  judges finding-age-tracker clear
+
+Options:
+  --file <path>      Verdict JSON to record (for update)
+  --min-age <days>   Show only findings older than N days
+  --format <fmt>     Output format: table (default), json
+  --help, -h         Show this help
+`);
+        return;
+    }
+    if (sub === "update") {
+        const fileIdx = argv.indexOf("--file");
+        const filePath = fileIdx >= 0 ? argv[fileIdx + 1] : undefined;
+        if (!filePath) {
+            console.error("Error: --file required");
+            process.exitCode = 1;
+            return;
+        }
+        if (!existsSync(filePath)) {
+            console.error(`Error: file 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 ages = loadAges();
+        const now = new Date().toISOString();
+        const ageMap = new Map(ages.map((a) => [`${a.ruleId}:${a.title}`, a]));
+        for (const f of verdict.findings) {
+            const key = `${f.ruleId}:${f.title}`;
+            const existing = ageMap.get(key);
+            if (existing) {
+                existing.lastSeen = now;
+                existing.occurrences++;
+            }
+            else {
+                ageMap.set(key, {
+                    ruleId: f.ruleId,
+                    title: f.title,
+                    firstSeen: now,
+                    lastSeen: now,
+                    occurrences: 1,
+                });
+            }
+        }
+        saveAges([...ageMap.values()]);
+        console.log(`Updated: ${verdict.findings.length} findings recorded (${ageMap.size} total tracked)`);
+    }
+    else if (sub === "show") {
+        const minAgeIdx = argv.indexOf("--min-age");
+        const formatIdx = argv.indexOf("--format");
+        const minAge = minAgeIdx >= 0 ? parseInt(argv[minAgeIdx + 1], 10) : 0;
+        const format = formatIdx >= 0 ? argv[formatIdx + 1] : "table";
+        const ages = loadAges();
+        if (ages.length === 0) {
+            console.log("No age data recorded. Run 'update' first.");
+            return;
+        }
+        const now = new Date().toISOString();
+        const filtered = ages
+            .map((a) => ({ ...a, ageDays: daysBetween(a.firstSeen, now) }))
+            .filter((a) => a.ageDays >= minAge)
+            .sort((a, b) => b.ageDays - a.ageDays);
+        if (format === "json") {
+            console.log(JSON.stringify(filtered, null, 2));
+            return;
+        }
+        console.log(`\nFinding Age Tracker (${filtered.length} findings)`);
+        console.log("═".repeat(70));
+        console.log(`${"Age".padEnd(8)} ${"Seen".padEnd(6)} ${"Rule".padEnd(25)} Title`);
+        console.log("─".repeat(70));
+        for (const a of filtered) {
+            const age = ageLabel(a.ageDays).padEnd(8);
+            const seen = String(a.occurrences).padEnd(6);
+            const rule = a.ruleId.length > 23 ? a.ruleId.slice(0, 23) + "…" : a.ruleId;
+            const title = a.title.length > 25 ? a.title.slice(0, 25) + "…" : a.title;
+            console.log(`${age} ${seen} ${rule.padEnd(25)} ${title}`);
+        }
+        console.log("─".repeat(70));
+        const avgAge = filtered.length > 0 ? (filtered.reduce((s, a) => s + a.ageDays, 0) / filtered.length).toFixed(1) : "0";
+        console.log(`Average age: ${avgAge} days`);
+        console.log("═".repeat(70));
+    }
+    else if (sub === "clear") {
+        saveAges([]);
+        console.log("Finding age data cleared.");
+    }
+    else {
+        console.error(`Unknown subcommand: ${sub}. Use --help for usage.`);
+        process.exitCode = 1;
+    }
+}

package/dist/commands/finding-age.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Finding-age — Track how long findings have been unresolved.
+ */
+export declare function runFindingAge(argv: string[]): void;

package/dist/commands/finding-age.js

@@ -0,0 +1,145 @@
+/**
+ * Finding-age — Track how long findings have been unresolved.
+ */
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join, dirname } from "path";
+// ─── Storage ────────────────────────────────────────────────────────────────
+const AGE_FILE = join(".judges", "finding-age.json");
+function loadAgeStore() {
+    if (!existsSync(AGE_FILE))
+        return { version: "1.0.0", records: [] };
+    try {
+        return JSON.parse(readFileSync(AGE_FILE, "utf-8"));
+    }
+    catch {
+        return { version: "1.0.0", records: [] };
+    }
+}
+function saveAgeStore(store) {
+    mkdirSync(dirname(AGE_FILE), { recursive: true });
+    writeFileSync(AGE_FILE, JSON.stringify(store, null, 2), "utf-8");
+}
+function findingFingerprint(f) {
+    return [f.ruleId || "", f.title || "", String(f.severity || "")].join("|").toLowerCase();
+}
+function daysBetween(a, b) {
+    const msPerDay = 86400000;
+    return Math.floor((new Date(b).getTime() - new Date(a).getTime()) / msPerDay);
+}
+// ─── CLI ────────────────────────────────────────────────────────────────────
+export function runFindingAge(argv) {
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`
+judges finding-age — Track how long findings have been unresolved
+
+Usage:
+  judges finding-age update --file verdict.json    Update age records
+  judges finding-age show                          Show finding ages
+  judges finding-age show --stale 30               Show findings older than 30 days
+  judges finding-age clear                         Clear all records
+
+Subcommands:
+  update               Update records from a verdict file
+  show                 Show age report
+  clear                Clear all tracking data
+
+Options:
+  --file <path>         Verdict JSON (for update)
+  --stale <days>        Show only findings older than N days
+  --format json         JSON output
+  --help, -h            Show this help
+
+Tracks first-seen dates and age of findings across reviews.
+Data stored locally in .judges/finding-age.json.
+`);
+        return;
+    }
+    const format = argv.find((_a, i) => argv[i - 1] === "--format") || "text";
+    const subcommand = argv.find((a) => ["update", "show", "clear"].includes(a)) || "show";
+    const store = loadAgeStore();
+    if (subcommand === "update") {
+        const file = argv.find((_a, i) => argv[i - 1] === "--file");
+        if (!file || !existsSync(file)) {
+            console.error("Error: --file with valid verdict JSON is required.");
+            process.exitCode = 1;
+            return;
+        }
+        let verdict;
+        try {
+            verdict = JSON.parse(readFileSync(file, "utf-8"));
+        }
+        catch {
+            console.error(`Error: Could not parse ${file}`);
+            process.exitCode = 1;
+            return;
+        }
+        const now = new Date().toISOString();
+        const currentFingerprints = new Set();
+        for (const f of verdict.findings || []) {
+            const fp = findingFingerprint(f);
+            currentFingerprints.add(fp);
+            const existing = store.records.find((r) => r.fingerprint === fp);
+            if (existing) {
+                existing.lastSeen = now;
+                existing.ageInDays = daysBetween(existing.firstSeen, now);
+                existing.resolved = false;
+                existing.resolvedAt = "";
+            }
+            else {
+                store.records.push({
+                    fingerprint: fp,
+                    ruleId: f.ruleId || "",
+                    title: f.title || "",
+                    severity: f.severity || "unknown",
+                    firstSeen: now,
+                    lastSeen: now,
+                    resolved: false,
+                    resolvedAt: "",
+                    ageInDays: 0,
+                });
+            }
+        }
+        // Mark resolved findings
+        for (const r of store.records) {
+            if (!currentFingerprints.has(r.fingerprint) && !r.resolved) {
+                r.resolved = true;
+                r.resolvedAt = now;
+            }
+        }
+        saveAgeStore(store);
+        console.log(`Updated ${store.records.length} finding age records.`);
+        return;
+    }
+    if (subcommand === "clear") {
+        saveAgeStore({ version: "1.0.0", records: [] });
+        console.log("Finding age records cleared.");
+        return;
+    }
+    // Show
+    const staleStr = argv.find((_a, i) => argv[i - 1] === "--stale");
+    const staleDays = staleStr ? parseInt(staleStr, 10) : 0;
+    let records = store.records.filter((r) => !r.resolved);
+    if (staleDays > 0) {
+        records = records.filter((r) => r.ageInDays >= staleDays);
+    }
+    records.sort((a, b) => b.ageInDays - a.ageInDays);
+    if (format === "json") {
+        console.log(JSON.stringify({ total: store.records.length, unresolved: records.length, staleDays, records }, null, 2));
+        return;
+    }
+    console.log(`\n  Finding Age Report\n  ═════════════════════════════`);
+    console.log(`    Total tracked: ${store.records.length}`);
+    console.log(`    Unresolved: ${records.length}`);
+    console.log(`    Resolved: ${store.records.filter((r) => r.resolved).length}`);
+    if (staleDays > 0)
+        console.log(`    Showing: older than ${staleDays} days`);
+    console.log();
+    if (records.length === 0) {
+        console.log("    No unresolved findings matching criteria.");
+    }
+    for (const r of records) {
+        const icon = r.ageInDays > 30 ? "🔴" : r.ageInDays > 7 ? "🟡" : "🟢";
+        console.log(`    ${icon} ${r.ageInDays}d — [${r.severity.toUpperCase()}] ${r.title || r.ruleId} (since ${r.firstSeen.slice(0, 10)})`);
+    }
+    console.log();
+}

package/dist/commands/finding-ancestry-trace.d.ts

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

package/dist/commands/finding-ancestry-trace.js

@@ -0,0 +1,69 @@
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+function traceAncestry(data) {
+    const findings = data.findings ?? [];
+    const evaluations = data.evaluations ?? [];
+    // Build rule-to-judge mapping from evaluations
+    const ruleToJudge = new Map();
+    for (const ev of evaluations) {
+        for (const f of ev.findings ?? []) {
+            ruleToJudge.set(f.ruleId, ev.judgeId);
+        }
+    }
+    const byJudge = {};
+    const byDomain = {};
+    const entries = [];
+    for (const f of findings) {
+        const domain = f.ruleId.split("-")[0].toUpperCase();
+        const judgeId = ruleToJudge.get(f.ruleId) ?? "unknown";
+        byJudge[judgeId] = (byJudge[judgeId] ?? 0) + 1;
+        byDomain[domain] = (byDomain[domain] ?? 0) + 1;
+        entries.push({
+            ruleId: f.ruleId,
+            title: f.title,
+            severity: f.severity,
+            domain,
+            judgeId,
+        });
+    }
+    return { totalFindings: findings.length, byJudge, byDomain, entries };
+}
+export function runFindingAncestryTrace(argv) {
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`Usage: judges finding-ancestry-trace [options]
+
+Trace finding ancestry to judges and domains.
+
+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}`);
+        return;
+    }
+    const data = JSON.parse(readFileSync(reportPath, "utf-8"));
+    const report = traceAncestry(data);
+    if (format === "json") {
+        console.log(JSON.stringify(report, null, 2));
+        return;
+    }
+    console.log(`\n=== Finding Ancestry (${report.totalFindings} findings) ===\n`);
+    console.log("By judge:");
+    for (const [judge, count] of Object.entries(report.byJudge)) {
+        console.log(`  ${judge}: ${count}`);
+    }
+    console.log("\nBy domain:");
+    for (const [domain, count] of Object.entries(report.byDomain)) {
+        console.log(`  ${domain}: ${count}`);
+    }
+    console.log();
+}

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

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

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

@@ -0,0 +1,97 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join } from "path";
+function toAnnotations(findings) {
+    const annotations = [];
+    for (const f of findings) {
+        const startLine = f.lineNumbers !== undefined && f.lineNumbers.length > 0 ? f.lineNumbers[0] : 1;
+        const endLine = f.lineNumbers !== undefined && f.lineNumbers.length > 1 ? f.lineNumbers[f.lineNumbers.length - 1] : startLine;
+        annotations.push({
+            ruleId: f.ruleId,
+            severity: f.severity,
+            title: f.title,
+            message: f.description,
+            startLine,
+            endLine,
+        });
+    }
+    return annotations;
+}
+function formatGitHub(annotations) {
+    const lines = [];
+    for (const a of annotations) {
+        const level = a.severity === "critical" || a.severity === "high" ? "error" : "warning";
+        lines.push(`::${level} title=${a.ruleId}::${a.title} (line ${a.startLine}): ${a.message}`);
+    }
+    return lines.join("\n");
+}
+function formatProblemMatcher(annotations) {
+    const lines = [];
+    for (const a of annotations) {
+        lines.push(`${a.ruleId}:${a.startLine}:${a.endLine}: ${a.severity}: ${a.title} - ${a.message}`);
+    }
+    return lines.join("\n");
+}
+export function runFindingAnnotationExport(argv) {
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`Usage: judges finding-annotation-export [options]
+
+Export findings as code annotations for IDEs and CI systems.
+
+Options:
+  --report <path>     Path to verdict JSON file
+  --output <path>     Output file path (default: stdout)
+  --type <type>       Annotation type: github, problem-matcher, json (default: 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");
+    if (!existsSync(reportPath)) {
+        console.log(`No report found at: ${reportPath}`);
+        console.log("Run a review first or provide --report.");
+        return;
+    }
+    const data = JSON.parse(readFileSync(reportPath, "utf-8"));
+    const findings = data.findings ?? [];
+    if (findings.length === 0) {
+        console.log("No findings to export.");
+        return;
+    }
+    const annotations = toAnnotations(findings);
+    const typeIdx = argv.indexOf("--type");
+    const annotationType = typeIdx !== -1 && argv[typeIdx + 1] ? argv[typeIdx + 1] : "json";
+    let output;
+    if (annotationType === "github") {
+        output = formatGitHub(annotations);
+    }
+    else if (annotationType === "problem-matcher") {
+        output = formatProblemMatcher(annotations);
+    }
+    else {
+        output = JSON.stringify(annotations, null, 2);
+    }
+    const outputIdx = argv.indexOf("--output");
+    if (outputIdx !== -1 && argv[outputIdx + 1]) {
+        const outPath = join(process.cwd(), argv[outputIdx + 1]);
+        const outDir = join(outPath, "..");
+        if (!existsSync(outDir)) {
+            mkdirSync(outDir, { recursive: true });
+        }
+        writeFileSync(outPath, output);
+        console.log(`Annotations exported to: ${outPath}`);
+        return;
+    }
+    if (format === "json" || annotationType === "json") {
+        console.log(output);
+        return;
+    }
+    console.log("\n=== Finding Annotations ===\n");
+    console.log(`Type: ${annotationType}`);
+    console.log(`Findings: ${annotations.length}\n`);
+    console.log(output);
+}

package/dist/commands/finding-annotation-layer.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Finding-annotation-layer — Add contextual annotations to findings.
+ */
+export declare function runFindingAnnotationLayer(argv: string[]): void;