@eduardbar/drift 1.0.0 → 1.1.0

package/dist/rules/complexity.js

@@ -0,0 +1,51 @@
+import { SyntaxKind } from 'ts-morph';
+import { hasIgnoreComment, getSnippet } from './shared.js';
+const COMPLEXITY_THRESHOLD = 10;
+const INCREMENT_KINDS = [
+    SyntaxKind.IfStatement,
+    SyntaxKind.ForStatement,
+    SyntaxKind.ForInStatement,
+    SyntaxKind.ForOfStatement,
+    SyntaxKind.WhileStatement,
+    SyntaxKind.DoStatement,
+    SyntaxKind.CaseClause,
+    SyntaxKind.CatchClause,
+    SyntaxKind.ConditionalExpression,
+    SyntaxKind.AmpersandAmpersandToken,
+    SyntaxKind.BarBarToken,
+    SyntaxKind.QuestionQuestionToken,
+];
+function getCyclomaticComplexity(fn) {
+    let complexity = 1;
+    for (const kind of INCREMENT_KINDS) {
+        complexity += fn.getDescendantsOfKind(kind).length;
+    }
+    return complexity;
+}
+export function detectHighComplexity(file) {
+    const issues = [];
+    const fns = [
+        ...file.getFunctions(),
+        ...file.getDescendantsOfKind(SyntaxKind.ArrowFunction),
+        ...file.getDescendantsOfKind(SyntaxKind.FunctionExpression),
+        ...file.getClasses().flatMap((c) => c.getMethods()),
+    ];
+    for (const fn of fns) {
+        const complexity = getCyclomaticComplexity(fn);
+        if (complexity > COMPLEXITY_THRESHOLD) {
+            const startLine = fn.getStartLineNumber();
+            if (hasIgnoreComment(file, startLine))
+                continue;
+            issues.push({
+                rule: 'high-complexity',
+                severity: 'error',
+                message: `Cyclomatic complexity is ${complexity} (threshold: ${COMPLEXITY_THRESHOLD}). AI generates correct code, not simple code.`,
+                line: startLine,
+                column: fn.getStartLinePos(),
+                snippet: getSnippet(fn, file),
+            });
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=complexity.js.map

package/dist/rules/coupling.d.ts

@@ -0,0 +1,4 @@
+import { SourceFile } from 'ts-morph';
+import type { DriftIssue } from '../types.js';
+export declare function detectHighCoupling(file: SourceFile): DriftIssue[];
+//# sourceMappingURL=coupling.d.ts.map

package/dist/rules/coupling.js

@@ -0,0 +1,19 @@
+const COUPLING_THRESHOLD = 10;
+export function detectHighCoupling(file) {
+    const imports = file.getImportDeclarations();
+    const sources = new Set(imports.map((i) => i.getModuleSpecifierValue()));
+    if (sources.size > COUPLING_THRESHOLD) {
+        return [
+            {
+                rule: 'high-coupling',
+                severity: 'warning',
+                message: `File imports from ${sources.size} distinct modules (threshold: ${COUPLING_THRESHOLD}). High coupling makes refactoring dangerous.`,
+                line: 1,
+                column: 1,
+                snippet: `// ${sources.size} import sources`,
+            },
+        ];
+    }
+    return [];
+}
+//# sourceMappingURL=coupling.js.map

package/dist/rules/magic.d.ts

@@ -0,0 +1,4 @@
+import { SourceFile } from 'ts-morph';
+import type { DriftIssue } from '../types.js';
+export declare function detectMagicNumbers(file: SourceFile): DriftIssue[];
+//# sourceMappingURL=magic.d.ts.map

package/dist/rules/magic.js

@@ -0,0 +1,33 @@
+import { SyntaxKind } from 'ts-morph';
+import { hasIgnoreComment, getSnippet } from './shared.js';
+const ALLOWED_NUMBERS = new Set([0, 1, -1, 2, 100]);
+export function detectMagicNumbers(file) {
+    const issues = [];
+    for (const node of file.getDescendantsOfKind(SyntaxKind.NumericLiteral)) {
+        const value = Number(node.getLiteralValue());
+        if (ALLOWED_NUMBERS.has(value))
+            continue;
+        const parent = node.getParent();
+        if (!parent)
+            continue;
+        const parentKind = parent.getKind();
+        if (parentKind === SyntaxKind.VariableDeclaration ||
+            parentKind === SyntaxKind.PropertyAssignment ||
+            parentKind === SyntaxKind.EnumMember ||
+            parentKind === SyntaxKind.Parameter)
+            continue;
+        const line = node.getStartLineNumber();
+        if (hasIgnoreComment(file, line))
+            continue;
+        issues.push({
+            rule: 'magic-number',
+            severity: 'info',
+            message: `Magic number ${value} used directly in logic. Extract to a named constant.`,
+            line,
+            column: node.getStartLinePos(),
+            snippet: getSnippet(node, file),
+        });
+    }
+    return issues;
+}
+//# sourceMappingURL=magic.js.map

package/dist/rules/nesting.d.ts

@@ -0,0 +1,5 @@
+import { SourceFile } from 'ts-morph';
+import type { DriftIssue } from '../types.js';
+export declare function detectDeepNesting(file: SourceFile): DriftIssue[];
+export declare function detectTooManyParams(file: SourceFile): DriftIssue[];
+//# sourceMappingURL=nesting.d.ts.map

package/dist/rules/nesting.js

@@ -0,0 +1,82 @@
+import { SyntaxKind } from 'ts-morph';
+import { hasIgnoreComment, getSnippet } from './shared.js';
+const NESTING_THRESHOLD = 3;
+const PARAMS_THRESHOLD = 4;
+const NESTING_KINDS = new Set([
+    SyntaxKind.IfStatement,
+    SyntaxKind.ForStatement,
+    SyntaxKind.ForInStatement,
+    SyntaxKind.ForOfStatement,
+    SyntaxKind.WhileStatement,
+    SyntaxKind.DoStatement,
+    SyntaxKind.TryStatement,
+    SyntaxKind.SwitchStatement,
+]);
+function getMaxNestingDepth(fn) {
+    let maxDepth = 0;
+    function walk(node, depth) {
+        if (NESTING_KINDS.has(node.getKind())) {
+            depth++;
+            if (depth > maxDepth)
+                maxDepth = depth;
+        }
+        for (const child of node.getChildren()) {
+            walk(child, depth);
+        }
+    }
+    walk(fn, 0);
+    return maxDepth;
+}
+export function detectDeepNesting(file) {
+    const issues = [];
+    const fns = [
+        ...file.getFunctions(),
+        ...file.getDescendantsOfKind(SyntaxKind.ArrowFunction),
+        ...file.getDescendantsOfKind(SyntaxKind.FunctionExpression),
+        ...file.getClasses().flatMap((c) => c.getMethods()),
+    ];
+    for (const fn of fns) {
+        const depth = getMaxNestingDepth(fn);
+        if (depth > NESTING_THRESHOLD) {
+            const startLine = fn.getStartLineNumber();
+            if (hasIgnoreComment(file, startLine))
+                continue;
+            issues.push({
+                rule: 'deep-nesting',
+                severity: 'warning',
+                message: `Maximum nesting depth is ${depth} (threshold: ${NESTING_THRESHOLD}). Deep nesting is the #1 readability killer.`,
+                line: startLine,
+                column: fn.getStartLinePos(),
+                snippet: getSnippet(fn, file),
+            });
+        }
+    }
+    return issues;
+}
+export function detectTooManyParams(file) {
+    const issues = [];
+    const fns = [
+        ...file.getFunctions(),
+        ...file.getDescendantsOfKind(SyntaxKind.ArrowFunction),
+        ...file.getDescendantsOfKind(SyntaxKind.FunctionExpression),
+        ...file.getClasses().flatMap((c) => c.getMethods()),
+    ];
+    for (const fn of fns) {
+        const paramCount = fn.getParameters().length;
+        if (paramCount > PARAMS_THRESHOLD) {
+            const startLine = fn.getStartLineNumber();
+            if (hasIgnoreComment(file, startLine))
+                continue;
+            issues.push({
+                rule: 'too-many-params',
+                severity: 'warning',
+                message: `Function has ${paramCount} parameters (threshold: ${PARAMS_THRESHOLD}). AI avoids refactoring into options objects.`,
+                line: startLine,
+                column: fn.getStartLinePos(),
+                snippet: getSnippet(fn, file),
+            });
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=nesting.js.map

package/dist/rules/phase0-basic.js

@@ -1,13 +1,17 @@
 import { SyntaxKind } from 'ts-morph';
 import { hasIgnoreComment, getSnippet, getFunctionLikeLines } from './shared.js';
+const LARGE_FILE_THRESHOLD = 300;
+const LARGE_FUNCTION_THRESHOLD = 50;
+const SNIPPET_TRUNCATE_SHORT = 60;
+const SNIPPET_TRUNCATE_LONG = 120;
 export function detectLargeFile(file) {
     const lineCount = file.getEndLineNumber();
-    if (lineCount > 300) {
+    if (lineCount > LARGE_FILE_THRESHOLD) {
         return [
             {
                 rule: 'large-file',
                 severity: 'error',
-                message: `File has ${lineCount} lines (threshold: 300). Large files are the #1 sign of AI-generated structural drift.`,
+                message: `File has ${lineCount} lines (threshold: ${LARGE_FILE_THRESHOLD}). Large files are the #1 sign of AI-generated structural drift.`,
                 line: 1,
                 column: 1,
                 snippet: `// ${lineCount} lines total`,
@@ -27,13 +31,13 @@ export function detectLargeFunctions(file) {
     for (const fn of fns) {
         const lines = getFunctionLikeLines(fn);
         const startLine = fn.getStartLineNumber();
-        if (lines > 50) {
+        if (lines > LARGE_FUNCTION_THRESHOLD) {
             if (hasIgnoreComment(file, startLine))
                 continue;
             issues.push({
                 rule: 'large-function',
                 severity: 'error',
-                message: `Function spans ${lines} lines (threshold: 50). AI tends to dump logic into single functions.`,
+                message: `Function spans ${lines} lines (threshold: ${LARGE_FUNCTION_THRESHOLD}). AI tends to dump logic into single functions.`,
                 line: startLine,
                 column: fn.getStartLinePos(),
                 snippet: getSnippet(fn, file),
@@ -68,10 +72,10 @@ export function detectDebugLeftovers(file) {
             issues.push({
                 rule: 'debug-leftover',
                 severity: 'warning',
-                message: `Unresolved marker found: ${lineContent.trim().slice(0, 60)}`,
+                message: `Unresolved marker found: ${lineContent.trim().slice(0, SNIPPET_TRUNCATE_SHORT)}`,
                 line: i + 1,
                 column: 1,
-                snippet: lineContent.trim().slice(0, 120),
+                snippet: lineContent.trim().slice(0, SNIPPET_TRUNCATE_LONG),
             });
         }
     });
@@ -145,11 +149,14 @@ export function detectCatchSwallow(file) {
         const block = catchClause.getBlock();
         const stmts = block.getStatements();
         if (stmts.length === 0) {
+            const line = catchClause.getStartLineNumber();
+            if (hasIgnoreComment(file, line))
+                continue;
             issues.push({
                 rule: 'catch-swallow',
                 severity: 'warning',
                 message: `Empty catch block silently swallows errors. Classic AI pattern to make code "not throw".`,
-                line: catchClause.getStartLineNumber(),
+                line,
                 column: catchClause.getStartLinePos(),
                 snippet: getSnippet(catchClause, file),
             });

package/dist/rules/phase1-complexity.d.ts

@@ -1,31 +1,7 @@
-import { SourceFile } from 'ts-morph';
-import type { DriftIssue } from '../types.js';
-export declare function detectHighComplexity(file: SourceFile): DriftIssue[];
-export declare function detectDeepNesting(file: SourceFile): DriftIssue[];
-/**
- * Too many parameters: functions with more than 4 parameters.
- * AI avoids refactoring parameters into objects/options bags.
- */
-export declare function detectTooManyParams(file: SourceFile): DriftIssue[];
-/**
- * High coupling: files with more than 10 distinct import sources.
- * AI imports broadly without considering module cohesion.
- */
-export declare function detectHighCoupling(file: SourceFile): DriftIssue[];
-/**
- * Promise style mix: async/await and .then()/.catch() used in the same file.
- * AI generates both styles without consistency.
- */
-export declare function detectPromiseStyleMix(file: SourceFile): DriftIssue[];
-/**
- * Magic numbers: numeric literals used directly in logic outside of named constants.
- * Excludes 0, 1, -1 (universally understood) and array indices in obvious patterns.
- */
-export declare function detectMagicNumbers(file: SourceFile): DriftIssue[];
-/**
- * Comment contradiction: comments that restate exactly what the code does.
- * Classic AI pattern — documents the obvious instead of the why.
- * Detects: "// increment counter" above counter++, "// return x" above return x, etc.
- */
-export declare function detectCommentContradiction(file: SourceFile): DriftIssue[];
+export { detectHighComplexity } from './complexity.js';
+export { detectDeepNesting, detectTooManyParams } from './nesting.js';
+export { detectHighCoupling } from './coupling.js';
+export { detectPromiseStyleMix } from './promise.js';
+export { detectMagicNumbers } from './magic.js';
+export { detectCommentContradiction } from './comments.js';
 //# sourceMappingURL=phase1-complexity.d.ts.map

package/dist/rules/phase1-complexity.js

@@ -1,277 +1,8 @@
-import { SyntaxKind } from 'ts-morph';
-import { hasIgnoreComment, getSnippet } from './shared.js';
-/**
- * Cyclomatic complexity: count decision points in a function.
- * Each if/else if/ternary/?:/for/while/do/case/catch/&&/|| adds 1.
- * Threshold: > 10 is considered high complexity.
- */
-function getCyclomaticComplexity(fn) {
-    let complexity = 1; // base path
-    const incrementKinds = [
-        SyntaxKind.IfStatement,
-        SyntaxKind.ForStatement,
-        SyntaxKind.ForInStatement,
-        SyntaxKind.ForOfStatement,
-        SyntaxKind.WhileStatement,
-        SyntaxKind.DoStatement,
-        SyntaxKind.CaseClause,
-        SyntaxKind.CatchClause,
-        SyntaxKind.ConditionalExpression, // ternary
-        SyntaxKind.AmpersandAmpersandToken,
-        SyntaxKind.BarBarToken,
-        SyntaxKind.QuestionQuestionToken, // ??
-    ];
-    for (const kind of incrementKinds) {
-        complexity += fn.getDescendantsOfKind(kind).length;
-    }
-    return complexity;
-}
-export function detectHighComplexity(file) {
-    const issues = [];
-    const fns = [
-        ...file.getFunctions(),
-        ...file.getDescendantsOfKind(SyntaxKind.ArrowFunction),
-        ...file.getDescendantsOfKind(SyntaxKind.FunctionExpression),
-        ...file.getClasses().flatMap((c) => c.getMethods()),
-    ];
-    for (const fn of fns) {
-        const complexity = getCyclomaticComplexity(fn);
-        if (complexity > 10) {
-            const startLine = fn.getStartLineNumber();
-            if (hasIgnoreComment(file, startLine))
-                continue;
-            issues.push({
-                rule: 'high-complexity',
-                severity: 'error',
-                message: `Cyclomatic complexity is ${complexity} (threshold: 10). AI generates correct code, not simple code.`,
-                line: startLine,
-                column: fn.getStartLinePos(),
-                snippet: getSnippet(fn, file),
-            });
-        }
-    }
-    return issues;
-}
-/**
- * Deep nesting: count the maximum nesting depth of control flow inside a function.
- * Counts: if, for, while, do, try, switch.
- * Threshold: > 3 levels.
- */
-function getMaxNestingDepth(fn) {
-    const nestingKinds = new Set([
-        SyntaxKind.IfStatement,
-        SyntaxKind.ForStatement,
-        SyntaxKind.ForInStatement,
-        SyntaxKind.ForOfStatement,
-        SyntaxKind.WhileStatement,
-        SyntaxKind.DoStatement,
-        SyntaxKind.TryStatement,
-        SyntaxKind.SwitchStatement,
-    ]);
-    let maxDepth = 0;
-    function walk(node, depth) {
-        if (nestingKinds.has(node.getKind())) {
-            depth++;
-            if (depth > maxDepth)
-                maxDepth = depth;
-        }
-        for (const child of node.getChildren()) {
-            walk(child, depth);
-        }
-    }
-    walk(fn, 0);
-    return maxDepth;
-}
-export function detectDeepNesting(file) {
-    const issues = [];
-    const fns = [
-        ...file.getFunctions(),
-        ...file.getDescendantsOfKind(SyntaxKind.ArrowFunction),
-        ...file.getDescendantsOfKind(SyntaxKind.FunctionExpression),
-        ...file.getClasses().flatMap((c) => c.getMethods()),
-    ];
-    for (const fn of fns) {
-        const depth = getMaxNestingDepth(fn);
-        if (depth > 3) {
-            const startLine = fn.getStartLineNumber();
-            if (hasIgnoreComment(file, startLine))
-                continue;
-            issues.push({
-                rule: 'deep-nesting',
-                severity: 'warning',
-                message: `Maximum nesting depth is ${depth} (threshold: 3). Deep nesting is the #1 readability killer.`,
-                line: startLine,
-                column: fn.getStartLinePos(),
-                snippet: getSnippet(fn, file),
-            });
-        }
-    }
-    return issues;
-}
-/**
- * Too many parameters: functions with more than 4 parameters.
- * AI avoids refactoring parameters into objects/options bags.
- */
-export function detectTooManyParams(file) {
-    const issues = [];
-    const fns = [
-        ...file.getFunctions(),
-        ...file.getDescendantsOfKind(SyntaxKind.ArrowFunction),
-        ...file.getDescendantsOfKind(SyntaxKind.FunctionExpression),
-        ...file.getClasses().flatMap((c) => c.getMethods()),
-    ];
-    for (const fn of fns) {
-        const paramCount = fn.getParameters().length;
-        if (paramCount > 4) {
-            const startLine = fn.getStartLineNumber();
-            if (hasIgnoreComment(file, startLine))
-                continue;
-            issues.push({
-                rule: 'too-many-params',
-                severity: 'warning',
-                message: `Function has ${paramCount} parameters (threshold: 4). AI avoids refactoring into options objects.`,
-                line: startLine,
-                column: fn.getStartLinePos(),
-                snippet: getSnippet(fn, file),
-            });
-        }
-    }
-    return issues;
-}
-/**
- * High coupling: files with more than 10 distinct import sources.
- * AI imports broadly without considering module cohesion.
- */
-export function detectHighCoupling(file) {
-    const imports = file.getImportDeclarations();
-    const sources = new Set(imports.map((i) => i.getModuleSpecifierValue()));
-    if (sources.size > 10) {
-        return [
-            {
-                rule: 'high-coupling',
-                severity: 'warning',
-                message: `File imports from ${sources.size} distinct modules (threshold: 10). High coupling makes refactoring dangerous.`,
-                line: 1,
-                column: 1,
-                snippet: `// ${sources.size} import sources`,
-            },
-        ];
-    }
-    return [];
-}
-/**
- * Promise style mix: async/await and .then()/.catch() used in the same file.
- * AI generates both styles without consistency.
- */
-export function detectPromiseStyleMix(file) {
-    const text = file.getFullText();
-    // detect .then( or .catch( calls (property access on a promise)
-    const hasThen = file.getDescendantsOfKind(SyntaxKind.PropertyAccessExpression).some((node) => {
-        const name = node.getName();
-        return name === 'then' || name === 'catch';
-    });
-    // detect async keyword usage
-    const hasAsync = file.getDescendantsOfKind(SyntaxKind.AsyncKeyword).length > 0 ||
-        /\bawait\b/.test(text);
-    if (hasThen && hasAsync) {
-        return [
-            {
-                rule: 'promise-style-mix',
-                severity: 'warning',
-                message: `File mixes async/await with .then()/.catch(). AI generates both styles without picking one.`,
-                line: 1,
-                column: 1,
-                snippet: `// mixed promise styles detected`,
-            },
-        ];
-    }
-    return [];
-}
-/**
- * Magic numbers: numeric literals used directly in logic outside of named constants.
- * Excludes 0, 1, -1 (universally understood) and array indices in obvious patterns.
- */
-export function detectMagicNumbers(file) {
-    const issues = [];
-    const ALLOWED = new Set([0, 1, -1, 2, 100]);
-    for (const node of file.getDescendantsOfKind(SyntaxKind.NumericLiteral)) {
-        const value = Number(node.getLiteralValue());
-        if (ALLOWED.has(value))
-            continue;
-        // Skip: variable/const initializers at top level (those ARE the named constants)
-        const parent = node.getParent();
-        if (!parent)
-            continue;
-        const parentKind = parent.getKind();
-        if (parentKind === SyntaxKind.VariableDeclaration ||
-            parentKind === SyntaxKind.PropertyAssignment ||
-            parentKind === SyntaxKind.EnumMember ||
-            parentKind === SyntaxKind.Parameter)
-            continue;
-        const line = node.getStartLineNumber();
-        if (hasIgnoreComment(file, line))
-            continue;
-        issues.push({
-            rule: 'magic-number',
-            severity: 'info',
-            message: `Magic number ${value} used directly in logic. Extract to a named constant.`,
-            line,
-            column: node.getStartLinePos(),
-            snippet: getSnippet(node, file),
-        });
-    }
-    return issues;
-}
-/**
- * Comment contradiction: comments that restate exactly what the code does.
- * Classic AI pattern — documents the obvious instead of the why.
- * Detects: "// increment counter" above counter++, "// return x" above return x, etc.
- */
-export function detectCommentContradiction(file) {
-    const issues = [];
-    const lines = file.getFullText().split('\n');
-    // Patterns: comment that is a near-literal restatement of the next line
-    const trivialCommentPatterns = [
-        // "// return ..." above a return statement
-        { comment: /\/\/\s*return\b/i, code: /^\s*return\b/ },
-        // "// increment ..." or "// increase ..." above x++ or x += 1
-        { comment: /\/\/\s*(increment|increase|add\s+1|plus\s+1)\b/i, code: /\+\+|(\+= ?1)\b/ },
-        // "// decrement ..." above x-- or x -= 1
-        { comment: /\/\/\s*(decrement|decrease|subtract\s+1|minus\s+1)\b/i, code: /--|(-= ?1)\b/ },
-        // "// log ..." above console.log
-        { comment: /\/\/\s*log\b/i, code: /console\.(log|warn|error)/ },
-        // "// set ... to ..." or "// assign ..." above assignment
-        { comment: /\/\/\s*(set|assign)\b/i, code: /^\s*\w[\w.[\]]*\s*=(?!=)/ },
-        // "// call ..." above a function call
-        { comment: /\/\/\s*call\b/i, code: /^\s*\w[\w.]*\(/ },
-        // "// declare ..." or "// define ..." or "// create ..." above const/let/var
-        { comment: /\/\/\s*(declare|define|create|initialize)\b/i, code: /^\s*(const|let|var)\b/ },
-        // "// check if ..." above an if statement
-        { comment: /\/\/\s*check\s+if\b/i, code: /^\s*if\s*\(/ },
-        // "// loop ..." or "// iterate ..." above for/while
-        { comment: /\/\/\s*(loop|iterate|for each|foreach)\b/i, code: /^\s*(for|while)\b/ },
-        // "// import ..." above an import
-        { comment: /\/\/\s*import\b/i, code: /^\s*import\b/ },
-    ];
-    for (let i = 0; i < lines.length - 1; i++) {
-        const commentLine = lines[i].trim();
-        const nextLine = lines[i + 1];
-        for (const { comment, code } of trivialCommentPatterns) {
-            if (comment.test(commentLine) && code.test(nextLine)) {
-                if (hasIgnoreComment(file, i + 1))
-                    continue;
-                issues.push({
-                    rule: 'comment-contradiction',
-                    severity: 'warning',
-                    message: `Comment restates what the code already says. AI documents the obvious instead of the why.`,
-                    line: i + 1,
-                    column: 1,
-                    snippet: `${commentLine.slice(0, 60)}\n${nextLine.trim().slice(0, 60)}`,
-                });
-                break; // one issue per comment line max
-            }
-        }
-    }
-    return issues;
-}
+// drift-ignore-file
+export { detectHighComplexity } from './complexity.js';
+export { detectDeepNesting, detectTooManyParams } from './nesting.js';
+export { detectHighCoupling } from './coupling.js';
+export { detectPromiseStyleMix } from './promise.js';
+export { detectMagicNumbers } from './magic.js';
+export { detectCommentContradiction } from './comments.js';
 //# sourceMappingURL=phase1-complexity.js.map

package/dist/rules/phase2-crossfile.d.ts

@@ -8,10 +8,6 @@ export declare function detectDeadFiles(sourceFiles: SourceFile[], allImportedPa
     severity: DriftIssue['severity'];
     weight: number;
 }>): Map<string, DriftIssue>;
-/**
- * Detect named exports that are never imported by any other file.
- * Barrel files (index.*) are excluded since their entire surface is the public API.
- */
 export declare function detectUnusedExports(sourceFiles: SourceFile[], allImportedNames: Map<string, Set<string>>, ruleWeights: Record<string, {
     severity: DriftIssue['severity'];
     weight: number;