claude-crap 0.1.2

package/dist/adapters/index.js

@@ -0,0 +1,64 @@
+/**
+ * Public SDK entry point for the per-scanner SARIF adapters.
+ *
+ * Adapters convert a scanner's native output (SARIF, JSON, or some
+ * other structured format) into a normalized `PersistedSarif`
+ * document that the `SarifStore` can ingest directly. Every adapter
+ * enriches its findings with a stable `effortMinutes` value on the
+ * `properties` bag so the Stop quality gate and the project score
+ * engine can compute a Technical Debt Ratio.
+ *
+ * Usage:
+ *
+ * ```ts
+ * import {
+ *   adaptScannerOutput,
+ *   adaptSemgrep,
+ *   adaptEslint,
+ *   adaptBandit,
+ *   adaptStryker,
+ * } from "claude-crap/adapters";
+ *
+ * const result = adaptScannerOutput("eslint", rawJsonFromEslint);
+ * sarifStore.ingestRun(result.document, result.sourceTool);
+ * ```
+ *
+ * @module adapters
+ */
+export { adaptSemgrep } from "./semgrep.js";
+export { adaptEslint } from "./eslint.js";
+export { adaptBandit } from "./bandit.js";
+export { adaptStryker } from "./stryker.js";
+export { DEFAULT_EFFORT_BY_SEVERITY, KNOWN_SCANNERS, estimateEffortMinutes, wrapResultsInSarif, } from "./common.js";
+import { adaptSemgrep } from "./semgrep.js";
+import { adaptEslint } from "./eslint.js";
+import { adaptBandit } from "./bandit.js";
+import { adaptStryker } from "./stryker.js";
+/**
+ * Route a raw scanner output to the correct adapter based on its
+ * name. Preferred entry point for the `ingest_scanner_output` MCP
+ * tool — the dispatch is a single switch so the compiler can verify
+ * every case with `never` exhaustiveness.
+ *
+ * @param scanner   One of the known scanner identifiers.
+ * @param rawOutput The scanner's native output (string or parsed).
+ * @returns         A normalized `AdapterResult`.
+ * @throws          When `scanner` is unknown or the raw output is malformed.
+ */
+export function adaptScannerOutput(scanner, rawOutput) {
+    switch (scanner) {
+        case "semgrep":
+            return adaptSemgrep(rawOutput);
+        case "eslint":
+            return adaptEslint(rawOutput);
+        case "bandit":
+            return adaptBandit(rawOutput);
+        case "stryker":
+            return adaptStryker(rawOutput);
+        default: {
+            const exhaustive = scanner;
+            throw new Error(`[adapters] Unknown scanner: ${String(exhaustive)}`);
+        }
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/adapters/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/adapters/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAE5C,OAAO,EACL,0BAA0B,EAC1B,cAAc,EACd,qBAAqB,EACrB,kBAAkB,GACnB,MAAM,aAAa,CAAC;AAIrB,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAG5C;;;;;;;;;;GAUG;AACH,MAAM,UAAU,kBAAkB,CAChC,OAAqB,EACrB,SAAkB;IAElB,QAAQ,OAAO,EAAE,CAAC;QAChB,KAAK,SAAS;YACZ,OAAO,YAAY,CAAC,SAAS,CAAC,CAAC;QACjC,KAAK,QAAQ;YACX,OAAO,WAAW,CAAC,SAAS,CAAC,CAAC;QAChC,KAAK,QAAQ;YACX,OAAO,WAAW,CAAC,SAAS,CAAC,CAAC;QAChC,KAAK,SAAS;YACZ,OAAO,YAAY,CAAC,SAAS,CAAC,CAAC;QACjC,OAAO,CAAC,CAAC,CAAC;YACR,MAAM,UAAU,GAAU,OAAO,CAAC;YAClC,MAAM,IAAI,KAAK,CAAC,+BAA+B,MAAM,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC;QACvE,CAAC;IACH,CAAC;AACH,CAAC"}

package/dist/adapters/semgrep.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Semgrep adapter.
+ *
+ * Semgrep already emits SARIF 2.1.0 natively when invoked with
+ * `--sarif`, so this adapter's job is not translation but
+ * **enrichment**: we walk every `result` entry and stamp a
+ * `properties.effortMinutes` value so the Stop quality gate can
+ * compute a Technical Debt Ratio, plus we normalize the
+ * `properties.sourceTool` field so downstream consumers always know
+ * the finding came from Semgrep.
+ *
+ * If the caller passes a string, we parse it as JSON. If they pass an
+ * object that already matches the SARIF 2.1.0 envelope, we use it
+ * directly. Anything else throws a descriptive error that the MCP
+ * tool handler surfaces back to the LLM.
+ *
+ * @module adapters/semgrep
+ */
+import { type AdapterResult } from "./common.js";
+/**
+ * Accept a Semgrep SARIF document (as a string or object) and return
+ * an enriched `PersistedSarif` with effort estimates and a normalized
+ * `sourceTool` field.
+ *
+ * @param input     Raw SARIF document from Semgrep (`JSON.stringify`ed or parsed).
+ * @returns         The enriched document plus per-run stats.
+ * @throws          When the input is not a SARIF 2.1.0 document.
+ */
+export declare function adaptSemgrep(input: unknown): AdapterResult;
+//# sourceMappingURL=semgrep.d.ts.map

package/dist/adapters/semgrep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"semgrep.d.ts","sourceRoot":"","sources":["../../src/adapters/semgrep.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAIH,OAAO,EAEL,KAAK,aAAa,EAEnB,MAAM,aAAa,CAAC;AAiBrB;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,aAAa,CA8D1D"}

package/dist/adapters/semgrep.js

@@ -0,0 +1,130 @@
+/**
+ * Semgrep adapter.
+ *
+ * Semgrep already emits SARIF 2.1.0 natively when invoked with
+ * `--sarif`, so this adapter's job is not translation but
+ * **enrichment**: we walk every `result` entry and stamp a
+ * `properties.effortMinutes` value so the Stop quality gate can
+ * compute a Technical Debt Ratio, plus we normalize the
+ * `properties.sourceTool` field so downstream consumers always know
+ * the finding came from Semgrep.
+ *
+ * If the caller passes a string, we parse it as JSON. If they pass an
+ * object that already matches the SARIF 2.1.0 envelope, we use it
+ * directly. Anything else throws a descriptive error that the MCP
+ * tool handler surfaces back to the LLM.
+ *
+ * @module adapters/semgrep
+ */
+import { estimateEffortMinutes, } from "./common.js";
+const SEMGREP = "semgrep";
+/**
+ * Rule-id effort overrides. Semgrep emits lots of stylistic rules
+ * that take less than a minute to fix and a handful of deep security
+ * rules that deserve more budget than the default warning tier. The
+ * list below is intentionally short — teams should extend it.
+ */
+const SEMGREP_EFFORT_OVERRIDES = new Map([
+    [/security\./i, 90],
+    [/sqli|xss|ssrf|rce|deserial|crypto/i, 120],
+    [/style\./i, 5],
+    [/formatting\./i, 3],
+]);
+/**
+ * Accept a Semgrep SARIF document (as a string or object) and return
+ * an enriched `PersistedSarif` with effort estimates and a normalized
+ * `sourceTool` field.
+ *
+ * @param input     Raw SARIF document from Semgrep (`JSON.stringify`ed or parsed).
+ * @returns         The enriched document plus per-run stats.
+ * @throws          When the input is not a SARIF 2.1.0 document.
+ */
+export function adaptSemgrep(input) {
+    const doc = coerceToSarif(input);
+    let findingCount = 0;
+    let totalEffortMinutes = 0;
+    // We deep-clone the document so callers don't observe a mutation on
+    // the value they passed us. JSON round-trip is cheap here; a
+    // typical Semgrep SARIF report is well under 1 MB.
+    //
+    // We operate on the cloned value through a loose `Record`-based view
+    // to keep the adapter agnostic to the full SARIF schema — the
+    // canonical types live in `sarif-store.ts` and we only care about a
+    // handful of fields here. The final return casts through `unknown`
+    // because the JSON round-trip is shape-preserving by construction.
+    const cloned = JSON.parse(JSON.stringify(doc));
+    const runs = Array.isArray(cloned.runs) ? cloned.runs : [];
+    for (const run of runs) {
+        const rawResults = run["results"];
+        const results = Array.isArray(rawResults) ? rawResults : [];
+        for (const result of results) {
+            findingCount += 1;
+            const ruleId = typeof result["ruleId"] === "string" ? result["ruleId"] : "";
+            const level = result["level"];
+            const override = matchOverride(ruleId);
+            const effort = estimateEffortMinutes(level, override);
+            totalEffortMinutes += effort;
+            const existingProps = result["properties"] && typeof result["properties"] === "object"
+                ? result["properties"]
+                : {};
+            result["properties"] = {
+                ...existingProps,
+                sourceTool: SEMGREP,
+                effortMinutes: effort,
+            };
+        }
+        // Overwrite tool.driver.name so store-level filters always match
+        // `"semgrep"` regardless of the label Semgrep reported. Preserve
+        // the existing version and rules[] array when present.
+        const existingTool = run["tool"] ?? {};
+        const existingDriver = existingTool["driver"] ?? {};
+        const driverOut = {
+            name: SEMGREP,
+            version: typeof existingDriver["version"] === "string" ? existingDriver["version"] : "unknown",
+        };
+        if (Array.isArray(existingDriver["rules"])) {
+            driverOut["rules"] = existingDriver["rules"];
+        }
+        run["tool"] = { driver: driverOut };
+    }
+    return {
+        document: cloned,
+        sourceTool: SEMGREP,
+        findingCount,
+        totalEffortMinutes,
+    };
+}
+/**
+ * Accept either a pre-parsed SARIF object or a JSON string and return
+ * a strongly-typed `PersistedSarif`. Throws on malformed input.
+ *
+ * @param input Raw caller-provided value.
+ */
+function coerceToSarif(input) {
+    const parsed = typeof input === "string" ? JSON.parse(input) : input;
+    if (!parsed || typeof parsed !== "object") {
+        throw new Error(`[adapter:semgrep] input is not a SARIF object`);
+    }
+    const doc = parsed;
+    if (doc.version !== "2.1.0") {
+        throw new Error(`[adapter:semgrep] expected SARIF version 2.1.0, got ${String(doc.version)}`);
+    }
+    if (!Array.isArray(doc.runs)) {
+        throw new Error(`[adapter:semgrep] document is missing a runs[] array`);
+    }
+    return parsed;
+}
+/**
+ * Return the effort override (in minutes) matching the first pattern
+ * that matches the given rule id, or `undefined` when none match.
+ *
+ * @param ruleId Semgrep rule identifier.
+ */
+function matchOverride(ruleId) {
+    for (const [pattern, minutes] of SEMGREP_EFFORT_OVERRIDES) {
+        if (pattern.test(ruleId))
+            return minutes;
+    }
+    return undefined;
+}
+//# sourceMappingURL=semgrep.js.map

package/dist/adapters/semgrep.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"semgrep.js","sourceRoot":"","sources":["../../src/adapters/semgrep.ts"],"names":[],"mappings":"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"}

package/dist/adapters/stryker.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Stryker (JavaScript mutation testing) adapter.
+ *
+ * Stryker emits a JSON report under `reports/mutation/mutation.json`.
+ * The report shape is documented at
+ * https://stryker-mutator.io/docs/mutation-testing-elements/mutant-result-schema/ :
+ *
+ *   {
+ *     "schemaVersion": "1.0",
+ *     "thresholds": { ... },
+ *     "files": {
+ *       "src/foo.ts": {
+ *         "language": "typescript",
+ *         "source": "...",
+ *         "mutants": [
+ *           {
+ *             "id": "1",
+ *             "mutatorName": "ConditionalExpression",
+ *             "replacement": "false",
+ *             "location": {
+ *               "start": { "line": 10, "column": 5 },
+ *               "end":   { "line": 10, "column": 15 }
+ *             },
+ *             "status": "Survived",   // Killed | Survived | Timeout | NoCoverage | RuntimeError | CompileError | Ignored
+ *             "statusReason": "..."
+ *           }
+ *         ]
+ *       }
+ *     }
+ *   }
+ *
+ * This adapter treats every **surviving mutant** as a SARIF
+ * `error`-level finding — surviving mutants are exactly the ones the
+ * Golden Rule forbids, because they prove the test suite does not
+ * pin the code's behavior tightly enough to notice a change.
+ *
+ * Mutants with status `NoCoverage` become `warning`-level findings
+ * (not blocking the Stop gate by themselves, but still ingested so
+ * the dashboard can surface uncovered lines). All other statuses are
+ * ignored — they do not represent defects.
+ *
+ * @module adapters/stryker
+ */
+import { type AdapterResult } from "./common.js";
+/**
+ * Accept a Stryker JSON mutation report and return a normalized
+ * `PersistedSarif` document with one finding per surviving mutant
+ * and per uncovered mutant.
+ *
+ * @param input Raw Stryker report (string or parsed object).
+ * @returns     Adapter result.
+ * @throws      When the input is not a Stryker mutation report.
+ */
+export declare function adaptStryker(input: unknown): AdapterResult;
+//# sourceMappingURL=stryker.d.ts.map

package/dist/adapters/stryker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stryker.d.ts","sourceRoot":"","sources":["../../src/adapters/stryker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAGH,OAAO,EAGL,KAAK,aAAa,EAEnB,MAAM,aAAa,CAAC;AA0BrB;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,aAAa,CA8D1D"}

package/dist/adapters/stryker.js

@@ -0,0 +1,165 @@
+/**
+ * Stryker (JavaScript mutation testing) adapter.
+ *
+ * Stryker emits a JSON report under `reports/mutation/mutation.json`.
+ * The report shape is documented at
+ * https://stryker-mutator.io/docs/mutation-testing-elements/mutant-result-schema/ :
+ *
+ *   {
+ *     "schemaVersion": "1.0",
+ *     "thresholds": { ... },
+ *     "files": {
+ *       "src/foo.ts": {
+ *         "language": "typescript",
+ *         "source": "...",
+ *         "mutants": [
+ *           {
+ *             "id": "1",
+ *             "mutatorName": "ConditionalExpression",
+ *             "replacement": "false",
+ *             "location": {
+ *               "start": { "line": 10, "column": 5 },
+ *               "end":   { "line": 10, "column": 15 }
+ *             },
+ *             "status": "Survived",   // Killed | Survived | Timeout | NoCoverage | RuntimeError | CompileError | Ignored
+ *             "statusReason": "..."
+ *           }
+ *         ]
+ *       }
+ *     }
+ *   }
+ *
+ * This adapter treats every **surviving mutant** as a SARIF
+ * `error`-level finding — surviving mutants are exactly the ones the
+ * Golden Rule forbids, because they prove the test suite does not
+ * pin the code's behavior tightly enough to notice a change.
+ *
+ * Mutants with status `NoCoverage` become `warning`-level findings
+ * (not blocking the Stop gate by themselves, but still ingested so
+ * the dashboard can surface uncovered lines). All other statuses are
+ * ignored — they do not represent defects.
+ *
+ * @module adapters/stryker
+ */
+import { estimateEffortMinutes, wrapResultsInSarif, } from "./common.js";
+const STRYKER = "stryker";
+/**
+ * Accept a Stryker JSON mutation report and return a normalized
+ * `PersistedSarif` document with one finding per surviving mutant
+ * and per uncovered mutant.
+ *
+ * @param input Raw Stryker report (string or parsed object).
+ * @returns     Adapter result.
+ * @throws      When the input is not a Stryker mutation report.
+ */
+export function adaptStryker(input) {
+    const parsed = typeof input === "string" ? JSON.parse(input) : input;
+    if (!parsed || typeof parsed !== "object") {
+        throw new Error(`[adapter:stryker] expected a JSON object`);
+    }
+    const report = parsed;
+    if (!report.files || typeof report.files !== "object") {
+        throw new Error(`[adapter:stryker] report is missing a files{} map`);
+    }
+    const results = [];
+    let totalEffortMinutes = 0;
+    for (const [filename, fileReport] of Object.entries(report.files)) {
+        const mutants = Array.isArray(fileReport?.mutants) ? fileReport.mutants : [];
+        for (const mutant of mutants) {
+            const level = classifyMutant(mutant.status);
+            if (level === null)
+                continue; // Killed / Ignored / CompileError — not a defect
+            const startLine = mutant.location?.start?.line ?? 1;
+            const startColumn = mutant.location?.start?.column ?? 1;
+            const endLine = mutant.location?.end?.line;
+            const endColumn = mutant.location?.end?.column;
+            // Surviving mutants cost more to fix than the default error
+            // budget because the agent has to first write a killing test,
+            // THEN possibly rewrite the code.
+            const effortOverride = level === "error" ? 45 : 15;
+            const effort = estimateEffortMinutes(level, effortOverride);
+            totalEffortMinutes += effort;
+            const mutator = mutant.mutatorName ?? "Unknown";
+            const ruleId = `stryker.${mutator}`;
+            const statusText = mutant.status ?? "Unknown";
+            const message = `${statusText}: ${mutator} mutant on '${mutant.replacement ?? "?"}'` +
+                (mutant.statusReason ? ` — ${mutant.statusReason}` : "");
+            results.push(buildSarifResult({
+                ruleId,
+                level,
+                message,
+                uri: filename,
+                startLine,
+                startColumn,
+                endLine: typeof endLine === "number" ? endLine : undefined,
+                endColumn: typeof endColumn === "number" ? endColumn : undefined,
+                effortMinutes: effort,
+                mutantId: mutant.id,
+                mutator,
+                mutantStatus: statusText,
+            }));
+        }
+    }
+    return {
+        document: wrapResultsInSarif(STRYKER, String(report.schemaVersion ?? "unknown"), results),
+        sourceTool: STRYKER,
+        findingCount: results.length,
+        totalEffortMinutes,
+    };
+}
+/**
+ * Classify a Stryker mutant status into a SARIF level, or `null` when
+ * the status represents a mutant that was correctly handled by the
+ * test suite and should not produce a finding.
+ */
+function classifyMutant(status) {
+    switch ((status ?? "").toLowerCase()) {
+        case "survived":
+            return "error";
+        case "nocoverage":
+            return "warning";
+        case "timeout":
+            // Timeout mutants are suspicious but not proof of defect —
+            // they deserve a note so the dashboard highlights them.
+            return "note";
+        case "killed":
+        case "ignored":
+        case "compileerror":
+        case "runtimeerror":
+        default:
+            return null;
+    }
+}
+/**
+ * Build the SARIF `result` object for a single Stryker mutant. We
+ * propagate the mutant id, mutator name, and raw status into
+ * `properties` so the dashboard can display them as tags.
+ */
+function buildSarifResult(opts) {
+    return {
+        ruleId: opts.ruleId,
+        level: opts.level,
+        message: { text: opts.message },
+        locations: [
+            {
+                physicalLocation: {
+                    artifactLocation: { uri: opts.uri },
+                    region: {
+                        startLine: opts.startLine,
+                        startColumn: opts.startColumn,
+                        ...(opts.endLine !== undefined ? { endLine: opts.endLine } : {}),
+                        ...(opts.endColumn !== undefined ? { endColumn: opts.endColumn } : {}),
+                    },
+                },
+            },
+        ],
+        properties: {
+            sourceTool: STRYKER,
+            effortMinutes: opts.effortMinutes,
+            ...(opts.mutantId ? { mutantId: opts.mutantId } : {}),
+            ...(opts.mutator ? { mutator: opts.mutator } : {}),
+            ...(opts.mutantStatus ? { mutantStatus: opts.mutantStatus } : {}),
+        },
+    };
+}
+//# sourceMappingURL=stryker.js.map

package/dist/adapters/stryker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stryker.js","sourceRoot":"","sources":["../../src/adapters/stryker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAGH,OAAO,EACL,qBAAqB,EACrB,kBAAkB,GAGnB,MAAM,aAAa,CAAC;AAErB,MAAM,OAAO,GAAiB,SAAS,CAAC;AAwBxC;;;;;;;;GAQG;AACH,MAAM,UAAU,YAAY,CAAC,KAAc;IACzC,MAAM,MAAM,GAAG,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAE,IAAI,CAAC,KAAK,CAAC,KAAK,CAAa,CAAC,CAAC,CAAC,KAAK,CAAC;IAClF,IAAI,CAAC,MAAM,IAAI,OAAO,MAAM,KAAK,QAAQ,EAAE,CAAC;QAC1C,MAAM,IAAI,KAAK,CAAC,0CAA0C,CAAC,CAAC;IAC9D,CAAC;IACD,MAAM,MAAM,GAAG,MAAuB,CAAC;IACvC,IAAI,CAAC,MAAM,CAAC,KAAK,IAAI,OAAO,MAAM,CAAC,KAAK,KAAK,QAAQ,EAAE,CAAC;QACtD,MAAM,IAAI,KAAK,CAAC,mDAAmD,CAAC,CAAC;IACvE,CAAC;IAED,MAAM,OAAO,GAA+C,EAAE,CAAC;IAC/D,IAAI,kBAAkB,GAAG,CAAC,CAAC;IAE3B,KAAK,MAAM,CAAC,QAAQ,EAAE,UAAU,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;QAClE,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC;QAC7E,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;YAC7B,MAAM,KAAK,GAAG,cAAc,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;YAC5C,IAAI,KAAK,KAAK,IAAI;gBAAE,SAAS,CAAC,iDAAiD;YAC/E,MAAM,SAAS,GAAG,MAAM,CAAC,QAAQ,EAAE,KAAK,EAAE,IAAI,IAAI,CAAC,CAAC;YACpD,MAAM,WAAW,GAAG,MAAM,CAAC,QAAQ,EAAE,KAAK,EAAE,MAAM,IAAI,CAAC,CAAC;YACxD,MAAM,OAAO,GAAG,MAAM,CAAC,QAAQ,EAAE,GAAG,EAAE,IAAI,CAAC;YAC3C,MAAM,SAAS,GAAG,MAAM,CAAC,QAAQ,EAAE,GAAG,EAAE,MAAM,CAAC;YAE/C,4DAA4D;YAC5D,8DAA8D;YAC9D,kCAAkC;YAClC,MAAM,cAAc,GAAG,KAAK,KAAK,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YACnD,MAAM,MAAM,GAAG,qBAAqB,CAAC,KAAK,EAAE,cAAc,CAAC,CAAC;YAC5D,kBAAkB,IAAI,MAAM,CAAC;YAE7B,MAAM,OAAO,GAAG,MAAM,CAAC,WAAW,IAAI,SAAS,CAAC;YAChD,MAAM,MAAM,GAAG,WAAW,OAAO,EAAE,CAAC;YACpC,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,IAAI,SAAS,CAAC;YAC9C,MAAM,OAAO,GACX,GAAG,UAAU,KAAK,OAAO,eAAe,MAAM,CAAC,WAAW,IAAI,GAAG,GAAG;gBACpE,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC,MAAM,MAAM,CAAC,YAAY,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;YAE3D,OAAO,CAAC,IAAI,CACV,gBAAgB,CAAC;gBACf,MAAM;gBACN,KAAK;gBACL,OAAO;gBACP,GAAG,EAAE,QAAQ;gBACb,SAAS;gBACT,WAAW;gBACX,OAAO,EAAE,OAAO,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS;gBAC1D,SAAS,EAAE,OAAO,SAAS,KAAK,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS;gBAChE,aAAa,EAAE,MAAM;gBACrB,QAAQ,EAAE,MAAM,CAAC,EAAE;gBACnB,OAAO;gBACP,YAAY,EAAE,UAAU;aACzB,CAAC,CACH,CAAC;QACJ,CAAC;IACH,CAAC;IAED,OAAO;QACL,QAAQ,EAAE,kBAAkB,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,aAAa,IAAI,SAAS,CAAC,EAAE,OAAO,CAAC;QACzF,UAAU,EAAE,OAAO;QACnB,YAAY,EAAE,OAAO,CAAC,MAAM;QAC5B,kBAAkB;KACnB,CAAC;AACJ,CAAC;AAED;;;;GAIG;AACH,SAAS,cAAc,CAAC,MAA0B;IAChD,QAAQ,CAAC,MAAM,IAAI,EAAE,CAAC,CAAC,WAAW,EAAE,EAAE,CAAC;QACrC,KAAK,UAAU;YACb,OAAO,OAAO,CAAC;QACjB,KAAK,YAAY;YACf,OAAO,SAAS,CAAC;QACnB,KAAK,SAAS;YACZ,2DAA2D;YAC3D,wDAAwD;YACxD,OAAO,MAAM,CAAC;QAChB,KAAK,QAAQ,CAAC;QACd,KAAK,SAAS,CAAC;QACf,KAAK,cAAc,CAAC;QACpB,KAAK,cAAc,CAAC;QACpB;YACE,OAAO,IAAI,CAAC;IAChB,CAAC;AACH,CAAC;AAED;;;;GAIG;AACH,SAAS,gBAAgB,CAAC,IAazB;IACC,OAAO;QACL,MAAM,EAAE,IAAI,CAAC,MAAM;QACnB,KAAK,EAAE,IAAI,CAAC,KAAK;QACjB,OAAO,EAAE,EAAE,IAAI,EAAE,IAAI,CAAC,OAAO,EAAE;QAC/B,SAAS,EAAE;YACT;gBACE,gBAAgB,EAAE;oBAChB,gBAAgB,EAAE,EAAE,GAAG,EAAE,IAAI,CAAC,GAAG,EAAE;oBACnC,MAAM,EAAE;wBACN,SAAS,EAAE,IAAI,CAAC,SAAS;wBACzB,WAAW,EAAE,IAAI,CAAC,WAAW;wBAC7B,GAAG,CAAC,IAAI,CAAC,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;wBAChE,GAAG,CAAC,IAAI,CAAC,SAAS,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;qBACvE;iBACF;aACF;SACF;QACD,UAAU,EAAE;YACV,UAAU,EAAE,OAAO;YACnB,aAAa,EAAE,IAAI,CAAC,aAAa;YACjC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YACrD,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YAClD,GAAG,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,YAAY,EAAE,IAAI,CAAC,YAAY,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;SAClE;KACF,CAAC;AACJ,CAAC"}

package/dist/ast/cyclomatic.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Deterministic cyclomatic complexity walker.
+ *
+ * Given a tree-sitter subtree rooted at a function node, this module walks
+ * the tree and returns the McCabe cyclomatic complexity number. The
+ * algorithm is the standard "1 + (branching nodes + short-circuit operators)"
+ * formulation:
+ *
+ *   CC = 1
+ *      + count of branching-statement nodes (if, while, for, case, catch, ...)
+ *      + count of short-circuit operators (&&, ||, ??, `and`, `or`)
+ *      + count of ternary expressions (counted as branching nodes)
+ *
+ * The baseline of 1 represents the straight-line path through the function.
+ * Every additional branching point multiplies the set of reachable paths.
+ *
+ * The walker is deliberately language-agnostic: it consults the
+ * {@link LanguageConfig} passed in to decide which node types to count.
+ * Nested functions inside the subtree are **skipped** — each function's
+ * complexity is reported independently by {@link TreeSitterEngine}.
+ *
+ * @module ast/cyclomatic
+ */
+import type { LanguageConfig } from "./language-config.js";
+/**
+ * Minimal structural contract of a tree-sitter node. We intentionally
+ * avoid importing `web-tree-sitter` types here so this module stays
+ * unit-testable with a hand-rolled mock tree.
+ */
+export interface AstNode {
+    /** Node type name from the grammar (e.g. `"if_statement"`). */
+    readonly type: string;
+    /** Raw source text for operator detection. May be large — do not log. */
+    readonly text: string;
+    /** Zero-based child count. */
+    readonly childCount: number;
+    /** Retrieve a child by index. Returns `null` if out of range. */
+    child(index: number): AstNode | null;
+}
+/**
+ * Compute the cyclomatic complexity of a function subtree.
+ *
+ * @param root           Node rooted at the function (method, arrow, lambda, ...).
+ * @param languageConfig Language classification tables for node types.
+ * @returns              The McCabe cyclomatic complexity (always ≥ 1).
+ */
+export declare function computeCyclomaticComplexity(root: AstNode, languageConfig: LanguageConfig): number;
+//# sourceMappingURL=cyclomatic.d.ts.map

package/dist/ast/cyclomatic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cyclomatic.d.ts","sourceRoot":"","sources":["../../src/ast/cyclomatic.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE3D;;;;GAIG;AACH,MAAM,WAAW,OAAO;IACtB,+DAA+D;IAC/D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,yEAAyE;IACzE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,8BAA8B;IAC9B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,iEAAiE;IACjE,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC;CACtC;AAED;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,OAAO,EAAE,cAAc,EAAE,cAAc,GAAG,MAAM,CAiBjG"}

package/dist/ast/cyclomatic.js

@@ -0,0 +1,106 @@
+/**
+ * Deterministic cyclomatic complexity walker.
+ *
+ * Given a tree-sitter subtree rooted at a function node, this module walks
+ * the tree and returns the McCabe cyclomatic complexity number. The
+ * algorithm is the standard "1 + (branching nodes + short-circuit operators)"
+ * formulation:
+ *
+ *   CC = 1
+ *      + count of branching-statement nodes (if, while, for, case, catch, ...)
+ *      + count of short-circuit operators (&&, ||, ??, `and`, `or`)
+ *      + count of ternary expressions (counted as branching nodes)
+ *
+ * The baseline of 1 represents the straight-line path through the function.
+ * Every additional branching point multiplies the set of reachable paths.
+ *
+ * The walker is deliberately language-agnostic: it consults the
+ * {@link LanguageConfig} passed in to decide which node types to count.
+ * Nested functions inside the subtree are **skipped** — each function's
+ * complexity is reported independently by {@link TreeSitterEngine}.
+ *
+ * @module ast/cyclomatic
+ */
+/**
+ * Compute the cyclomatic complexity of a function subtree.
+ *
+ * @param root           Node rooted at the function (method, arrow, lambda, ...).
+ * @param languageConfig Language classification tables for node types.
+ * @returns              The McCabe cyclomatic complexity (always ≥ 1).
+ */
+export function computeCyclomaticComplexity(root, languageConfig) {
+    let complexity = 1;
+    walk(root, languageConfig, true, (node) => {
+        if (languageConfig.branchingNodeTypes.has(node.type)) {
+            complexity += 1;
+            return;
+        }
+        // Boolean / short-circuit operators are usually represented as
+        // "binary_expression" nodes with an operator token child. To avoid
+        // coupling to a specific grammar's node shape, we inspect the raw
+        // text of the node's direct operator child.
+        if (isBooleanExpression(node, languageConfig)) {
+            complexity += 1;
+            return;
+        }
+    });
+    return complexity;
+}
+/**
+ * Depth-first walk that skips any nested function subtree so that its
+ * complexity is not attributed to the enclosing function.
+ *
+ * @param node           Current node being visited.
+ * @param languageConfig Language tables used to detect nested functions.
+ * @param isRoot         `true` for the starting node (we do not skip it).
+ * @param visit          Callback invoked for every non-function descendant.
+ */
+function walk(node, languageConfig, isRoot, visit) {
+    if (!isRoot && languageConfig.functionNodeTypes.has(node.type)) {
+        // Nested function — stop the walk here. Its complexity is reported
+        // separately when the engine iterates the top-level function list.
+        return;
+    }
+    visit(node);
+    for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (child)
+            walk(child, languageConfig, false, visit);
+    }
+}
+/**
+ * Return `true` when `node` is a boolean / short-circuit expression that
+ * should add one to the cyclomatic complexity. We inspect the node's
+ * immediate children for an operator token whose text matches one of the
+ * language's short-circuit operators.
+ *
+ * This is a heuristic — grammars differ in how they represent operators
+ * — but it is stable enough for the five supported languages because:
+ *
+ *   - JavaScript / TypeScript / Java: binary expression with `"&&"` or `"||"` token child.
+ *   - Python: `boolean_operator` node with `"and"` / `"or"` token child.
+ *   - C#: binary expression with `"&&"`, `"||"`, or `"??"` token child.
+ *
+ * @param node           Candidate node.
+ * @param languageConfig Tables with the language's boolean operator set.
+ * @returns              `true` when the node is a counted boolean expression.
+ */
+function isBooleanExpression(node, languageConfig) {
+    // Common type names across supported grammars. We check the type first
+    // to avoid scanning text for every node in the tree.
+    if (node.type !== "binary_expression" &&
+        node.type !== "boolean_operator" &&
+        node.type !== "logical_expression") {
+        return false;
+    }
+    for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (!child)
+            continue;
+        if (languageConfig.booleanOperators.includes(child.text)) {
+            return true;
+        }
+    }
+    return false;
+}
+//# sourceMappingURL=cyclomatic.js.map

package/dist/ast/cyclomatic.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cyclomatic.js","sourceRoot":"","sources":["../../src/ast/cyclomatic.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAoBH;;;;;;GAMG;AACH,MAAM,UAAU,2BAA2B,CAAC,IAAa,EAAE,cAA8B;IACvF,IAAI,UAAU,GAAG,CAAC,CAAC;IACnB,IAAI,CAAC,IAAI,EAAE,cAAc,EAAE,IAAI,EAAE,CAAC,IAAI,EAAE,EAAE;QACxC,IAAI,cAAc,CAAC,kBAAkB,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;YACrD,UAAU,IAAI,CAAC,CAAC;YAChB,OAAO;QACT,CAAC;QACD,+DAA+D;QAC/D,mEAAmE;QACnE,kEAAkE;QAClE,4CAA4C;QAC5C,IAAI,mBAAmB,CAAC,IAAI,EAAE,cAAc,CAAC,EAAE,CAAC;YAC9C,UAAU,IAAI,CAAC,CAAC;YAChB,OAAO;QACT,CAAC;IACH,CAAC,CAAC,CAAC;IACH,OAAO,UAAU,CAAC;AACpB,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,IAAI,CACX,IAAa,EACb,cAA8B,EAC9B,MAAe,EACf,KAA2B;IAE3B,IAAI,CAAC,MAAM,IAAI,cAAc,CAAC,iBAAiB,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;QAC/D,mEAAmE;QACnE,mEAAmE;QACnE,OAAO;IACT,CAAC;IACD,KAAK,CAAC,IAAI,CAAC,CAAC;IACZ,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,UAAU,EAAE,CAAC,EAAE,EAAE,CAAC;QACzC,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAC5B,IAAI,KAAK;YAAE,IAAI,CAAC,KAAK,EAAE,cAAc,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;IACvD,CAAC;AACH,CAAC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,SAAS,mBAAmB,CAAC,IAAa,EAAE,cAA8B;IACxE,uEAAuE;IACvE,qDAAqD;IACrD,IACE,IAAI,CAAC,IAAI,KAAK,mBAAmB;QACjC,IAAI,CAAC,IAAI,KAAK,kBAAkB;QAChC,IAAI,CAAC,IAAI,KAAK,oBAAoB,EAClC,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IACD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,UAAU,EAAE,CAAC,EAAE,EAAE,CAAC;QACzC,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAC5B,IAAI,CAAC,KAAK;YAAE,SAAS;QACrB,IAAI,cAAc,CAAC,gBAAgB,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;YACzD,OAAO,IAAI,CAAC;QACd,CAAC;IACH,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/ast/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Public SDK entry point for the tree-sitter based AST engine and the
+ * cyclomatic complexity walker.
+ *
+ * Usage:
+ *
+ * ```ts
+ * import {
+ *   TreeSitterEngine,
+ *   computeCyclomaticComplexity,
+ *   detectLanguageFromPath,
+ *   type FileMetrics,
+ *   type FunctionMetrics,
+ *   type SupportedLanguage,
+ * } from "claude-crap/ast";
+ * ```
+ *
+ * @module ast
+ */
+export { TreeSitterEngine } from "./tree-sitter-engine.js";
+export type { AnalyzeFileRequest, FileMetrics, FunctionMetrics, TreeSitterEngineOptions, } from "./tree-sitter-engine.js";
+export { computeCyclomaticComplexity } from "./cyclomatic.js";
+export type { AstNode } from "./cyclomatic.js";
+export { LANGUAGE_TABLE, detectLanguageFromPath } from "./language-config.js";
+export type { LanguageConfig, SupportedLanguage } from "./language-config.js";
+//# sourceMappingURL=index.d.ts.map