@kevinrabun/judges-cli 3.124.0

package/dist/commands/finding-root-cause.js

@@ -0,0 +1,184 @@
+/**
+ * Finding-root-cause — Identify root causes of recurring findings.
+ */
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { dirname } from "path";
+// ─── Storage ────────────────────────────────────────────────────────────────
+const STORE_FILE = ".judges/root-causes.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");
+}
+// ─── Analysis ───────────────────────────────────────────────────────────────
+function inferRootCause(ruleId, description) {
+    const text = `${ruleId} ${description}`.toLowerCase();
+    if (text.includes("inject") || text.includes("sql") || text.includes("xss")) {
+        return { cause: "Unsanitized user input", recommendation: "Implement input validation and parameterized queries" };
+    }
+    if (text.includes("auth") || text.includes("credential") || text.includes("password")) {
+        return {
+            cause: "Missing or weak authentication",
+            recommendation: "Review authentication flow and enforce strong auth",
+        };
+    }
+    if (text.includes("hardcod") || text.includes("secret") || text.includes("api.key")) {
+        return { cause: "Hardcoded secrets", recommendation: "Use environment variables or secret managers" };
+    }
+    if (text.includes("error") || text.includes("exception") || text.includes("catch")) {
+        return { cause: "Insufficient error handling", recommendation: "Add structured error handling and logging" };
+    }
+    if (text.includes("log") || text.includes("sensitive") || text.includes("pii")) {
+        return { cause: "Sensitive data in logs", recommendation: "Sanitize log output and mask sensitive fields" };
+    }
+    if (text.includes("race") || text.includes("concurrent") || text.includes("async")) {
+        return { cause: "Concurrency issues", recommendation: "Add proper synchronization or use atomic operations" };
+    }
+    if (text.includes("deprecat") || text.includes("version") || text.includes("outdated")) {
+        return { cause: "Outdated dependencies", recommendation: "Update dependencies and review breaking changes" };
+    }
+    return { cause: "Code quality issue", recommendation: "Review coding standards and add linting rules" };
+}
+// ─── CLI ────────────────────────────────────────────────────────────────────
+export function runFindingRootCause(argv) {
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`
+judges finding-root-cause — Identify root causes of recurring findings
+
+Usage:
+  judges finding-root-cause analyze --file <results>    Analyze findings for root causes
+  judges finding-root-cause list                        List known root causes
+  judges finding-root-cause set --rule <id> --cause <text> --recommendation <text>
+  judges finding-root-cause clear                       Clear root cause data
+
+Options:
+  --file <path>            Results file
+  --rule <ruleId>          Rule ID
+  --cause <text>           Root cause description
+  --recommendation <text>  Recommended fix
+  --min-occurrences <n>    Min occurrences to report (default: 2)
+  --format json            JSON output
+  --help, -h               Show this help
+`);
+        return;
+    }
+    const subcommand = argv.find((a) => ["analyze", "list", "set", "clear"].includes(a));
+    const format = argv.find((_a, i) => argv[i - 1] === "--format") || "text";
+    const store = loadStore();
+    if (subcommand === "analyze") {
+        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;
+        }
+        const minOccurrences = parseInt(argv.find((_a, i) => argv[i - 1] === "--min-occurrences") || "2", 10);
+        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;
+        }
+        // Group by rule
+        const ruleCounts = new Map();
+        for (const f of findings) {
+            const rid = f.ruleId || "unknown";
+            const existing = ruleCounts.get(rid);
+            if (existing) {
+                existing.count++;
+            }
+            else {
+                ruleCounts.set(rid, { count: 1, description: f.description || f.title || "" });
+            }
+        }
+        // Analyze recurring rules
+        const now = new Date().toISOString();
+        let analyzed = 0;
+        for (const [ruleId, info] of ruleCounts) {
+            if (info.count < minOccurrences)
+                continue;
+            const existing = store.entries.find((e) => e.ruleId === ruleId);
+            const { cause, recommendation } = inferRootCause(ruleId, info.description);
+            if (existing) {
+                existing.occurrences = info.count;
+                existing.lastUpdated = now;
+            }
+            else {
+                store.entries.push({ ruleId, occurrences: info.count, rootCause: cause, recommendation, lastUpdated: now });
+            }
+            analyzed++;
+        }
+        saveStore(store);
+        console.log(`Analyzed ${findings.length} findings, identified ${analyzed} recurring patterns.`);
+        return;
+    }
+    if (subcommand === "set") {
+        const ruleId = argv.find((_a, i) => argv[i - 1] === "--rule");
+        const cause = argv.find((_a, i) => argv[i - 1] === "--cause");
+        const recommendation = argv.find((_a, i) => argv[i - 1] === "--recommendation");
+        if (!ruleId || !cause) {
+            console.error("Error: --rule and --cause required");
+            process.exitCode = 1;
+            return;
+        }
+        const existing = store.entries.find((e) => e.ruleId === ruleId);
+        if (existing) {
+            existing.rootCause = cause;
+            existing.recommendation = recommendation || existing.recommendation;
+            existing.lastUpdated = new Date().toISOString();
+        }
+        else {
+            store.entries.push({
+                ruleId,
+                occurrences: 0,
+                rootCause: cause,
+                recommendation: recommendation || "",
+                lastUpdated: new Date().toISOString(),
+            });
+        }
+        saveStore(store);
+        console.log(`Root cause set for '${ruleId}'.`);
+        return;
+    }
+    if (subcommand === "clear") {
+        saveStore({ version: "1.0.0", entries: [] });
+        console.log("Root cause data cleared.");
+        return;
+    }
+    // Default: list
+    if (store.entries.length === 0) {
+        console.log("No root causes tracked. Use 'judges finding-root-cause analyze --file <f>'.");
+        return;
+    }
+    if (format === "json") {
+        console.log(JSON.stringify(store.entries, null, 2));
+        return;
+    }
+    const sorted = [...store.entries].sort((a, b) => b.occurrences - a.occurrences);
+    console.log(`\nRoot Cause Analysis (${sorted.length} patterns):`);
+    console.log("═".repeat(70));
+    for (const e of sorted) {
+        console.log(`\n  ${e.ruleId} (${e.occurrences} occurrences)`);
+        console.log(`    Root cause:      ${e.rootCause}`);
+        console.log(`    Recommendation:  ${e.recommendation}`);
+    }
+    console.log("\n" + "═".repeat(70));
+}

package/dist/commands/finding-rule-explain.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Finding-rule-explain — Explain rules in detail with examples and remediation.
+ */
+export declare function runFindingRuleExplain(argv: string[]): void;

package/dist/commands/finding-rule-explain.js

@@ -0,0 +1,140 @@
+/**
+ * Finding-rule-explain — Explain rules in detail with examples and remediation.
+ */
+import { readFileSync, existsSync } from "fs";
+import { defaultRegistry } from "../judge-registry.js";
+// ─── Analysis ───────────────────────────────────────────────────────────────
+function explainRules(verdict, targetRule) {
+    const judges = defaultRegistry.getJudges();
+    const explanations = [];
+    const ruleMap = new Map();
+    for (const f of verdict.findings) {
+        if (targetRule !== undefined && f.ruleId !== targetRule)
+            continue;
+        const existing = ruleMap.get(f.ruleId);
+        if (existing) {
+            existing.occurrences++;
+            const lines = f.lineNumbers || [];
+            for (const ln of lines) {
+                if (!existing.affectedLines.includes(ln)) {
+                    existing.affectedLines.push(ln);
+                }
+            }
+            continue;
+        }
+        // find the judge for this rule
+        let judgeName = "unknown";
+        let domain = "unknown";
+        for (const j of judges) {
+            if (f.ruleId.startsWith(j.rulePrefix)) {
+                judgeName = j.name;
+                domain = j.domain;
+                break;
+            }
+        }
+        const explanation = {
+            ruleId: f.ruleId,
+            title: f.title,
+            severity: (f.severity || "medium").toLowerCase(),
+            judge: judgeName,
+            domain,
+            description: f.description,
+            recommendation: f.recommendation,
+            occurrences: 1,
+            affectedLines: [...(f.lineNumbers || [])],
+        };
+        ruleMap.set(f.ruleId, explanation);
+        explanations.push(explanation);
+    }
+    explanations.sort((a, b) => {
+        const sevOrder = { critical: 0, high: 1, medium: 2, low: 3, info: 4 };
+        return (sevOrder[a.severity] || 3) - (sevOrder[b.severity] || 3);
+    });
+    return explanations;
+}
+// ─── CLI ────────────────────────────────────────────────────────────────────
+export function runFindingRuleExplain(argv) {
+    const fileIdx = argv.indexOf("--file");
+    const ruleIdx = argv.indexOf("--rule");
+    const formatIdx = argv.indexOf("--format");
+    const filePath = fileIdx >= 0 ? argv[fileIdx + 1] : undefined;
+    const targetRule = ruleIdx >= 0 ? argv[ruleIdx + 1] : undefined;
+    const format = formatIdx >= 0 ? argv[formatIdx + 1] : "detail";
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`
+judges finding-rule-explain — Explain rules in detail
+
+Usage:
+  judges finding-rule-explain --file <verdict.json> [--rule <RULE-ID>]
+                              [--format detail|table|json]
+
+Options:
+  --file <path>      Path to verdict JSON file (required)
+  --rule <id>        Explain a specific rule ID
+  --format <fmt>     Output format: detail (default), table, json
+  --help, -h         Show this help
+`);
+        return;
+    }
+    if (!filePath) {
+        console.error("Error: --file required");
+        process.exitCode = 1;
+        return;
+    }
+    if (!existsSync(filePath)) {
+        console.error(`Error: not found: ${filePath}`);
+        process.exitCode = 1;
+        return;
+    }
+    let verdict;
+    try {
+        verdict = JSON.parse(readFileSync(filePath, "utf-8"));
+    }
+    catch {
+        console.error("Error: invalid JSON");
+        process.exitCode = 1;
+        return;
+    }
+    const explanations = explainRules(verdict, targetRule);
+    if (explanations.length === 0) {
+        console.log(targetRule ? `No findings for rule: ${targetRule}` : "No findings to explain");
+        return;
+    }
+    if (format === "json") {
+        console.log(JSON.stringify(explanations, null, 2));
+        return;
+    }
+    if (format === "table") {
+        console.log(`\nRule Explanations (${explanations.length} rules)`);
+        console.log("═".repeat(80));
+        console.log(`${"Rule".padEnd(18)} ${"Severity".padEnd(10)} ${"Judge".padEnd(22)} ${"Occurs".padEnd(8)} Title`);
+        console.log("─".repeat(80));
+        for (const e of explanations) {
+            const rule = e.ruleId.length > 16 ? e.ruleId.slice(0, 16) + "…" : e.ruleId;
+            const judge = e.judge.length > 20 ? e.judge.slice(0, 20) + "…" : e.judge;
+            const title = e.title.length > 25 ? e.title.slice(0, 25) + "…" : e.title;
+            console.log(`${rule.padEnd(18)} ${e.severity.padEnd(10)} ${judge.padEnd(22)} ${String(e.occurrences).padEnd(8)} ${title}`);
+        }
+        console.log("═".repeat(80));
+        return;
+    }
+    // detail format
+    for (const e of explanations) {
+        console.log(`\n${"═".repeat(70)}`);
+        console.log(`  Rule: ${e.ruleId}`);
+        console.log(`  Title: ${e.title}`);
+        console.log(`  Severity: ${e.severity.toUpperCase()}`);
+        console.log(`  Judge: ${e.judge}`);
+        console.log(`  Domain: ${e.domain}`);
+        console.log(`  Occurrences: ${e.occurrences}`);
+        if (e.affectedLines.length > 0) {
+            console.log(`  Lines: ${e.affectedLines.join(", ")}`);
+        }
+        console.log(`${"─".repeat(70)}`);
+        console.log(`  Description:`);
+        console.log(`    ${e.description}`);
+        console.log(`  Recommendation:`);
+        console.log(`    ${e.recommendation}`);
+    }
+    console.log(`\n${"═".repeat(70)}`);
+}

package/dist/commands/finding-scope-filter.d.ts

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

package/dist/commands/finding-scope-filter.js

@@ -0,0 +1,77 @@
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+/* ── finding-scope-filter ───────────────────────────────────────────
+   Filter findings by scope — rule prefix, severity, confidence,
+   or keyword — to focus on relevant subsets during triage.
+   ─────────────────────────────────────────────────────────────────── */
+function filterFindings(findings, opts) {
+    let result = findings;
+    if (opts.rule) {
+        const prefix = opts.rule.toUpperCase();
+        result = result.filter((f) => f.ruleId.toUpperCase().startsWith(prefix));
+    }
+    if (opts.severity) {
+        const sev = opts.severity.toLowerCase();
+        result = result.filter((f) => f.severity === sev);
+    }
+    if (opts.minConfidence !== undefined) {
+        result = result.filter((f) => (f.confidence ?? 0) >= opts.minConfidence);
+    }
+    if (opts.keyword) {
+        const kw = opts.keyword.toLowerCase();
+        result = result.filter((f) => {
+            const text = `${f.ruleId} ${f.title} ${f.description}`.toLowerCase();
+            return text.includes(kw);
+        });
+    }
+    return result;
+}
+export function runFindingScopeFilter(argv) {
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`Usage: judges finding-scope-filter [options]
+
+Filter findings by scope criteria.
+
+Options:
+  --report <path>      Path to verdict JSON file
+  --rule <prefix>      Filter by rule prefix (e.g., SEC, PERF)
+  --severity <level>   Filter by severity
+  --min-confidence <n> Minimum confidence (0-1)
+  --keyword <text>     Filter by keyword in title/description
+  --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 ruleIdx = argv.indexOf("--rule");
+    const rule = ruleIdx !== -1 && argv[ruleIdx + 1] ? argv[ruleIdx + 1] : undefined;
+    const sevIdx = argv.indexOf("--severity");
+    const severity = sevIdx !== -1 && argv[sevIdx + 1] ? argv[sevIdx + 1] : undefined;
+    const confIdx = argv.indexOf("--min-confidence");
+    const minConfidence = confIdx !== -1 && argv[confIdx + 1] ? parseFloat(argv[confIdx + 1]) : undefined;
+    const kwIdx = argv.indexOf("--keyword");
+    const keyword = kwIdx !== -1 && argv[kwIdx + 1] ? argv[kwIdx + 1] : undefined;
+    if (!existsSync(reportPath)) {
+        console.log(`No report found at: ${reportPath}`);
+        return;
+    }
+    const data = JSON.parse(readFileSync(reportPath, "utf-8"));
+    const findings = data.findings ?? [];
+    const filtered = filterFindings(findings, { rule, severity, minConfidence, keyword });
+    if (format === "json") {
+        console.log(JSON.stringify({ total: findings.length, filtered: filtered.length, findings: filtered }, null, 2));
+        return;
+    }
+    console.log(`\n=== Filtered Findings: ${filtered.length} of ${findings.length} ===\n`);
+    for (const f of filtered) {
+        console.log(`[${f.severity.toUpperCase()}] ${f.ruleId}: ${f.title}`);
+    }
+    if (filtered.length === 0) {
+        console.log("No findings match the filter criteria.");
+    }
+}

package/dist/commands/finding-scope-impact.d.ts

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

package/dist/commands/finding-scope-impact.js

@@ -0,0 +1,83 @@
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+function extractDomain(ruleId) {
+    const parts = ruleId.split("/");
+    return parts.length > 1 ? parts[0] : "general";
+}
+function analyseScope(verdict) {
+    const findings = verdict.findings ?? [];
+    const domainCounts = {};
+    for (const f of findings) {
+        const domain = extractDomain(f.ruleId);
+        domainCounts[domain] = (domainCounts[domain] ?? 0) + 1;
+    }
+    const entries = [];
+    for (const f of findings) {
+        const domain = extractDomain(f.ruleId);
+        const count = domainCounts[domain] ?? 1;
+        let impactScope;
+        if (count >= 10)
+            impactScope = "systemic";
+        else if (count >= 5)
+            impactScope = "widespread";
+        else if (count >= 2)
+            impactScope = "moderate";
+        else
+            impactScope = "isolated";
+        entries.push({
+            ruleId: f.ruleId,
+            title: f.title,
+            severity: f.severity,
+            domain,
+            domainCount: count,
+            impactScope,
+        });
+    }
+    entries.sort((a, b) => b.domainCount - a.domainCount);
+    return entries;
+}
+export function runFindingScopeImpact(argv) {
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`Usage: judges finding-scope-impact [options]
+
+Analyse the scope of finding impact across domains.
+
+Options:
+  --report <path>      Path to verdict 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}`);
+        return;
+    }
+    const data = JSON.parse(readFileSync(reportPath, "utf-8"));
+    const entries = analyseScope(data);
+    if (format === "json") {
+        console.log(JSON.stringify(entries, null, 2));
+        return;
+    }
+    console.log(`\n=== Finding Scope Impact (${entries.length} findings) ===\n`);
+    if (entries.length === 0) {
+        console.log("No findings to analyse.");
+        return;
+    }
+    const seen = new Set();
+    for (const e of entries) {
+        if (!seen.has(e.domain)) {
+            seen.add(e.domain);
+            console.log(`  [${e.domain}] ${e.domainCount} findings — ${e.impactScope} scope`);
+        }
+    }
+    console.log();
+    for (const e of entries) {
+        console.log(`  ${e.impactScope.padEnd(12)} [${e.severity}] ${e.ruleId}: ${e.title}`);
+    }
+}

package/dist/commands/finding-search-index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Finding-search-index — Build and query a local search index of findings.
+ */
+export declare function runFindingSearchIndex(argv: string[]): void;

package/dist/commands/finding-search-index.js

@@ -0,0 +1,99 @@
+/**
+ * Finding-search-index — Build and query a local search index of findings.
+ */
+import { readFileSync, writeFileSync, existsSync } from "fs";
+// ─── CLI ────────────────────────────────────────────────────────────────────
+export function runFindingSearchIndex(argv) {
+    const storeIdx = argv.indexOf("--store");
+    const storePath = storeIdx >= 0 ? argv[storeIdx + 1] : ".judges-search-index.json";
+    const findingsIdx = argv.indexOf("--findings");
+    const findingsPath = findingsIdx >= 0 ? argv[findingsIdx + 1] : "";
+    const queryIdx = argv.indexOf("--query");
+    const query = queryIdx >= 0 ? argv[queryIdx + 1] : "";
+    const formatIdx = argv.indexOf("--format");
+    const format = formatIdx >= 0 ? argv[formatIdx + 1] : "table";
+    const buildMode = argv.includes("--build");
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`
+judges finding-search-index — Build and search findings index
+
+Usage:
+  judges finding-search-index --build --findings <path> [--store <path>]
+  judges finding-search-index --query <text> [--store <path>] [--format table|json]
+
+Options:
+  --store <path>      Index file (default: .judges-search-index.json)
+  --build             Build/update the search index
+  --findings <path>   Path to findings JSON (with --build)
+  --query <text>      Search query text
+  --format <fmt>      Output format: table (default), json
+  --help, -h          Show this help
+`);
+        return;
+    }
+    if (buildMode) {
+        if (!findingsPath || !existsSync(findingsPath)) {
+            console.error("Provide --findings <path> to a valid findings JSON file.");
+            process.exitCode = 1;
+            return;
+        }
+        const findings = JSON.parse(readFileSync(findingsPath, "utf-8"));
+        const index = existsSync(storePath)
+            ? JSON.parse(readFileSync(storePath, "utf-8"))
+            : { entries: [], lastUpdated: new Date().toISOString() };
+        let added = 0;
+        for (const f of findings) {
+            const exists = index.entries.some((e) => e.ruleId === f.ruleId && e.source === findingsPath);
+            if (!exists) {
+                index.entries.push({
+                    ruleId: f.ruleId,
+                    title: f.title,
+                    severity: f.severity,
+                    description: f.description,
+                    recommendation: f.recommendation,
+                    source: findingsPath,
+                    indexedAt: new Date().toISOString(),
+                });
+                added++;
+            }
+        }
+        index.lastUpdated = new Date().toISOString();
+        writeFileSync(storePath, JSON.stringify(index, null, 2));
+        console.log(`Indexed ${added} new findings. Total: ${index.entries.length}`);
+        return;
+    }
+    if (!existsSync(storePath)) {
+        console.log(`No search index found at: ${storePath}`);
+        console.log("Run with --build to create one.");
+        return;
+    }
+    const index = JSON.parse(readFileSync(storePath, "utf-8"));
+    let results = index.entries;
+    if (query) {
+        const q = query.toLowerCase();
+        results = index.entries.filter((e) => e.ruleId.toLowerCase().includes(q) ||
+            e.title.toLowerCase().includes(q) ||
+            e.description.toLowerCase().includes(q) ||
+            e.recommendation.toLowerCase().includes(q));
+    }
+    if (format === "json") {
+        console.log(JSON.stringify(results, null, 2));
+        return;
+    }
+    console.log(`\nSearch Results (${results.length})`);
+    console.log("═".repeat(80));
+    if (results.length === 0) {
+        console.log("  No matching findings.");
+    }
+    else {
+        console.log(`  ${"Rule ID".padEnd(25)} ${"Severity".padEnd(10)} ${"Title".padEnd(30)} Source`);
+        console.log("  " + "─".repeat(75));
+        for (const e of results) {
+            const title = e.title.length > 28 ? e.title.slice(0, 25) + "..." : e.title;
+            const source = e.source.length > 15 ? "..." + e.source.slice(-12) : e.source;
+            console.log(`  ${e.ruleId.padEnd(25)} ${e.severity.padEnd(10)} ${title.padEnd(30)} ${source}`);
+        }
+    }
+    console.log(`\n  Index size: ${index.entries.length} | Matched: ${results.length}`);
+    console.log("═".repeat(80));
+}

package/dist/commands/finding-security-hotspot.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Finding-security-hotspot — Identify security-sensitive code zones.
+ */
+export declare function runFindingSecurityHotspot(argv: string[]): void;