devkit-quality 0.1.0

package/dist/rules/deadCode.js

@@ -0,0 +1,252 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runDeadCodeRules = runDeadCodeRules;
+const typescript_1 = __importDefault(require("typescript"));
+const node_path_1 = __importDefault(require("node:path"));
+const finding_1 = require("../finding");
+const config_1 = require("../config");
+const discovery_1 = require("../discovery");
+const walk_1 = require("../ast/walk");
+const UNUSED_DIAGNOSTIC_CODES = new Set([6133, 6192, 6196, 6198]);
+function hasDynamicRequireHint(context, relativePath) {
+    for (const hint of context.moduleGraph.dynamicRequireHints) {
+        if (hint === '.' || relativePath === hint || relativePath.startsWith(`${hint}/`))
+            return true;
+    }
+    return false;
+}
+function classifyUnusedDiagnostic(node, code) {
+    if (code === 6192 || typescript_1.default.isImportDeclaration(node) || typescript_1.default.isImportEqualsDeclaration(node)) {
+        return { ruleId: 'DEAD002', title: 'Unused import', fixAvailable: true };
+    }
+    const importAncestor = typescript_1.default.findAncestor(node, (ancestor) => typescript_1.default.isImportSpecifier(ancestor) || typescript_1.default.isNamespaceImport(ancestor) || typescript_1.default.isImportClause(ancestor));
+    if (importAncestor) {
+        return { ruleId: 'DEAD002', title: 'Unused import', fixAvailable: true };
+    }
+    if (code === 6196) {
+        return { ruleId: 'DEAD007', title: 'Unused type', fixAvailable: false };
+    }
+    const parameterAncestor = typescript_1.default.findAncestor(node, typescript_1.default.isParameter);
+    if (parameterAncestor) {
+        return { ruleId: 'DEAD006', title: 'Unused parameter', fixAvailable: false };
+    }
+    const classAncestor = typescript_1.default.findAncestor(node, typescript_1.default.isClassDeclaration);
+    if (classAncestor && classAncestor.name === node) {
+        return { ruleId: 'DEAD005', title: 'Unused class', fixAvailable: false };
+    }
+    const functionAncestor = typescript_1.default.findAncestor(node, typescript_1.default.isFunctionDeclaration);
+    if (functionAncestor && functionAncestor.name === node) {
+        return { ruleId: 'DEAD004', title: 'Unused function', fixAvailable: false };
+    }
+    return { ruleId: 'DEAD003', title: 'Unused variable', fixAvailable: true };
+}
+function detectUnusedViaDiagnostics(context) {
+    const findings = [];
+    for (const file of context.files) {
+        const sourceFile = context.program.getSourceFile(file);
+        if (!sourceFile) {
+            continue;
+        }
+        let diagnostics = [];
+        try {
+            diagnostics = context.program.getSemanticDiagnostics(sourceFile);
+        }
+        catch {
+            continue;
+        }
+        const relativePath = node_path_1.default.relative(context.projectRoot, file).replace(/\\/g, '/');
+        for (const diagnostic of diagnostics) {
+            if (diagnostic.start === undefined || !UNUSED_DIAGNOSTIC_CODES.has(diagnostic.code)) {
+                continue;
+            }
+            const node = (0, walk_1.findNodeAtPosition)(sourceFile, diagnostic.start);
+            const { ruleId, title, fixAvailable } = classifyUnusedDiagnostic(node, diagnostic.code);
+            if (!(0, config_1.isRuleEnabled)(context.config, ruleId)) {
+                continue;
+            }
+            const { line, column } = (0, walk_1.lineAndColumn)(sourceFile, diagnostic.start);
+            const message = typescript_1.default.flattenDiagnosticMessageText(diagnostic.messageText, ' ');
+            findings.push((0, finding_1.buildFinding)({
+                ruleId,
+                category: 'deadCode',
+                severity: ruleId === 'DEAD006' ? 'LOW' : 'MEDIUM',
+                confidence: 'CERTAIN',
+                file: relativePath,
+                line,
+                column,
+                message: title,
+                description: message,
+                evidence: sourceFile.text.slice(node.getStart(), Math.min(node.getEnd(), node.getStart() + 160)),
+                suggestion: fixAvailable
+                    ? 'Remove the unused declaration.'
+                    : 'Remove it if truly unused, or export it if it is part of the public API.',
+                fixAvailable
+            }));
+        }
+    }
+    return findings;
+}
+function detectUnusedExports(context) {
+    if (!(0, config_1.isRuleEnabled)(context.config, 'DEAD009')) {
+        return [];
+    }
+    const findings = [];
+    const { moduleGraph } = context;
+    const usedExportsByFile = new Map();
+    const fullyUsedFiles = new Set();
+    for (const [, imports] of moduleGraph.importsByFile) {
+        for (const importInfo of imports) {
+            if (!importInfo.resolved) {
+                continue;
+            }
+            if (importInfo.hasNamespaceImport) {
+                fullyUsedFiles.add(importInfo.resolved);
+                continue;
+            }
+            if (!usedExportsByFile.has(importInfo.resolved)) {
+                usedExportsByFile.set(importInfo.resolved, new Set());
+            }
+            const used = usedExportsByFile.get(importInfo.resolved);
+            if (importInfo.hasDefaultImport) {
+                used.add('default');
+            }
+            for (const name of importInfo.namedImports) {
+                used.add(name);
+            }
+        }
+    }
+    for (const [, targets] of moduleGraph.reExportAllTargets) {
+        for (const target of targets) {
+            fullyUsedFiles.add(target);
+        }
+    }
+    for (const [file, exports] of moduleGraph.exportsByFile) {
+        if (exports.length === 0)
+            continue;
+        if (moduleGraph.entryPoints.has(file))
+            continue;
+        if ((0, discovery_1.isTestFile)(file))
+            continue;
+        if (fullyUsedFiles.has(file))
+            continue;
+        const used = usedExportsByFile.get(file) ?? new Set();
+        const relativePath = node_path_1.default.relative(context.projectRoot, file).replace(/\\/g, '/');
+        const dynamicHint = hasDynamicRequireHint(context, relativePath);
+        for (const exportInfo of exports) {
+            if (used.has(exportInfo.name)) {
+                continue;
+            }
+            findings.push((0, finding_1.buildFinding)({
+                ruleId: 'DEAD009',
+                category: 'deadCode',
+                severity: 'MEDIUM',
+                confidence: dynamicHint ? 'LOW' : 'MEDIUM',
+                file: relativePath,
+                line: exportInfo.line,
+                column: 1,
+                message: 'Unused export',
+                description: `Export "${exportInfo.name}" is not imported by any other file in the project.${dynamicHint ? ' A nearby dynamic require/import could not be resolved, so verify this manually.' : ''}`,
+                evidence: exportInfo.name,
+                suggestion: 'Remove the export or confirm it is part of a public API consumed outside this repository.',
+                fixAvailable: false
+            }));
+        }
+    }
+    return findings;
+}
+function detectUnusedFiles(context) {
+    if (!(0, config_1.isRuleEnabled)(context.config, 'DEAD010')) {
+        return [];
+    }
+    const findings = [];
+    const { moduleGraph } = context;
+    for (const file of context.files) {
+        if ((0, discovery_1.isTestFile)(file))
+            continue;
+        if (moduleGraph.entryPoints.has(file))
+            continue;
+        const incoming = moduleGraph.reverseEdges.get(file);
+        if (incoming && incoming.size > 0)
+            continue;
+        const relativePath = node_path_1.default.relative(context.projectRoot, file).replace(/\\/g, '/');
+        const dynamicHint = hasDynamicRequireHint(context, relativePath);
+        findings.push((0, finding_1.buildFinding)({
+            ruleId: 'DEAD010',
+            category: 'deadCode',
+            severity: 'MEDIUM',
+            confidence: dynamicHint ? 'LOW' : 'MEDIUM',
+            file: relativePath,
+            line: 1,
+            column: 1,
+            message: 'Unused file',
+            description: `This file is never imported by any other file and is not a configured entry point.${dynamicHint ? ' A nearby dynamic require/import could not be resolved, so verify this manually.' : ''}`,
+            evidence: relativePath,
+            suggestion: 'Delete the file or wire it up as a reachable entry point.',
+            fixAvailable: false
+        }));
+    }
+    return findings;
+}
+function detectUnreachableStatements(context) {
+    if (!(0, config_1.isRuleEnabled)(context.config, 'DEAD011')) {
+        return [];
+    }
+    const findings = [];
+    for (const file of context.files) {
+        const sourceFile = context.program.getSourceFile(file);
+        if (!sourceFile)
+            continue;
+        const relativePath = node_path_1.default.relative(context.projectRoot, file).replace(/\\/g, '/');
+        const checkStatementList = (statements) => {
+            let terminated = false;
+            for (const statement of statements) {
+                if (terminated) {
+                    if (typescript_1.default.isFunctionDeclaration(statement)) {
+                        continue;
+                    }
+                    const { line, column } = (0, walk_1.lineAndColumn)(sourceFile, statement.getStart());
+                    findings.push((0, finding_1.buildFinding)({
+                        ruleId: 'DEAD011',
+                        category: 'deadCode',
+                        severity: 'MEDIUM',
+                        confidence: 'CERTAIN',
+                        file: relativePath,
+                        line,
+                        column,
+                        message: 'Unreachable statement',
+                        description: 'Code following a return, throw, break, or continue statement can never execute.',
+                        evidence: statement.getText().slice(0, 160),
+                        suggestion: 'Remove the unreachable code.',
+                        fixAvailable: true
+                    }));
+                    break;
+                }
+                if (typescript_1.default.isReturnStatement(statement) ||
+                    typescript_1.default.isThrowStatement(statement) ||
+                    typescript_1.default.isBreakStatement(statement) ||
+                    typescript_1.default.isContinueStatement(statement)) {
+                    terminated = true;
+                }
+            }
+        };
+        const visit = (node) => {
+            if ((0, walk_1.isStatementContainer)(node)) {
+                checkStatementList(node.statements);
+            }
+            typescript_1.default.forEachChild(node, visit);
+        };
+        visit(sourceFile);
+    }
+    return findings;
+}
+function runDeadCodeRules(context) {
+    return [
+        ...detectUnusedViaDiagnostics(context),
+        ...detectUnusedExports(context),
+        ...detectUnusedFiles(context),
+        ...detectUnreachableStatements(context)
+    ];
+}

package/dist/rules/dependencies.js

@@ -0,0 +1,137 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runDependencyRules = runDependencyRules;
+const node_module_1 = require("node:module");
+const node_path_1 = __importDefault(require("node:path"));
+const finding_1 = require("../finding");
+const config_1 = require("../config");
+const discovery_1 = require("../discovery");
+const moduleGraph_1 = require("../moduleGraph");
+const BUILTIN_MODULES = new Set([...node_module_1.builtinModules, ...node_module_1.builtinModules.map((name) => `node:${name}`)]);
+function packageNameFromSpecifier(specifier) {
+    if (specifier.startsWith('@')) {
+        const parts = specifier.split('/');
+        return parts.slice(0, 2).join('/');
+    }
+    return specifier.split('/')[0];
+}
+function findDependencyLine(packageJsonText, dependencyName) {
+    const escaped = dependencyName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const pattern = new RegExp(`"${escaped}"\\s*:`);
+    const lines = packageJsonText.split(/\r\n|\r|\n/);
+    for (let i = 0; i < lines.length; i += 1) {
+        if (pattern.test(lines[i])) {
+            return i + 1;
+        }
+    }
+    return 1;
+}
+function getDeclaredDependencyNames(packageJson) {
+    if (!packageJson)
+        return new Set();
+    const fields = ['dependencies', 'devDependencies', 'peerDependencies', 'optionalDependencies'];
+    const names = new Set();
+    for (const field of fields) {
+        const section = packageJson[field];
+        if (section) {
+            for (const name of Object.keys(section)) {
+                names.add(name);
+            }
+        }
+    }
+    return names;
+}
+function runDependencyRules(context) {
+    const findings = [];
+    const { moduleGraph, packageJson, projectRoot } = context;
+    const packageJsonText = (0, discovery_1.readFileSafe)(node_path_1.default.join(projectRoot, 'package.json'));
+    const usedPackageNames = new Set();
+    for (const [, imports] of moduleGraph.importsByFile) {
+        for (const importInfo of imports) {
+            if (!importInfo.isRelative && !importInfo.resolved) {
+                usedPackageNames.add(packageNameFromSpecifier(importInfo.specifier));
+            }
+        }
+    }
+    const scripts = packageJson?.scripts ?? {};
+    const scriptText = Object.values(scripts).join(' ');
+    const declaredDependencies = getDeclaredDependencyNames(packageJson);
+    if ((0, config_1.isRuleEnabled)(context.config, 'DEP001')) {
+        for (const dependencyName of declaredDependencies) {
+            if (usedPackageNames.has(dependencyName))
+                continue;
+            // @types/* packages provide ambient global declarations (process, Buffer, JSX, ...)
+            // that are never referenced through an import specifier, so they are exempt by design.
+            if (dependencyName.startsWith('@types/'))
+                continue;
+            const wordBoundary = new RegExp(`(^|[^A-Za-z0-9_@/.-])${dependencyName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}([^A-Za-z0-9_@/.-]|$)`);
+            if (wordBoundary.test(scriptText))
+                continue;
+            findings.push((0, finding_1.buildFinding)({
+                ruleId: 'DEP001',
+                category: 'dependencies',
+                severity: 'MEDIUM',
+                confidence: 'CERTAIN',
+                file: 'package.json',
+                line: findDependencyLine(packageJsonText, dependencyName),
+                column: 1,
+                message: `Unused dependency: ${dependencyName}`,
+                description: `"${dependencyName}" is declared but not referenced by source files, require/import calls, or package.json scripts.`,
+                evidence: dependencyName,
+                suggestion: 'Remove the unused dependency or confirm it is required by a toolchain entry point.',
+                fixAvailable: true
+            }));
+        }
+    }
+    if ((0, config_1.isRuleEnabled)(context.config, 'DEP002')) {
+        for (const usedName of usedPackageNames) {
+            if (BUILTIN_MODULES.has(usedName))
+                continue;
+            if (declaredDependencies.has(usedName))
+                continue;
+            findings.push((0, finding_1.buildFinding)({
+                ruleId: 'DEP002',
+                category: 'dependencies',
+                severity: 'HIGH',
+                confidence: 'HIGH',
+                file: 'package.json',
+                line: 1,
+                column: 1,
+                message: `Unlisted dependency: ${usedName}`,
+                description: `"${usedName}" is imported from source but is not declared in package.json.`,
+                evidence: usedName,
+                suggestion: 'Add the package to package.json dependencies, or remove the import if it was unintentional.',
+                fixAvailable: false
+            }));
+        }
+    }
+    if ((0, config_1.isRuleEnabled)(context.config, 'DEP003')) {
+        const cycles = (0, moduleGraph_1.findImportCycles)(moduleGraph);
+        const reported = new Set();
+        for (const cycle of cycles) {
+            const relativeCycle = cycle.map((file) => node_path_1.default.relative(projectRoot, file).replace(/\\/g, '/'));
+            const key = [...relativeCycle].sort().join('|');
+            if (reported.has(key))
+                continue;
+            reported.add(key);
+            findings.push((0, finding_1.buildFinding)({
+                ruleId: 'DEP003',
+                category: 'dependencies',
+                severity: 'MEDIUM',
+                confidence: 'HIGH',
+                file: relativeCycle[0],
+                line: 1,
+                column: 1,
+                message: 'Circular import detected',
+                description: 'A cycle exists in the internal module import graph.',
+                evidence: relativeCycle.join(' -> '),
+                suggestion: 'Break the cycle by extracting shared code into a separate module.',
+                fixAvailable: false
+            }));
+        }
+    }
+    return findings;
+}

package/dist/rules/duplication.js

@@ -0,0 +1,138 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeWindow = normalizeWindow;
+exports.runDuplicationRules = runDuplicationRules;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const node_path_1 = __importDefault(require("node:path"));
+const typescript_1 = __importDefault(require("typescript"));
+const finding_1 = require("../finding");
+const config_1 = require("../config");
+const DEFAULT_MIN_TOKENS = 40;
+const WINDOW_STEP = 5;
+function tokenize(sourceFile, languageVariant) {
+    const scanner = typescript_1.default.createScanner(typescript_1.default.ScriptTarget.ES2022, true, languageVariant, sourceFile.text);
+    const tokens = [];
+    let kind = scanner.scan();
+    while (kind !== typescript_1.default.SyntaxKind.EndOfFileToken) {
+        const pos = scanner.getTokenStart();
+        tokens.push({ text: scanner.getTokenText(), line: sourceFile.getLineAndCharacterOfPosition(pos).line + 1, kind });
+        kind = scanner.scan();
+    }
+    return tokens;
+}
+function normalizeWindow(window) {
+    const identifiers = new Map();
+    let nextIdentifier = 0;
+    return window.map((token) => {
+        if (token.kind !== typescript_1.default.SyntaxKind.Identifier && token.kind !== typescript_1.default.SyntaxKind.PrivateIdentifier)
+            return token.text;
+        if (!identifiers.has(token.text))
+            identifiers.set(token.text, `IDENT_${nextIdentifier++}`);
+        return identifiers.get(token.text);
+    }).join('\u0001');
+}
+function severityForSpan(spanTokens, minTokens) {
+    if (spanTokens >= minTokens * 4)
+        return 'HIGH';
+    if (spanTokens >= minTokens * 2)
+        return 'MEDIUM';
+    return 'LOW';
+}
+function mergeRanges(ranges) {
+    const sorted = [...ranges].sort((a, b) => a.startLineA - b.startLineA);
+    const merged = [];
+    for (const range of sorted) {
+        const last = merged[merged.length - 1];
+        if (last && range.startLineA <= last.endLineA + 1 && range.startLineB <= last.endLineB + 1) {
+            last.endLineA = Math.max(last.endLineA, range.endLineA);
+            last.endLineB = Math.max(last.endLineB, range.endLineB);
+        }
+        else {
+            merged.push({ ...range });
+        }
+    }
+    return merged;
+}
+function runDuplicationRules(context) {
+    if (!(0, config_1.isRuleEnabled)(context.config, 'DUP001')) {
+        return [];
+    }
+    const minTokens = (0, config_1.getRuleThreshold)(context.config, 'DUP001', DEFAULT_MIN_TOKENS);
+    const hashBuckets = new Map();
+    const relPath = (file) => node_path_1.default.relative(context.projectRoot, file).replace(/\\/g, '/');
+    for (const file of context.files) {
+        const sourceFile = context.program.getSourceFile(file);
+        if (!sourceFile)
+            continue;
+        const variant = /\.(tsx|jsx)$/i.test(file) ? typescript_1.default.LanguageVariant.JSX : typescript_1.default.LanguageVariant.Standard;
+        const tokens = tokenize(sourceFile, variant);
+        if (tokens.length < minTokens)
+            continue;
+        const relative = relPath(file);
+        for (let i = 0; i + minTokens <= tokens.length; i += WINDOW_STEP) {
+            const window = tokens.slice(i, i + minTokens);
+            const joined = normalizeWindow(window);
+            const hash = node_crypto_1.default.createHash('sha1').update(joined).digest('hex');
+            const entry = {
+                file: relative,
+                startLine: window[0].line,
+                endLine: window[window.length - 1].line,
+                startIndex: i
+            };
+            if (!hashBuckets.has(hash))
+                hashBuckets.set(hash, []);
+            hashBuckets.get(hash).push(entry);
+        }
+    }
+    const pairRanges = new Map();
+    for (const entries of hashBuckets.values()) {
+        if (entries.length < 2)
+            continue;
+        for (let i = 0; i < entries.length; i += 1) {
+            for (let j = i + 1; j < entries.length; j += 1) {
+                const a = entries[i];
+                const b = entries[j];
+                if (a.file === b.file && a.startIndex === b.startIndex)
+                    continue;
+                const key = a.file <= b.file ? `${a.file}::${b.file}` : `${b.file}::${a.file}`;
+                const [first, second] = a.file <= b.file ? [a, b] : [b, a];
+                if (!pairRanges.has(key))
+                    pairRanges.set(key, []);
+                pairRanges.get(key).push({
+                    startLineA: first.startLine,
+                    endLineA: first.endLine,
+                    startLineB: second.startLine,
+                    endLineB: second.endLine
+                });
+            }
+        }
+    }
+    const findings = [];
+    for (const [key, ranges] of pairRanges) {
+        const [fileA, fileB] = key.split('::');
+        const merged = mergeRanges(ranges);
+        for (const range of merged) {
+            const spanLines = range.endLineA - range.startLineA + 1;
+            if (spanLines * WINDOW_STEP < minTokens)
+                continue;
+            findings.push((0, finding_1.buildFinding)({
+                ruleId: 'DUP001',
+                category: 'duplication',
+                severity: severityForSpan(spanLines * WINDOW_STEP, minTokens),
+                confidence: 'MEDIUM',
+                file: fileA,
+                line: range.startLineA,
+                column: 1,
+                message: 'Duplicate code block',
+                description: `Lines ${range.startLineA}-${range.endLineA} closely match ${fileB}:${range.startLineB}-${range.endLineB}.`,
+                evidence: `${fileB}:${range.startLineB}-${range.endLineB}`,
+                suggestion: 'Extract the shared logic into a reusable function or module.',
+                fixAvailable: false
+            }));
+        }
+    }
+    return findings;
+}

package/dist/rules/errorHandling.js

@@ -0,0 +1,120 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runErrorHandlingRules = runErrorHandlingRules;
+const node_path_1 = __importDefault(require("node:path"));
+const typescript_1 = __importDefault(require("typescript"));
+const finding_1 = require("../finding");
+const config_1 = require("../config");
+const walk_1 = require("../ast/walk");
+function isPromiseLike(checker, expression) {
+    let type;
+    try {
+        type = checker.getTypeAtLocation(expression);
+    }
+    catch {
+        return false;
+    }
+    if (type.flags & (typescript_1.default.TypeFlags.Any | typescript_1.default.TypeFlags.Unknown))
+        return false;
+    const thenProperty = checker.getPropertyOfType(type, 'then');
+    if (!thenProperty)
+        return false;
+    const thenType = checker.getTypeOfSymbolAtLocation(thenProperty, expression);
+    return checker.getSignaturesOfType(thenType, typescript_1.default.SignatureKind.Call).length > 0;
+}
+function outerPromiseChain(node) {
+    let current = node;
+    while (current.parent) {
+        if (typescript_1.default.isPropertyAccessExpression(current.parent) && current.parent.expression === current) {
+            current = current.parent;
+            continue;
+        }
+        if (typescript_1.default.isCallExpression(current.parent) && current.parent.expression === current) {
+            current = current.parent;
+            continue;
+        }
+        break;
+    }
+    return typescript_1.default.isCallExpression(current) ? current : node;
+}
+function propertyCallName(call) {
+    return typescript_1.default.isPropertyAccessExpression(call.expression) ? call.expression.name.text : null;
+}
+function promiseChainHasCatch(call) {
+    let current = call;
+    while (typescript_1.default.isCallExpression(current)) {
+        if (propertyCallName(current) === 'catch')
+            return true;
+        if (!typescript_1.default.isPropertyAccessExpression(current.expression))
+            return false;
+        current = current.expression.expression;
+    }
+    return false;
+}
+function runErrorHandlingRules(context) {
+    const findings = [];
+    const checker = context.program.getTypeChecker();
+    for (const file of context.files) {
+        const sourceFile = context.program.getSourceFile(file);
+        if (!sourceFile)
+            continue;
+        const relativePath = node_path_1.default.relative(context.projectRoot, file).replace(/\\/g, '/');
+        const visit = (node) => {
+            if (typescript_1.default.isCatchClause(node)) {
+                const statements = node.block.statements;
+                if ((0, config_1.isRuleEnabled)(context.config, 'ERR001') && statements.length === 0) {
+                    const { line, column } = (0, walk_1.lineAndColumn)(sourceFile, node.getStart());
+                    findings.push((0, finding_1.buildFinding)({
+                        ruleId: 'ERR001', category: 'errorHandling', severity: 'MEDIUM', confidence: 'CERTAIN', file: relativePath, line, column,
+                        message: 'Empty catch block', description: 'An exception is caught and silently discarded.', evidence: node.getText().slice(0, 160),
+                        suggestion: 'Handle the error, log it, or document why it is intentionally ignored.', fixAvailable: false
+                    }));
+                }
+                if ((0, config_1.isRuleEnabled)(context.config, 'ERR002') && statements.length === 1 && typescript_1.default.isThrowStatement(statements[0])) {
+                    const throwStatement = statements[0];
+                    const catchVarName = node.variableDeclaration && typescript_1.default.isIdentifier(node.variableDeclaration.name) ? node.variableDeclaration.name.text : undefined;
+                    const rethrowsSameValue = !throwStatement.expression || (catchVarName && typescript_1.default.isIdentifier(throwStatement.expression) && throwStatement.expression.text === catchVarName);
+                    if (rethrowsSameValue) {
+                        const { line, column } = (0, walk_1.lineAndColumn)(sourceFile, node.getStart());
+                        findings.push((0, finding_1.buildFinding)({
+                            ruleId: 'ERR002', category: 'errorHandling', severity: 'LOW', confidence: 'HIGH', file: relativePath, line, column,
+                            message: 'Catch-and-rethrow without modification', description: 'The catch block only rethrows the original error, adding no value.',
+                            evidence: node.getText().slice(0, 160), suggestion: 'Remove the try/catch, or add meaningful handling (logging, wrapping, recovery).', fixAvailable: false
+                        }));
+                    }
+                }
+            }
+            if ((0, config_1.isRuleEnabled)(context.config, 'ERR003') && typescript_1.default.isExpressionStatement(node) && typescript_1.default.isCallExpression(node.expression)) {
+                const call = node.expression;
+                if (propertyCallName(call) !== 'then' && !promiseChainHasCatch(call) && isPromiseLike(checker, call)) {
+                    const { line, column } = (0, walk_1.lineAndColumn)(sourceFile, node.getStart());
+                    findings.push((0, finding_1.buildFinding)({
+                        ruleId: 'ERR003', category: 'errorHandling', severity: 'MEDIUM', confidence: 'HIGH', file: relativePath, line, column,
+                        message: 'Floating promise', description: 'The result of this Promise-like call is neither awaited nor handled.', evidence: node.getText().slice(0, 160),
+                        suggestion: 'Add await, or explicitly handle rejection with .catch().', fixAvailable: false
+                    }));
+                }
+            }
+            if ((0, config_1.isRuleEnabled)(context.config, 'ERR004') && typescript_1.default.isCallExpression(node) && propertyCallName(node) === 'then') {
+                const chain = outerPromiseChain(node);
+                if (chain === node && propertyCallName(chain) !== 'catch') {
+                    const statement = typescript_1.default.findAncestor(chain, typescript_1.default.isExpressionStatement);
+                    if (statement && statement.expression === chain) {
+                        const { line, column } = (0, walk_1.lineAndColumn)(sourceFile, node.getStart());
+                        findings.push((0, finding_1.buildFinding)({
+                            ruleId: 'ERR004', category: 'errorHandling', severity: 'MEDIUM', confidence: 'MEDIUM', file: relativePath, line, column,
+                            message: 'Promise chain has no rejection handler', description: 'This .then() chain is not followed by .catch(), so a rejected Promise may go unhandled.',
+                            evidence: statement.getText().slice(0, 160), suggestion: 'Add a .catch() handler or use try/catch with await.', fixAvailable: false
+                        }));
+                    }
+                }
+            }
+            typescript_1.default.forEachChild(node, visit);
+        };
+        visit(sourceFile);
+    }
+    return findings;
+}