any-doctor 0.0.1

package/bin/cli.js

@@ -0,0 +1,426 @@
+#!/usr/bin/env node
+import * as fs from "fs";
+import * as path from "path";
+import { fileURLToPath, pathToFileURL } from "url";
+import { DOCTOR_FILE_RE } from "./contract.js";
+import { renderReport, renderVerifyResult, unsafeSkipLine } from "./report.js";
+import { copyToClipboard } from "./clipboard.js";
+import { runDashboard } from "./dashboard.js";
+import { brokenDoctors, discoverDoctors, globalDoctorsDir, unsafeSlugs } from "./discover.js";
+import { causeSummaryLine, describeRunnerError, isRunnerError, runDoctor, verifyDoctor } from "./runner.js";
+import { scanDoctorFile, capabilitySummary } from "./capabilities.js";
+import { selectDoctor } from "./select.js";
+import { canRunTui, processTtyEnv } from "./tty.js";
+import { BOLD, CYAN, DIM, GREEN, RED, RESET, YELLOW } from "./palette.js";
+function fail(msg) {
+    console.error(RED + msg + RESET);
+}
+function ok(msg) {
+    console.log(GREEN + msg + RESET);
+}
+function warn(msg) {
+    console.log(YELLOW + msg + RESET);
+}
+function dim(msg) {
+    return DIM + msg + RESET;
+}
+function skillText() {
+    const p = fileURLToPath(new URL("../skill/any-doctor.skill.md", import.meta.url));
+    try {
+        return fs.readFileSync(p, "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+function useColor() {
+    return Boolean(process.stdout.isTTY) && !process.env.NO_COLOR;
+}
+// Commands compute exit codes; process.exit happens exactly once, in the
+// direct-invocation guard at the bottom of this file. An ExitCode thrown
+// mid-command aborts it with a code — main flattens it into its return
+// value, so callers and tests always get a number, never a rejection.
+class ExitCode extends Error {
+    constructor(code) {
+        super("exit " + code);
+        this.code = code;
+    }
+}
+// The one place the command layer crosses the Runner seam: a failure here is
+// a failure of the whole command, so it renders and aborts. Exit policy
+// lives in this layer, never in the Runner.
+async function runOrReport(work) {
+    try {
+        return await work;
+    }
+    catch (e) {
+        fail(isRunnerError(e) ? describeRunnerError(e) : String(e));
+        throw new ExitCode(1);
+    }
+}
+function warnBrokenDoctors(skipped) {
+    for (const b of skipped) {
+        console.log(YELLOW + "\u26a0 skipping broken doctor " + b.slug + RESET + dim(" — " + causeSummaryLine(b.cause)));
+    }
+}
+function selectionOutcome(sel) {
+    switch (sel.kind) {
+        case "doctor":
+            warnBrokenDoctors(sel.skipped);
+            if (sel.unsafe.length > 0)
+                warn("\u26a0 " + unsafeSkipLine(sel.unsafe));
+            return { doctorPath: sel.doctorPath };
+        case "not-found":
+            fail(`no doctor program found for "${sel.arg}"`);
+            fail(`searched ./doctors (walking up from ${process.cwd()}) and ~/.any-doctor/doctors`);
+            return { exit: 1 };
+        case "none-discovered":
+            fail(`no doctors discovered in ${process.cwd()}/doctors or ~/.any-doctor/doctors`);
+            fail('create one with: any-doctor generate "<intent>"');
+            if (sel.unsafe.length > 0)
+                warn("\u26a0 " + unsafeSkipLine(sel.unsafe));
+            for (const b of sel.broken)
+                fail("broken: " + b.slug + " — " + causeSummaryLine(b.cause));
+            return { exit: 1 };
+        case "non-interactive":
+            warnBrokenDoctors(sel.skipped);
+            if (sel.unsafe.length > 0)
+                warn("\u26a0 " + unsafeSkipLine(sel.unsafe));
+            console.log("available doctors:");
+            for (const row of sel.rows) {
+                console.log("  " + row.scope.padEnd(7) + row.slug.padEnd(32) + dim(row.description));
+            }
+            fail("non-interactive session — specify a doctor path");
+            return { exit: 1 };
+        case "cancelled":
+            return { exit: 0 };
+    }
+}
+function parseArgs(args) {
+    const out = { targetDir: path.resolve("."), all: false, global: false };
+    let targetDirSet = false;
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === "--all")
+            out.all = true;
+        else if (a === "--global")
+            out.global = true;
+        else if (out.doctorPath === undefined && DOCTOR_FILE_RE.test(a))
+            out.doctorPath = a;
+        else if (!targetDirSet) {
+            out.targetDir = path.resolve(a);
+            targetDirSet = true;
+        }
+    }
+    return out;
+}
+// Discovery and the gate's partition, computed once per command — pure
+// compute; rendering (broken warnings, skip notes) belongs to the callers,
+// matching select.ts's compute/render split.
+async function gatherDoctors() {
+    const all = await discoverDoctors(process.cwd());
+    return {
+        valid: all.filter(d => d.meta !== null),
+        skippedUnsafe: unsafeSlugs(all),
+        broken: brokenDoctors(all),
+    };
+}
+async function scanOnce(doctorAbs, targetDir) {
+    const result = await runOrReport(runDoctor({ programPath: doctorAbs, targetDir }));
+    return {
+        group: { programName: path.basename(doctorAbs), meta: result.meta, findings: result.findings },
+        fileCount: result.fileCount,
+    };
+}
+// The batch commands' empty-cohort policy: no doctors at all is a setup
+// error; only-skipped doctors are named and fail quietly. True means the
+// caller returns 1.
+function cohortUnusable(cohort) {
+    if (cohort.valid.length > 0)
+        return false;
+    if (cohort.skippedUnsafe.length === 0) {
+        fail("no doctors discovered — run from a directory with doctors/, or specify a doctor path");
+    }
+    else {
+        warn("\u26a0 " + unsafeSkipLine(cohort.skippedUnsafe));
+    }
+    return true;
+}
+async function cmdRun(args) {
+    var _a;
+    const parsed = parseArgs(args);
+    if (parsed.global) {
+        fail("--global is a generate-only flag");
+        return 1;
+    }
+    // One RunOutcome for both modes — a doctor path targets one doctor;
+    // --all and the no-argument default run every discovered doctor (a crash
+    // is data — named, and it fails the command).
+    let outcome;
+    if (parsed.doctorPath) {
+        const sel = await selectDoctor(parsed.doctorPath, {
+            cwd: process.cwd(),
+            useColor: useColor(),
+            env: processTtyEnv(),
+        });
+        const selection = selectionOutcome(sel);
+        if ("exit" in selection)
+            return selection.exit;
+        const runStarted = Date.now();
+        const scan = await scanOnce(selection.doctorPath, parsed.targetDir);
+        outcome = {
+            groups: [scan.group],
+            crashed: [],
+            skippedUnsafe: [],
+            doctorPaths: new Map([[scan.group.meta.id, selection.doctorPath]]),
+            fileCount: scan.fileCount,
+            durationMs: Date.now() - runStarted,
+            targetDir: parsed.targetDir,
+        };
+    }
+    else {
+        const cohort = await gatherDoctors();
+        warnBrokenDoctors(cohort.broken);
+        if (cohortUnusable(cohort))
+            return 1;
+        const discovered = cohort.valid;
+        const skippedUnsafe = cohort.skippedUnsafe;
+        const runStarted = Date.now();
+        const groups = [];
+        const crashed = [];
+        const doctorPaths = new Map();
+        let fileCount = 0;
+        for (const d of discovered) {
+            try {
+                const scan = await scanOnce(d.path, parsed.targetDir);
+                fileCount = Math.max(fileCount, scan.fileCount);
+                doctorPaths.set(d.meta.id, d.path);
+                groups.push(scan.group);
+            }
+            catch (e) {
+                if (!(e instanceof ExitCode))
+                    throw e;
+                crashed.push(d.meta.id);
+            }
+        }
+        outcome = {
+            groups,
+            crashed,
+            skippedUnsafe,
+            doctorPaths,
+            fileCount,
+            durationMs: Date.now() - runStarted,
+            targetDir: parsed.targetDir,
+        };
+    }
+    const env = processTtyEnv();
+    const ttyCols = (_a = process.stdout.columns) !== null && _a !== void 0 ? _a : 0;
+    // Report-vs-dashboard policy: --all is the batch/report mode; otherwise
+    // a real terminal with room and no headless override gets the tree.
+    const interactive = !parsed.all
+        && canRunTui(env) && !process.env.ANY_DOCTOR_HEADLESS && (ttyCols === 0 || ttyCols >= 60);
+    if (!interactive) {
+        console.log(renderReport(outcome, useColor()));
+        if (outcome.crashed.length > 0) {
+            for (const id of outcome.crashed)
+                fail("doctor crashed (results above are partial): " + id);
+            return 1;
+        }
+        return outcome.skippedUnsafe.length > 0 ? 1 : 0;
+    }
+    const invoker = process.argv[1] ? `node "${fs.realpathSync(process.argv[1])}"` : "any-doctor";
+    // Interactive runs always show what did run: skips and crashes cost the
+    // exit code, never the results. Crashes are named before the dashboard
+    // paints — the dashboard itself renders findings and skips, not crashes.
+    for (const id of outcome.crashed)
+        fail("doctor crashed (results above are partial): " + id);
+    await runDashboard({ outcome, invoker, useColor: useColor() });
+    return outcome.crashed.length > 0 || outcome.skippedUnsafe.length > 0 ? 1 : 0;
+}
+async function cmdVerify(args) {
+    const parsed = parseArgs(args);
+    if (parsed.global) {
+        fail("--global is a generate-only flag");
+        return 1;
+    }
+    if (parsed.all) {
+        const cohort = await gatherDoctors();
+        warnBrokenDoctors(cohort.broken);
+        if (cohort.skippedUnsafe.length > 0)
+            warn("\u26a0 " + unsafeSkipLine(cohort.skippedUnsafe));
+        if (cohortUnusable(cohort))
+            return 1;
+        const discovered = cohort.valid;
+        const skippedUnsafe = cohort.skippedUnsafe;
+        let totalFailures = 0;
+        const crashed = [];
+        for (const d of discovered) {
+            console.log(BOLD + d.meta.id + RESET);
+            console.log(DIM + "  capabilities: " + capabilitySummary(scanDoctorFile(d.path)) + RESET);
+            try {
+                const r = await runOrReport(verifyDoctor({ programPath: d.path }));
+                console.log(renderVerifyResult(r, useColor()));
+                totalFailures += r.results.filter(x => !x.ok).length;
+            }
+            catch (e) {
+                if (!(e instanceof ExitCode))
+                    throw e;
+                console.log(RED + "  crashed — skipped" + RESET);
+                crashed.push(d.meta.id);
+            }
+            console.log("");
+        }
+        if (totalFailures > 0 || crashed.length > 0 || skippedUnsafe.length > 0) {
+            const parts = [];
+            if (totalFailures > 0)
+                parts.push(totalFailures + " fixture(s) failed");
+            if (crashed.length > 0)
+                parts.push(crashed.length + " doctor(s) crashed: " + crashed.join(", "));
+            if (skippedUnsafe.length > 0)
+                parts.push(unsafeSkipLine(skippedUnsafe));
+            fail(parts.join("; "));
+            return 1;
+        }
+        ok("all doctors fixture-green");
+        return 0;
+    }
+    const sel = await selectDoctor(parsed.doctorPath, {
+        cwd: process.cwd(),
+        useColor: useColor(),
+        allowPicker: !process.env.ANY_DOCTOR_HEADLESS,
+        env: processTtyEnv(),
+    });
+    const outcome = selectionOutcome(sel);
+    if ("exit" in outcome)
+        return outcome.exit;
+    console.log(DIM + "capabilities: " + capabilitySummary(scanDoctorFile(outcome.doctorPath)) + RESET);
+    const result = await runOrReport(verifyDoctor({ programPath: outcome.doctorPath }));
+    console.log(renderVerifyResult(result, useColor()));
+    const failures = result.results.filter(x => !x.ok).length;
+    console.log("");
+    console.log(dim(`${result.results.length - failures}/${result.results.length} fixtures passed for ${result.meta.id}`));
+    return failures > 0 ? 1 : 0;
+}
+async function cmdGenerate(args) {
+    let intent;
+    let global = false;
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === "--global")
+            global = true;
+        else if (intent === undefined)
+            intent = args[i];
+    }
+    if (!intent) {
+        fail('usage: any-doctor generate "<one-line intent>" [--global]');
+        return 1;
+    }
+    const skill = skillText();
+    if (skill === null) {
+        fail("generation skill not found (skill/any-doctor.skill.md missing).");
+        return 1;
+    }
+    const slug = slugify(intent);
+    const scopeDir = global
+        ? (fs.mkdirSync(globalDoctorsDir(), { recursive: true }), globalDoctorsDir())
+        : path.resolve("doctors");
+    fs.mkdirSync(scopeDir, { recursive: true });
+    const agentsPath = path.join(scopeDir, "AGENTS.md");
+    if (!fs.existsSync(agentsPath)) {
+        fs.writeFileSync(agentsPath, skill);
+    }
+    const cliJs = fileURLToPath(new URL("cli.js", import.meta.url));
+    const doctorAbs = path.join(scopeDir, slug + ".mjs");
+    const prompt = [
+        skill,
+        "",
+        "## Your task",
+        "",
+        "INTENT (the entire specification):",
+        "  " + intent,
+        "",
+        "Working directory is the doctor pack root. Write exactly two files:",
+        "  " + slug + ".mjs",
+        "  " + slug + ".fixtures.mjs",
+        "",
+        "Then verify with exactly this command and iterate until every fixture passes:",
+        '  node "' + cliJs + '" verify "' + doctorAbs + '"',
+        "Then stop and report.",
+    ].join("\n");
+    console.log(BOLD + "doctor prompt ready: " + CYAN + slug + RESET + dim(global ? " (global scope)" : ""));
+    console.log("");
+    if (copyToClipboard(prompt)) {
+        ok("prompt copied to clipboard — paste it into your own agent session");
+        console.log(dim("run the agent with this as its working directory: " + scopeDir));
+        console.log(dim("(the skill is planted there as AGENTS.md — most agents load it automatically)"));
+    }
+    else {
+        console.log(prompt);
+        warn("clipboard unavailable — copy the prompt above");
+    }
+    console.log("");
+    console.log(dim("once your agent has written both files, gate it:"));
+    console.log(dim('  node "' + cliJs + '" verify "' + doctorAbs + '"'));
+    return 0;
+}
+const STOP_WORDS = new Set(["a", "an", "the", "find", "flag", "all", "that", "which", "is", "are", "in", "on", "of", "to", "and", "or", "not"]);
+function slugify(intent) {
+    const words = intent.toLowerCase().replace(/[^a-z0-9\s-]/g, " ").trim().split(/\s+/);
+    const kept = words.filter(w => w && !STOP_WORDS.has(w)).slice(0, 5);
+    return (kept.length ? kept : ["custom-doctor"]).join("-").slice(0, 60);
+}
+function usage() {
+    console.log(BOLD + "any-doctor" + RESET + dim(" — your agent writes the analyzer, fixtures prove it, CI reruns it forever"));
+    console.log("");
+    console.log('  generate "<intent>" [--global]      print the exact prompt for your agent to build a doctor');
+    console.log("  run [--all] [doctor.(m)js] [dir]   scan; no argument = every doctor in one review tree");
+    console.log("  verify [--all] [doctor.(m)js]     fixture gate (no doctor: fuzzy picker; --all: every doctor)");
+    console.log("");
+    console.log(dim("doctors live in ./doctors/ (repo) and ~/.any-doctor/doctors/ (global)."));
+    console.log(dim("generation delegates to your installed agent — run and verify never touch a model."));
+}
+export async function main(argv = process.argv.slice(2)) {
+    const major = Number(process.versions.node.split(".")[0]);
+    if (major < 18) {
+        fail("any-doctor requires Node >= 18 — you are running " + process.versions.node);
+        return 1;
+    }
+    const cmd = argv[0];
+    const rest = argv.slice(1);
+    if (!cmd || cmd === "help" || cmd === "--help") {
+        usage();
+        return 0;
+    }
+    try {
+        if (cmd === "generate")
+            return await cmdGenerate(rest);
+        if (cmd === "run")
+            return await cmdRun(rest);
+        if (cmd === "verify")
+            return await cmdVerify(rest);
+    }
+    catch (e) {
+        if (e instanceof ExitCode)
+            return e.code;
+        throw e;
+    }
+    fail("unknown command: " + cmd);
+    usage();
+    return 1;
+}
+// Direct-invocation guard (realpath-aware so npm link's symlinks still run):
+// importing this module never executes the CLI — commands are testable
+// through main(argv).
+const invokedDirectly = (() => {
+    try {
+        return import.meta.url === pathToFileURL(fs.realpathSync(process.argv[1])).href;
+    }
+    catch {
+        return false;
+    }
+})();
+if (invokedDirectly) {
+    main().then((code) => process.exit(code), (e) => {
+        console.error(RED + (e && e.stack ? e.stack : String(e)) + RESET);
+        process.exit(1);
+    });
+}

package/bin/clipboard.d.ts

@@ -0,0 +1 @@
+export declare function copyToClipboard(text: string): boolean;

package/bin/clipboard.js

@@ -0,0 +1,10 @@
+import { spawnSync } from "child_process";
+export function copyToClipboard(text) {
+    const bins = [["pbcopy", []], ["wl-copy", []], ["clip", []]];
+    for (const [bin, args] of bins) {
+        const r = spawnSync(bin, args, { input: text, encoding: "utf8" });
+        if (r.status === 0)
+            return true;
+    }
+    return false;
+}

package/bin/contract.d.ts

@@ -0,0 +1,134 @@
+export type Severity = "error" | "warning" | "info";
+export interface CheckMeta {
+    id: string;
+    description: string;
+    severity?: Severity;
+    impact?: string;
+    why?: string;
+    fix?: string;
+}
+export interface DoctorMeta {
+    id: string;
+    description: string;
+    severity: Severity;
+    category?: string;
+    blindSpots?: string[];
+    checks?: CheckMeta[];
+}
+export interface ReportGroup {
+    programName: string;
+    meta: DoctorMeta;
+    findings: Finding[];
+}
+export interface Finding {
+    rule?: string;
+    file: string;
+    line: number;
+    column?: number;
+    message?: string;
+    severity?: Severity;
+}
+export interface Match {
+    file: string;
+    line: number;
+    column: number;
+    text: string;
+}
+export interface DoctorCtx {
+    root: string;
+    files: {
+        list(exts?: string[]): string[];
+        read(relativePath: string): string;
+    };
+    search: {
+        pattern(pattern: string, language?: "TypeScript" | "JavaScript"): Match[];
+    };
+    report: {
+        finding(f: Finding): void;
+    };
+}
+export interface Fixture {
+    name: string;
+    seed: Record<string, string>;
+    expected: {
+        file: string;
+        line: number;
+    }[];
+}
+export declare const PROTOCOL_VERSION = 1;
+export declare const RESULT_SENTINEL = "###ANY_DOCTOR_V1###";
+export declare const SEARCH_REQUEST = "###ANY_DOCTOR_SEARCH###";
+export declare const SEARCH_RESULT = "###ANY_DOCTOR_SEARCH_RESULT###";
+export type Mode = {
+    kind: "run";
+    root: string;
+} | {
+    kind: "verify";
+    fixtures: string;
+} | {
+    kind: "meta";
+};
+export declare function modeArgs(mode: Mode, programPath: string): string[];
+export declare function decodeLoaderArgs(argv: string[]): {
+    program: string;
+    mode: Mode;
+} | null;
+export interface RunResult {
+    protocolVersion: number;
+    kind: "run";
+    root: string;
+    fileCount: number;
+    durationMs: number;
+    meta: DoctorMeta;
+    findings: Finding[];
+}
+export interface FixtureDiff {
+    missing: {
+        file: string;
+        line: number;
+    }[];
+    unexpected: {
+        file: string;
+        line: number;
+    }[];
+}
+export interface FixtureResult extends FixtureDiff {
+    name: string;
+    ok: boolean;
+    error?: string;
+}
+export interface VerifyRunResult {
+    protocolVersion: number;
+    kind: "verify";
+    meta: DoctorMeta;
+    results: FixtureResult[];
+}
+export interface MetaResult {
+    protocolVersion: number;
+    kind: "meta";
+    meta: DoctorMeta;
+}
+export type Frame = RunResult | VerifyRunResult | MetaResult;
+export declare const DOCTOR_FILE_RE: RegExp;
+export declare const FIXTURES_FILE_RE: RegExp;
+export declare function fixturesPathFor(programPath: string): string;
+export declare function runCommandFor(doctorPath: string, root: string, invoker?: string): string;
+export declare function compareFindings(expected: {
+    file: string;
+    line: number;
+}[], actual: Finding[]): FixtureDiff;
+export interface JoinedFinding {
+    doctorId: string;
+    checkId: string;
+    checkKey: string;
+    description: string;
+    severity: Severity;
+    declaredSeverity: Severity;
+    category: string;
+    impact?: string;
+    why?: string;
+    fix?: string;
+    blindSpots?: string[];
+    finding: Finding;
+}
+export declare function resolveFinding(meta: DoctorMeta, finding: Finding): JoinedFinding;

package/bin/contract.js

@@ -0,0 +1,70 @@
+export const PROTOCOL_VERSION = 1;
+export const RESULT_SENTINEL = "###ANY_DOCTOR_V1###";
+// ctx.search host protocol: doctor children cannot spawn (permission
+// model), so they ask the host to run ast-grep — request out fd 3, result
+// back on stdin.
+export const SEARCH_REQUEST = "###ANY_DOCTOR_SEARCH###";
+export const SEARCH_RESULT = "###ANY_DOCTOR_SEARCH_RESULT###";
+export function modeArgs(mode, programPath) {
+    switch (mode.kind) {
+        case "run": return [programPath, mode.root];
+        case "verify": return [programPath, "--verify", mode.fixtures];
+        case "meta": return [programPath, "--meta"];
+    }
+}
+export function decodeLoaderArgs(argv) {
+    const [program, second, third] = argv;
+    if (!program || program.startsWith("-"))
+        return null;
+    if (second === "--verify" && third !== undefined)
+        return { program, mode: { kind: "verify", fixtures: third } };
+    if (second === "--meta" && third === undefined)
+        return { program, mode: { kind: "meta" } };
+    if (second !== undefined && !second.startsWith("-") && third === undefined) {
+        return { program, mode: { kind: "run", root: second } };
+    }
+    return null;
+}
+// Filename conventions of the doctor contract — the one home for what is a
+// doctor file, what is a fixture file, and where a doctor's fixtures live.
+export const DOCTOR_FILE_RE = /\.(m|c)?js$/;
+export const FIXTURES_FILE_RE = /\.fixtures\.(m|c)?js$/;
+// A check id is a short kebab-case noun phrase naming the defect, unique within its doctor,
+// over the charset [a-z0-9-] (never "/" — checkKey joins ids with it).
+// Prefer naming the defect ("uncleared-settimeout-in-effect") over the
+// pattern it searches for.
+export function fixturesPathFor(programPath) {
+    return programPath.replace(DOCTOR_FILE_RE, "") + ".fixtures.mjs";
+}
+// The re-run command embedded in copied prompts. invoker defaults to
+// the installed binary name; callers running via node or npx pass their own.
+export function runCommandFor(doctorPath, root, invoker = "any-doctor") {
+    return `${invoker} run "${doctorPath}" "${root}"`;
+}
+export function compareFindings(expected, actual) {
+    const key = (f) => `${f.file}:${f.line}`;
+    const expectedKeys = new Set(expected.map(key));
+    const actualKeys = new Set(actual.map(key));
+    const missing = expected.filter(f => !actualKeys.has(key(f))).map(f => ({ file: f.file, line: f.line }));
+    const unexpected = actual.filter(f => !expectedKeys.has(key(f))).map(f => ({ file: f.file, line: f.line }));
+    return { missing, unexpected };
+}
+export function resolveFinding(meta, finding) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const checkId = (_a = finding.rule) !== null && _a !== void 0 ? _a : meta.id;
+    const check = (_b = meta.checks) === null || _b === void 0 ? void 0 : _b.find(c => c.id === checkId);
+    return {
+        doctorId: meta.id,
+        checkId,
+        checkKey: meta.id + "/" + checkId,
+        description: (_c = check === null || check === void 0 ? void 0 : check.description) !== null && _c !== void 0 ? _c : meta.description,
+        severity: (_e = (_d = finding.severity) !== null && _d !== void 0 ? _d : check === null || check === void 0 ? void 0 : check.severity) !== null && _e !== void 0 ? _e : meta.severity,
+        declaredSeverity: (_f = check === null || check === void 0 ? void 0 : check.severity) !== null && _f !== void 0 ? _f : meta.severity,
+        category: (_g = meta.category) !== null && _g !== void 0 ? _g : "general",
+        impact: check === null || check === void 0 ? void 0 : check.impact,
+        why: check === null || check === void 0 ? void 0 : check.why,
+        fix: check === null || check === void 0 ? void 0 : check.fix,
+        blindSpots: meta.blindSpots,
+        finding,
+    };
+}