@sebassdc/crap4ts 0.1.0

package/dist/complexity.js

@@ -0,0 +1,122 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractFunctions = extractFunctions;
+const typescript_1 = __importDefault(require("typescript"));
+function isFunctionLike(node) {
+    return (typescript_1.default.isFunctionDeclaration(node) ||
+        typescript_1.default.isMethodDeclaration(node) ||
+        typescript_1.default.isArrowFunction(node) ||
+        typescript_1.default.isFunctionExpression(node) ||
+        typescript_1.default.isConstructorDeclaration(node) ||
+        typescript_1.default.isGetAccessorDeclaration(node) ||
+        typescript_1.default.isSetAccessorDeclaration(node));
+}
+const DECISION_KINDS = new Set([
+    typescript_1.default.SyntaxKind.IfStatement,
+    typescript_1.default.SyntaxKind.ConditionalExpression,
+    typescript_1.default.SyntaxKind.ForStatement,
+    typescript_1.default.SyntaxKind.ForInStatement,
+    typescript_1.default.SyntaxKind.ForOfStatement,
+    typescript_1.default.SyntaxKind.WhileStatement,
+    typescript_1.default.SyntaxKind.DoStatement,
+    typescript_1.default.SyntaxKind.CatchClause,
+    typescript_1.default.SyntaxKind.CaseClause,
+]);
+const LOGICAL_OPS = new Set([
+    typescript_1.default.SyntaxKind.AmpersandAmpersandToken,
+    typescript_1.default.SyntaxKind.BarBarToken,
+    typescript_1.default.SyntaxKind.QuestionQuestionToken,
+]);
+function nodeDecisionCount(node) {
+    if (DECISION_KINDS.has(node.kind))
+        return 1;
+    if (typescript_1.default.isBinaryExpression(node) && LOGICAL_OPS.has(node.operatorToken.kind))
+        return 1;
+    return 0;
+}
+function countDecisions(node) {
+    if (isFunctionLike(node))
+        return 0;
+    let count = nodeDecisionCount(node);
+    node.forEachChild(child => {
+        count += countDecisions(child);
+    });
+    return count;
+}
+function computeComplexity(node) {
+    const body = node.body;
+    if (!body)
+        return 1; // abstract method or overload signature
+    return 1 + countDecisions(body);
+}
+function visitObjectLiteralMethods(varName, obj, add) {
+    for (const prop of obj.properties) {
+        if (typescript_1.default.isMethodDeclaration(prop) ||
+            typescript_1.default.isGetAccessorDeclaration(prop) ||
+            typescript_1.default.isSetAccessorDeclaration(prop)) {
+            if (typescript_1.default.isIdentifier(prop.name)) {
+                add(`${varName}.${prop.name.text}`, prop);
+            }
+            else if (typescript_1.default.isStringLiteral(prop.name)) {
+                add(`${varName}['${prop.name.text}']`, prop);
+            }
+            // Skip computed property names (e.g., [Symbol.iterator])
+        }
+    }
+}
+function visitVariableStatement(stmt, add) {
+    for (const decl of stmt.declarationList.declarations) {
+        if (!typescript_1.default.isIdentifier(decl.name) || !decl.initializer)
+            continue;
+        if (typescript_1.default.isArrowFunction(decl.initializer) || typescript_1.default.isFunctionExpression(decl.initializer)) {
+            add(decl.name.text, decl.initializer);
+        }
+        else if (typescript_1.default.isObjectLiteralExpression(decl.initializer)) {
+            visitObjectLiteralMethods(decl.name.text, decl.initializer, add);
+        }
+    }
+}
+function visitClassDeclaration(stmt, add) {
+    if (!stmt.name)
+        return;
+    const className = stmt.name.text;
+    for (const member of stmt.members) {
+        if (typescript_1.default.isConstructorDeclaration(member)) {
+            add(`${className}.constructor`, member);
+        }
+        else if ((typescript_1.default.isMethodDeclaration(member) || typescript_1.default.isGetAccessorDeclaration(member) || typescript_1.default.isSetAccessorDeclaration(member)) &&
+            typescript_1.default.isIdentifier(member.name)) {
+            add(`${className}.${member.name.text}`, member);
+        }
+    }
+}
+function extractFunctions(source, filePath = 'file.ts') {
+    const sourceFile = typescript_1.default.createSourceFile(filePath, source, typescript_1.default.ScriptTarget.Latest, true);
+    const functions = [];
+    function lineOf(pos) {
+        return sourceFile.getLineAndCharacterOfPosition(pos).line + 1;
+    }
+    function add(name, node) {
+        functions.push({
+            name,
+            startLine: lineOf(node.getStart(sourceFile)),
+            endLine: lineOf(node.getEnd()),
+            complexity: computeComplexity(node),
+        });
+    }
+    for (const stmt of sourceFile.statements) {
+        if (typescript_1.default.isFunctionDeclaration(stmt) && stmt.name) {
+            add(stmt.name.text, stmt);
+        }
+        else if (typescript_1.default.isVariableStatement(stmt)) {
+            visitVariableStatement(stmt, add);
+        }
+        else if (typescript_1.default.isClassDeclaration(stmt)) {
+            visitClassDeclaration(stmt, add);
+        }
+    }
+    return functions;
+}

package/dist/config.d.ts

@@ -0,0 +1,15 @@
+import type { CliOptions } from './options';
+export interface Crap4tsConfig {
+    src?: string;
+    exclude?: string[];
+    output?: 'text' | 'json' | 'markdown' | 'csv';
+    runner?: 'vitest' | 'jest';
+    coverageCommand?: string;
+    failOnCrap?: number;
+    failOnComplexity?: number;
+    failOnCoverageBelow?: number;
+    top?: number;
+    timeout?: number;
+}
+export declare function loadConfig(explicitPath?: string): Crap4tsConfig;
+export declare function mergeConfigIntoOptions(opts: CliOptions, config: Crap4tsConfig): CliOptions;

package/dist/config.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfig = loadConfig;
+exports.mergeConfigIntoOptions = mergeConfigIntoOptions;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const CONFIG_FILES = ['crap4ts.config.json', '.crap4tsrc.json'];
+function loadConfig(explicitPath) {
+    if (explicitPath) {
+        if (!(0, fs_1.existsSync)(explicitPath)) {
+            throw new Error(`Config file not found: ${explicitPath}`);
+        }
+        return parseConfigFile(explicitPath);
+    }
+    for (const name of CONFIG_FILES) {
+        const fullPath = (0, path_1.join)(process.cwd(), name);
+        if ((0, fs_1.existsSync)(fullPath)) {
+            return parseConfigFile(fullPath);
+        }
+    }
+    return {};
+}
+function parseConfigFile(filePath) {
+    let raw;
+    try {
+        raw = (0, fs_1.readFileSync)(filePath, 'utf8');
+    }
+    catch (err) {
+        throw new Error(`Failed to read config file: ${filePath}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new Error(`Invalid JSON in config file ${filePath}. Check for syntax errors.`);
+    }
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+        throw new Error(`Config file ${filePath} must contain a JSON object.`);
+    }
+    return parsed;
+}
+function mergeNullableOptions(opts, config) {
+    return {
+        runner: opts.runner ?? config.runner,
+        coverageCommand: opts.coverageCommand ?? config.coverageCommand,
+        failOnCrap: opts.failOnCrap ?? config.failOnCrap,
+        failOnComplexity: opts.failOnComplexity ?? config.failOnComplexity,
+        failOnCoverageBelow: opts.failOnCoverageBelow ?? config.failOnCoverageBelow,
+        top: opts.top ?? config.top,
+    };
+}
+function mergeDefaultOptions(opts, config) {
+    return {
+        srcDir: opts.srcDir !== 'src' ? opts.srcDir : (config.src ?? opts.srcDir),
+        excludes: opts.excludes.length > 0 ? opts.excludes : (config.exclude ?? []),
+        output: opts.output !== 'text' ? opts.output : (config.output ?? 'text'),
+        timeoutMs: opts.timeoutMs !== 600_000 ? opts.timeoutMs : ((config.timeout ?? 600) * 1000),
+    };
+}
+function mergeConfigIntoOptions(opts, config) {
+    return {
+        ...opts,
+        ...mergeDefaultOptions(opts, config),
+        ...mergeNullableOptions(opts, config),
+    };
+}

package/dist/core.d.ts

@@ -0,0 +1,24 @@
+import { extractFunctions } from './complexity';
+import { CoverageData } from './coverage';
+import { CrapEntry } from './crap';
+export interface SourceScanOptions {
+    srcDirs: string[];
+    excludes: string[];
+}
+export declare function findSourceFilesWithOptions(opts: SourceScanOptions): string[];
+export declare function findSourceFiles(srcDir: string): string[];
+export declare function filterSources(files: string[], filters: string[]): string[];
+export declare function buildEntries(fns: ReturnType<typeof extractFunctions>, fileData: {
+    statementMap: Record<string, {
+        start: {
+            line: number;
+            column: number;
+        };
+        end: {
+            line: number;
+            column: number;
+        };
+    }>;
+    s: Record<string, number>;
+}, module: string): CrapEntry[];
+export declare function analyzeFile(filePath: string, filesData: CoverageData, srcDir: string): CrapEntry[];

package/dist/core.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findSourceFilesWithOptions = findSourceFilesWithOptions;
+exports.findSourceFiles = findSourceFiles;
+exports.filterSources = filterSources;
+exports.buildEntries = buildEntries;
+exports.analyzeFile = analyzeFile;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const complexity_1 = require("./complexity");
+const coverage_1 = require("./coverage");
+const crap_1 = require("./crap");
+function findSourceFilesWithOptions(opts) {
+    const fileSet = new Set();
+    function walk(dir) {
+        for (const entry of (0, fs_1.readdirSync)(dir)) {
+            if (entry === 'node_modules')
+                continue;
+            const full = (0, path_1.join)(dir, entry);
+            if (opts.excludes.some(ex => full.includes(ex)))
+                continue;
+            if ((0, fs_1.statSync)(full).isDirectory()) {
+                walk(full);
+            }
+            else if (/\.(ts|tsx)$/.test(entry) && !entry.endsWith('.d.ts')) {
+                fileSet.add(full);
+            }
+        }
+    }
+    for (const srcDir of opts.srcDirs) {
+        walk(srcDir);
+    }
+    return [...fileSet].sort();
+}
+function findSourceFiles(srcDir) {
+    return findSourceFilesWithOptions({ srcDirs: [srcDir], excludes: [] });
+}
+function filterSources(files, filters) {
+    if (filters.length === 0)
+        return files;
+    return files.filter(f => filters.some(filter => f.includes(filter)));
+}
+function buildEntries(fns, fileData, module) {
+    return fns.map(fn => {
+        const cov = (0, coverage_1.coverageForRange)(fileData, fn.startLine, fn.endLine);
+        return {
+            name: fn.name,
+            module,
+            complexity: fn.complexity,
+            coverage: cov,
+            crap: (0, crap_1.crapScore)(fn.complexity, cov),
+        };
+    });
+}
+function analyzeFile(filePath, filesData, srcDir) {
+    try {
+        const source = (0, fs_1.readFileSync)(filePath, 'utf-8');
+        const fns = (0, complexity_1.extractFunctions)(source, filePath);
+        const absolutePath = (0, coverage_1.normalizePath)((0, path_1.resolve)(filePath));
+        const module = (0, coverage_1.sourceToModule)(absolutePath, srcDir);
+        const fileData = filesData[absolutePath] ?? { statementMap: {}, s: {} };
+        return buildEntries(fns, fileData, module);
+    }
+    catch (e) {
+        console.warn(`crap4ts: skipping ${filePath} (parse error: ${e.message})`);
+        return [];
+    }
+}

package/dist/coverage.d.ts

@@ -0,0 +1,19 @@
+interface Location {
+    line: number;
+    column: number;
+}
+interface Range {
+    start: Location;
+    end: Location;
+}
+export interface FileCoverageData {
+    statementMap: Record<string, Range>;
+    s: Record<string, number>;
+}
+export type CoverageData = Record<string, FileCoverageData>;
+/** Normalize a file path to always use forward slashes. */
+export declare function normalizePath(p: string): string;
+export declare function parseCoverage(coverageDir: string): CoverageData;
+export declare function coverageForRange(fileData: FileCoverageData, startLine: number, endLine: number): number;
+export declare function sourceToModule(filePath: string, srcDir: string): string;
+export {};

package/dist/coverage.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizePath = normalizePath;
+exports.parseCoverage = parseCoverage;
+exports.coverageForRange = coverageForRange;
+exports.sourceToModule = sourceToModule;
+const fs_1 = require("fs");
+const path_1 = require("path");
+/** Normalize a file path to always use forward slashes. */
+function normalizePath(p) {
+    return p.replace(/\\/g, '/');
+}
+function assertValidCoverageEntry(key, entry) {
+    if (!entry || typeof entry !== 'object') {
+        throw new Error(`coverage-final.json entry ${key} is not an object`);
+    }
+    const e = entry;
+    if (!e.statementMap || typeof e.statementMap !== 'object') {
+        throw new Error(`coverage-final.json entry ${key} missing statementMap`);
+    }
+    if (!e.s || typeof e.s !== 'object') {
+        throw new Error(`coverage-final.json entry ${key} missing s`);
+    }
+}
+function assertValidCoverage(data) {
+    if (!data || typeof data !== 'object') {
+        throw new Error('coverage-final.json is not an object');
+    }
+    for (const [key, entry] of Object.entries(data)) {
+        assertValidCoverageEntry(key, entry);
+    }
+}
+function parseCoverage(coverageDir) {
+    const jsonPath = (0, path_1.join)(coverageDir, 'coverage-final.json');
+    const content = (0, fs_1.readFileSync)(jsonPath, 'utf-8');
+    let parsed;
+    try {
+        parsed = JSON.parse(content);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new Error(`coverage-final.json is not valid JSON: ${message}`);
+    }
+    assertValidCoverage(parsed);
+    // Normalize coverage keys to forward slashes so lookups are platform-independent
+    const normalized = {};
+    for (const [key, value] of Object.entries(parsed)) {
+        normalized[normalizePath(key)] = value;
+    }
+    return normalized;
+}
+function coverageForRange(fileData, startLine, endLine) {
+    let total = 0;
+    let covered = 0;
+    for (const [id, loc] of Object.entries(fileData.statementMap)) {
+        // Overlap check: statement overlaps function if it starts before the function ends
+        // AND ends after the function starts (standard range-overlap test).
+        if (loc.start.line <= endLine && loc.end.line >= startLine) {
+            total++;
+            if ((fileData.s[id] ?? 0) > 0)
+                covered++;
+        }
+    }
+    if (total === 0)
+        return 100.0;
+    return (covered / total) * 100;
+}
+function sourceToModule(filePath, srcDir) {
+    const normalized = normalizePath(filePath);
+    const src = normalizePath(srcDir).replace(/\/$/, '') + '/';
+    let mod = normalized;
+    if (mod.startsWith(src)) {
+        mod = mod.slice(src.length);
+    }
+    mod = mod.replace(/\.(ts|tsx|js|jsx)$/, '');
+    return mod.replace(/\//g, '.');
+}

package/dist/crap.d.ts

@@ -0,0 +1,13 @@
+export interface CrapEntry {
+    name: string;
+    module: string;
+    complexity: number;
+    coverage: number;
+    crap: number;
+}
+export declare function crapScore(complexity: number, coveragePct: number): number;
+export declare function sortByCrap(entries: CrapEntry[]): CrapEntry[];
+export declare function formatJsonReport(entries: CrapEntry[]): string;
+export declare function formatCsvReport(entries: CrapEntry[]): string;
+export declare function formatMarkdownReport(entries: CrapEntry[]): string;
+export declare function formatReport(entries: CrapEntry[]): string;

package/dist/crap.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.crapScore = crapScore;
+exports.sortByCrap = sortByCrap;
+exports.formatJsonReport = formatJsonReport;
+exports.formatCsvReport = formatCsvReport;
+exports.formatMarkdownReport = formatMarkdownReport;
+exports.formatReport = formatReport;
+function crapScore(complexity, coveragePct) {
+    const cc = complexity;
+    const uncov = 1.0 - coveragePct / 100.0;
+    return cc * cc * uncov * uncov * uncov + cc;
+}
+function sortByCrap(entries) {
+    return [...entries].sort((a, b) => b.crap - a.crap);
+}
+function formatJsonReport(entries) {
+    return JSON.stringify({ tool: 'crap4ts', entries }, null, 2);
+}
+function formatCsvReport(entries) {
+    const header = 'Function,Module,CC,Coverage,CRAP';
+    const rows = entries.map(e => {
+        const name = e.name.includes(',') ? `"${e.name}"` : e.name;
+        const mod = e.module.includes(',') ? `"${e.module}"` : e.module;
+        return `${name},${mod},${e.complexity},${e.coverage.toFixed(1)},${e.crap.toFixed(1)}`;
+    });
+    return [header, ...rows, ''].join('\n');
+}
+function formatMarkdownReport(entries) {
+    const header = '| Function | Module | CC | Cov% | CRAP |';
+    const sep = '|---|---|---:|---:|---:|';
+    const rows = entries.map(e => `| ${e.name} | ${e.module} | ${e.complexity} | ${e.coverage.toFixed(1)}% | ${e.crap.toFixed(1)} |`);
+    return ['# CRAP Report', '', header, sep, ...rows, ''].join('\n');
+}
+function formatReport(entries) {
+    const header = `${'Function'.padEnd(30)} ${'Module'.padEnd(35)} ${'CC'.padStart(4)} ${'Cov%'.padStart(6)} ${'CRAP'.padStart(8)}`;
+    const sep = '-'.repeat(header.length);
+    const rows = entries.map(e => {
+        const name = e.name.slice(0, 30).padEnd(30);
+        const mod = e.module.slice(0, 35).padEnd(35);
+        const cc = String(e.complexity).padStart(4);
+        const cov = `${e.coverage.toFixed(1)}%`.padStart(6);
+        const crap = e.crap.toFixed(1).padStart(8);
+        return `${name} ${mod} ${cc} ${cov} ${crap}`;
+    });
+    return ['CRAP Report', '===========', header, sep, ...rows, ''].join('\n');
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cli_1 = require("./cli");
+(0, cli_1.runCli)(process.argv.slice(2)).then(code => process.exit(code));

package/dist/options.d.ts

@@ -0,0 +1,17 @@
+export interface CliOptions {
+    mode: 'report' | 'help' | 'version';
+    filters: string[];
+    srcDir: string;
+    coverageDir: string;
+    timeoutMs: number;
+    output: 'text' | 'json' | 'markdown' | 'csv';
+    excludes: string[];
+    runner?: 'vitest' | 'jest';
+    coverageCommand?: string;
+    failOnCrap?: number;
+    failOnComplexity?: number;
+    failOnCoverageBelow?: number;
+    top?: number;
+    configPath?: string;
+}
+export declare function parseOptions(argv: string[]): CliOptions;

package/dist/options.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseOptions = parseOptions;
+function parseOutputFormat(v) {
+    const valid = ['text', 'json', 'markdown', 'csv'];
+    if (!v || !valid.includes(v)) {
+        throw new Error(`--output must be one of: ${valid.join(', ')}. Got: ${v}`);
+    }
+    return v;
+}
+function parseRunnerValue(v) {
+    if (!v)
+        throw new Error('--runner requires an argument');
+    if (v !== 'vitest' && v !== 'jest') {
+        throw new Error(`--runner must be 'vitest' or 'jest', got: ${v}`);
+    }
+    return v;
+}
+function parsePositiveNum(v, flag) {
+    const n = Number(v);
+    if (!v || !Number.isFinite(n) || n <= 0) {
+        throw new Error(`${flag} requires a positive number, got: ${v}`);
+    }
+    return n;
+}
+function parsePositiveInt(v, flag) {
+    const n = Number(v);
+    if (!v || !Number.isFinite(n) || n <= 0 || !Number.isInteger(n)) {
+        throw new Error(`${flag} requires a positive integer, got: ${v}`);
+    }
+    return n;
+}
+function parseRange(v, flag, min, max) {
+    const n = Number(v);
+    if (!v || !Number.isFinite(n) || n < min || n > max) {
+        throw new Error(`${flag} requires a number between ${min} and ${max}, got: ${v}`);
+    }
+    return n;
+}
+const FLAG_HANDLERS = {
+    '--json'(_argv, i, state) {
+        state.output = 'json';
+        return i;
+    },
+    '--output'(argv, i, state) {
+        state.output = parseOutputFormat(argv[i + 1]);
+        return i + 1;
+    },
+    '--src'(argv, i, state) {
+        const v = argv[i + 1];
+        if (!v)
+            throw new Error('--src requires a directory argument');
+        state.srcDir = v;
+        return i + 1;
+    },
+    '--timeout'(argv, i, state) {
+        state.timeoutMs = parsePositiveNum(argv[i + 1], '--timeout') * 1000;
+        return i + 1;
+    },
+    '--runner'(argv, i, state) {
+        state.runner = parseRunnerValue(argv[i + 1]);
+        return i + 1;
+    },
+    '--coverage-command'(argv, i, state) {
+        const v = argv[i + 1];
+        if (!v)
+            throw new Error('--coverage-command requires an argument');
+        state.coverageCommand = v;
+        return i + 1;
+    },
+    '--exclude'(argv, i, state) {
+        const v = argv[i + 1];
+        if (!v)
+            throw new Error('--exclude requires a pattern argument');
+        state.excludes.push(v);
+        return i + 1;
+    },
+    '--fail-on-crap'(argv, i, state) {
+        state.failOnCrap = parsePositiveNum(argv[i + 1], '--fail-on-crap');
+        return i + 1;
+    },
+    '--fail-on-complexity'(argv, i, state) {
+        state.failOnComplexity = parsePositiveNum(argv[i + 1], '--fail-on-complexity');
+        return i + 1;
+    },
+    '--fail-on-coverage-below'(argv, i, state) {
+        state.failOnCoverageBelow = parseRange(argv[i + 1], '--fail-on-coverage-below', 0, 100);
+        return i + 1;
+    },
+    '--top'(argv, i, state) {
+        state.top = parsePositiveInt(argv[i + 1], '--top');
+        return i + 1;
+    },
+    '--config'(argv, i, state) {
+        const v = argv[i + 1];
+        if (!v)
+            throw new Error('--config requires a file path argument');
+        state.configPath = v;
+        return i + 1;
+    },
+};
+const EARLY_EXIT_DEFAULTS = {
+    filters: [], srcDir: 'src', coverageDir: 'coverage', timeoutMs: 600_000, output: 'text', excludes: [],
+};
+function parseOptions(argv) {
+    const state = {
+        filters: [], excludes: [], srcDir: 'src', timeoutMs: 600_000, output: 'text',
+    };
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === '--help' || a === '-h') {
+            return { mode: 'help', ...EARLY_EXIT_DEFAULTS };
+        }
+        if (a === '--version' || a === '-v') {
+            return { mode: 'version', ...EARLY_EXIT_DEFAULTS };
+        }
+        const handler = FLAG_HANDLERS[a];
+        if (handler) {
+            i = handler(argv, i, state);
+        }
+        else {
+            state.filters.push(a);
+        }
+    }
+    return { mode: 'report', ...state, coverageDir: 'coverage' };
+}

package/dist/report.d.ts

@@ -0,0 +1,22 @@
+import { CrapEntry } from './crap';
+export interface ReportOptions {
+    filters: string[];
+    srcDir: string;
+    coverageDir: string;
+    timeoutMs: number;
+    output: 'text' | 'json' | 'markdown' | 'csv';
+    excludes: string[];
+    runner?: 'vitest' | 'jest';
+    coverageCommand?: string;
+    failOnCrap?: number;
+    failOnComplexity?: number;
+    failOnCoverageBelow?: number;
+    top?: number;
+}
+export declare function detectRunner(): 'vitest' | 'jest';
+export declare function runCoverage(runner: 'vitest' | 'jest', timeoutMs: number): {
+    ok: boolean;
+    timedOut: boolean;
+};
+export declare function evaluateThresholds(entries: CrapEntry[], opts: ReportOptions): string | null;
+export declare function runReport(opts: ReportOptions): Promise<number>;