@eduardbar/drift 1.2.0 → 1.4.0

package/dist/plugins.d.ts

@@ -1,6 +1,7 @@
-import type { PluginLoadError, LoadedPlugin } from './types.js';
+import type { LoadedPlugin, PluginLoadError, PluginLoadWarning } from './types.js';
 export declare function loadPlugins(projectRoot: string, pluginIds: string[] | undefined): {
     plugins: LoadedPlugin[];
     errors: PluginLoadError[];
+    warnings: PluginLoadWarning[];
 };
 //# sourceMappingURL=plugins.d.ts.map

package/dist/plugins.js

@@ -1,30 +1,82 @@
 import { existsSync } from 'node:fs';
 import { isAbsolute, resolve } from 'node:path';
 import { createRequire } from 'node:module';
+import { normalizeRules } from './plugins-rules.js';
+import { validateCapabilities } from './plugins-capabilities.js';
+import { pushError, pushWarning } from './plugins-messages.js';
 const require = createRequire(import.meta.url);
-function isPluginShape(value) {
-    if (!value || typeof value !== 'object')
-        return false;
-    const candidate = value;
-    if (typeof candidate.name !== 'string')
-        return false;
-    if (!Array.isArray(candidate.rules))
-        return false;
-    return candidate.rules.every((rule) => rule &&
-        typeof rule === 'object' &&
-        typeof rule.name === 'string' &&
-        typeof rule.detect === 'function');
-}
+const SUPPORTED_PLUGIN_API_VERSION = 1;
 function normalizePluginExport(mod) {
-    if (isPluginShape(mod))
-        return mod;
     if (mod && typeof mod === 'object' && 'default' in mod) {
-        const maybeDefault = mod.default;
-        if (isPluginShape(maybeDefault))
-            return maybeDefault;
+        return mod.default ?? mod;
+    }
+    return mod;
+}
+function ensureObjectCandidate(pluginId, candidate, errors) {
+    if (candidate && typeof candidate === 'object') {
+        return candidate;
     }
+    pushError(errors, pluginId, `Invalid plugin contract in '${pluginId}'. Expected an object export with shape { name, rules[] }`, { code: 'plugin-shape-invalid' });
     return undefined;
 }
+function ensurePluginName(pluginId, plugin, errors) {
+    const pluginName = typeof plugin.name === 'string' ? plugin.name.trim() : '';
+    if (pluginName)
+        return pluginName;
+    pushError(errors, pluginId, `Invalid plugin contract in '${pluginId}'. Expected 'name' as a non-empty string.`, { code: 'plugin-name-missing' });
+    return undefined;
+}
+function validateApiVersion(plugin, context) {
+    const { pluginId, pluginName, errors, warnings } = context;
+    const hasExplicitApiVersion = plugin.apiVersion !== undefined;
+    const isLegacyPlugin = !hasExplicitApiVersion;
+    if (isLegacyPlugin) {
+        pushWarning(warnings, pluginId, `Plugin '${pluginName}' does not declare 'apiVersion'. Assuming ${SUPPORTED_PLUGIN_API_VERSION} for backward compatibility; please add apiVersion: ${SUPPORTED_PLUGIN_API_VERSION}.`, { pluginName, code: 'plugin-api-version-implicit' });
+        return { hasExplicitApiVersion, isLegacyPlugin, isSupported: true };
+    }
+    if (typeof plugin.apiVersion !== 'number' || !Number.isInteger(plugin.apiVersion) || plugin.apiVersion <= 0) {
+        pushError(errors, pluginId, `Plugin '${pluginName}' has invalid apiVersion '${String(plugin.apiVersion)}'. Expected a positive integer (for example: ${SUPPORTED_PLUGIN_API_VERSION}).`, { pluginName, code: 'plugin-api-version-invalid' });
+        return { hasExplicitApiVersion, isLegacyPlugin, isSupported: false };
+    }
+    if (plugin.apiVersion !== SUPPORTED_PLUGIN_API_VERSION) {
+        pushError(errors, pluginId, `Plugin '${pluginName}' targets apiVersion ${plugin.apiVersion}, but this drift build supports apiVersion ${SUPPORTED_PLUGIN_API_VERSION}.`, { pluginName, code: 'plugin-api-version-unsupported' });
+        return { hasExplicitApiVersion, isLegacyPlugin, isSupported: false };
+    }
+    return { hasExplicitApiVersion, isLegacyPlugin, isSupported: true };
+}
+function validatePluginContractData(pluginId, candidate) {
+    const errors = [];
+    const warnings = [];
+    const plugin = ensureObjectCandidate(pluginId, candidate, errors);
+    if (!plugin)
+        return { errors, warnings };
+    const pluginName = ensurePluginName(pluginId, plugin, errors);
+    if (!pluginName)
+        return { errors, warnings };
+    const context = { pluginId, pluginName, errors, warnings };
+    const apiVersion = validateApiVersion(plugin, context);
+    if (!apiVersion.isSupported)
+        return { errors, warnings };
+    const capabilities = validateCapabilities(plugin.capabilities, context);
+    if (errors.length > 0)
+        return { errors, warnings };
+    const normalizedRules = normalizeRules(plugin.rules, apiVersion.isLegacyPlugin, context);
+    if (!normalizedRules)
+        return { errors, warnings };
+    return {
+        plugin: {
+            name: pluginName,
+            apiVersion: apiVersion.hasExplicitApiVersion ? plugin.apiVersion : SUPPORTED_PLUGIN_API_VERSION,
+            capabilities,
+            rules: normalizedRules,
+        },
+        errors,
+        warnings,
+    };
+}
+function validatePluginContract(pluginId, candidate) {
+    return validatePluginContractData(pluginId, candidate);
+}
 function resolvePluginSpecifier(projectRoot, pluginId) {
     if (pluginId.startsWith('.') || pluginId.startsWith('/')) {
         const abs = isAbsolute(pluginId) ? pluginId : resolve(projectRoot, pluginId);
@@ -44,31 +96,31 @@ function resolvePluginSpecifier(projectRoot, pluginId) {
 }
 export function loadPlugins(projectRoot, pluginIds) {
     if (!pluginIds || pluginIds.length === 0) {
-        return { plugins: [], errors: [] };
+        return { plugins: [], errors: [], warnings: [] };
     }
     const loaded = [];
     const errors = [];
+    const warnings = [];
     for (const pluginId of pluginIds) {
         const resolved = resolvePluginSpecifier(projectRoot, pluginId);
         try {
             const mod = require(resolved);
-            const plugin = normalizePluginExport(mod);
-            if (!plugin) {
-                errors.push({
-                    pluginId,
-                    message: `Invalid plugin contract in '${pluginId}'. Expected: { name, rules[] }`,
-                });
+            const normalized = normalizePluginExport(mod);
+            const validation = validatePluginContract(pluginId, normalized);
+            errors.push(...validation.errors);
+            warnings.push(...validation.warnings);
+            if (!validation.plugin)
                 continue;
-            }
-            loaded.push({ id: pluginId, plugin });
+            loaded.push({ id: pluginId, plugin: validation.plugin });
         }
         catch (error) {
             errors.push({
                 pluginId,
+                code: 'plugin-load-failed',
                 message: error instanceof Error ? error.message : String(error),
             });
         }
     }
-    return { plugins: loaded, errors };
+    return { plugins: loaded, errors, warnings };
 }
 //# sourceMappingURL=plugins.js.map

package/dist/printer.js

@@ -131,6 +131,10 @@ function formatFixSuggestion(issue) {
             'Fix or remove the failing plugin in drift.config.*',
             'Validate plugin contract: export { name, rules[] } and detector functions',
         ],
+        'plugin-warning': [
+            'Review plugin validation warnings and align with the recommended contract',
+            'Use explicit rule ids and valid severity/weight values',
+        ],
     };
     return suggestions[issue.rule] ?? ['Review and fix manually'];
 }

package/dist/reporter-constants.d.ts

@@ -0,0 +1,16 @@
+import type { DriftIssue } from './types.js';
+export declare const FIX_SUGGESTIONS: Record<string, string>;
+export declare const RULE_EFFORT: Record<string, 'low' | 'medium' | 'high'>;
+export declare const SEVERITY_ORDER: Record<string, number>;
+export declare const EFFORT_ORDER: Record<string, number>;
+export declare const AI_SIGNAL_RULES: Set<string>;
+export declare const AI_CODE_SMELL_BOOST = 20;
+export declare const AI_TRIGGER_LIMIT = 4;
+export declare const AI_LIKELIHOOD_THRESHOLD = 35;
+export declare const AI_SMELL_SCORE_MULTIPLIER = 15;
+export declare const AI_SUSPECTED_LIMIT = 10;
+export type DriftIssueWithFile = {
+    file: string;
+    issue: DriftIssue;
+};
+//# sourceMappingURL=reporter-constants.d.ts.map

package/dist/reporter-constants.js

@@ -0,0 +1,39 @@
+export const FIX_SUGGESTIONS = {
+    'large-file': 'Consider splitting this file into smaller modules with single responsibility',
+    'large-function': 'Extract logic into smaller functions with descriptive names',
+    'debug-leftover': 'Remove this console.log or replace with proper logging library',
+    'dead-code': 'Remove unused import to keep code clean',
+    'duplicate-function-name': 'Consolidate with existing function or rename to clarify different behavior',
+    'any-abuse': "Replace 'any' with proper type definition",
+    'catch-swallow': 'Add error handling or logging in catch block',
+    'no-return-type': 'Add explicit return type for better type safety',
+};
+export const RULE_EFFORT = {
+    'debug-leftover': 'low',
+    'dead-code': 'low',
+    'no-return-type': 'low',
+    'any-abuse': 'medium',
+    'catch-swallow': 'medium',
+    'large-file': 'high',
+    'large-function': 'high',
+    'duplicate-function-name': 'high',
+};
+export const SEVERITY_ORDER = { error: 0, warning: 1, info: 2 };
+export const EFFORT_ORDER = { low: 0, medium: 1, high: 2 };
+export const AI_SIGNAL_RULES = new Set([
+    'over-commented',
+    'hardcoded-config',
+    'inconsistent-error-handling',
+    'unnecessary-abstraction',
+    'naming-inconsistency',
+    'comment-contradiction',
+    'promise-style-mix',
+    'any-abuse',
+    'ai-code-smell',
+]);
+export const AI_CODE_SMELL_BOOST = 20;
+export const AI_TRIGGER_LIMIT = 4;
+export const AI_LIKELIHOOD_THRESHOLD = 35;
+export const AI_SMELL_SCORE_MULTIPLIER = 15;
+export const AI_SUSPECTED_LIMIT = 10;
+//# sourceMappingURL=reporter-constants.js.map

package/dist/reporter.d.ts

@@ -1,5 +1,5 @@
-import type { FileReport, DriftReport, AIOutput } from './types.js';
-export declare function buildReport(targetPath: string, files: FileReport[]): DriftReport;
+import type { FileReport, DriftReport, AIOutputJson, DriftReportJson } from './types.js';
+export declare function buildReport(targetPath: string, files: FileReport[]): DriftReportJson;
 export declare function formatMarkdown(report: DriftReport): string;
-export declare function formatAIOutput(report: DriftReport): AIOutput;
+export declare function formatAIOutput(report: DriftReport): AIOutputJson;
 //# sourceMappingURL=reporter.d.ts.map

package/dist/reporter.js

@@ -1,61 +1,34 @@
 import { scoreToGradeText, severityIcon } from './utils.js';
 import { computeRepoQuality, computeMaintenanceRisk } from './metrics.js';
-const FIX_SUGGESTIONS = {
-    'large-file': 'Consider splitting this file into smaller modules with single responsibility',
-    'large-function': 'Extract logic into smaller functions with descriptive names',
-    'debug-leftover': 'Remove this console.log or replace with proper logging library',
-    'dead-code': 'Remove unused import to keep code clean',
-    'duplicate-function-name': 'Consolidate with existing function or rename to clarify different behavior',
-    'any-abuse': "Replace 'any' with proper type definition",
-    'catch-swallow': 'Add error handling or logging in catch block',
-    'no-return-type': 'Add explicit return type for better type safety',
-};
-const RULE_EFFORT = {
-    'debug-leftover': 'low',
-    'dead-code': 'low',
-    'no-return-type': 'low',
-    'any-abuse': 'medium',
-    'catch-swallow': 'medium',
-    'large-file': 'high',
-    'large-function': 'high',
-    'duplicate-function-name': 'high',
-};
-const SEVERITY_ORDER = { error: 0, warning: 1, info: 2 };
-const EFFORT_ORDER = { low: 0, medium: 1, high: 2 };
-const AI_SIGNAL_RULES = new Set([
-    'over-commented',
-    'hardcoded-config',
-    'inconsistent-error-handling',
-    'unnecessary-abstraction',
-    'naming-inconsistency',
-    'comment-contradiction',
-    'promise-style-mix',
-    'any-abuse',
-    'ai-code-smell',
-]);
-export function buildReport(targetPath, files) {
-    const allIssues = files.flatMap((f) => f.issues);
+import { OUTPUT_SCHEMA, withOutputMetadata } from './output-metadata.js';
+import { AI_CODE_SMELL_BOOST, AI_LIKELIHOOD_THRESHOLD, AI_SIGNAL_RULES, AI_SMELL_SCORE_MULTIPLIER, AI_SUSPECTED_LIMIT, AI_TRIGGER_LIMIT, EFFORT_ORDER, FIX_SUGGESTIONS, RULE_EFFORT, SEVERITY_ORDER, } from './reporter-constants.js';
+function summarizeIssues(allIssues) {
     const byRule = {};
     for (const issue of allIssues) {
         byRule[issue.rule] = (byRule[issue.rule] ?? 0) + 1;
     }
-    const totalScore = files.length > 0
-        ? Math.round(files.reduce((sum, f) => sum + f.score, 0) / files.length)
-        : 0;
-    const sortedFiles = files.filter((f) => f.issues.length > 0).sort((a, b) => b.score - a.score);
-    const baseReport = {
+    return {
+        errors: allIssues.filter((issue) => issue.severity === 'error').length,
+        warnings: allIssues.filter((issue) => issue.severity === 'warning').length,
+        infos: allIssues.filter((issue) => issue.severity === 'info').length,
+        byRule,
+    };
+}
+function calculateTotalScore(files) {
+    if (files.length === 0)
+        return 0;
+    return Math.round(files.reduce((sum, file) => sum + file.score, 0) / files.length);
+}
+function baseReportDefaults(summary, targetPath, files) {
+    const filesWithIssues = files.filter((file) => file.issues.length > 0).sort((a, b) => b.score - a.score);
+    const report = {
         scannedAt: new Date().toISOString(),
         targetPath,
-        files: sortedFiles,
-        totalIssues: allIssues.length,
-        totalScore,
+        files: filesWithIssues,
+        totalIssues: files.flatMap((file) => file.issues).length,
+        totalScore: calculateTotalScore(files),
         totalFiles: files.length,
-        summary: {
-            errors: allIssues.filter((i) => i.severity === 'error').length,
-            warnings: allIssues.filter((i) => i.severity === 'warning').length,
-            infos: allIssues.filter((i) => i.severity === 'info').length,
-            byRule,
-        },
+        summary,
         quality: {
             overall: 100,
             dimensions: {
@@ -76,6 +49,12 @@ export function buildReport(targetPath, files) {
             },
         },
     };
+    return withOutputMetadata(report, OUTPUT_SCHEMA.report);
+}
+export function buildReport(targetPath, files) {
+    const allIssues = files.flatMap((f) => f.issues);
+    const summary = summarizeIssues(allIssues);
+    const baseReport = baseReportDefaults(summary, targetPath, files);
     baseReport.quality = computeRepoQuality(targetPath, files);
     baseReport.maintenanceRisk = computeMaintenanceRisk(baseReport);
     return baseReport;
@@ -191,12 +170,12 @@ function fileAILikelihood(fileIssues) {
         triggerCounts.set(issue.rule, (triggerCounts.get(issue.rule) ?? 0) + 1);
     }
     const triggerTotal = [...triggerCounts.values()].reduce((sum, count) => sum + count, 0);
-    const smellBoost = fileIssues.some((issue) => issue.rule === 'ai-code-smell') ? 20 : 0;
+    const smellBoost = fileIssues.some((issue) => issue.rule === 'ai-code-smell') ? AI_CODE_SMELL_BOOST : 0;
     const ratioScore = Math.round((triggerTotal / Math.max(fileIssues.length, 1)) * 100);
     const score = Math.max(0, Math.min(100, ratioScore + smellBoost));
     const triggers = [...triggerCounts.entries()]
         .sort((a, b) => b[1] - a[1])
-        .slice(0, 4)
+        .slice(0, AI_TRIGGER_LIMIT)
         .map(([rule]) => rule);
     return { score, triggers };
 }
@@ -210,16 +189,16 @@ function computeAILikelihood(report) {
             triggers: likelihood.triggers,
         };
     })
-        .filter((entry) => entry.ai_likelihood >= 35)
+        .filter((entry) => entry.ai_likelihood >= AI_LIKELIHOOD_THRESHOLD)
         .sort((a, b) => b.ai_likelihood - a.ai_likelihood);
     const overall = suspected.length === 0
         ? 0
         : Math.round(suspected.reduce((sum, entry) => sum + entry.ai_likelihood, 0) / suspected.length);
     const smellCount = report.files.flatMap((file) => file.issues).filter((issue) => issue.rule === 'ai-code-smell').length;
-    const smellScore = Math.min(100, smellCount * 15);
+    const smellScore = Math.min(100, smellCount * AI_SMELL_SCORE_MULTIPLIER);
     return {
         overall,
-        files: suspected.slice(0, 10),
+        files: suspected.slice(0, AI_SUSPECTED_LIMIT),
         smellScore,
     };
 }
@@ -230,7 +209,7 @@ export function formatAIOutput(report) {
     const rulesDetected = [...new Set(allIssues.map((i) => i.issue.rule))];
     const grade = scoreToGradeText(report.totalScore);
     const aiLikelihood = computeAILikelihood(report);
-    return {
+    const output = {
         summary: {
             score: report.totalScore,
             grade: grade.label.toUpperCase(),
@@ -251,5 +230,6 @@ export function formatAIOutput(report) {
             recommended_action: buildRecommendedAction(priorityOrder),
         },
     };
+    return withOutputMetadata(output, OUTPUT_SCHEMA.ai);
 }
 //# sourceMappingURL=reporter.js.map

package/dist/review.d.ts

@@ -1,5 +1,5 @@
 import type { DriftDiff } from './types.js';
-export interface DriftReview {
+interface DriftReview {
     baseRef: string;
     scannedAt: string;
     totalDelta: number;
@@ -12,4 +12,5 @@ export interface DriftReview {
 }
 export declare function formatReviewMarkdown(review: DriftReview): string;
 export declare function generateReview(projectPath: string, baseRef: string): Promise<DriftReview>;
+export {};
 //# sourceMappingURL=review.d.ts.map

package/dist/review.js

@@ -1,13 +1,14 @@
-import { resolve } from 'node:path';
+import { relative, resolve } from 'node:path';
 import { analyzeProject } from './analyzer.js';
 import { loadConfig } from './config.js';
 import { buildReport } from './reporter.js';
 import { cleanupTempDir, extractFilesAtRef } from './git.js';
 import { computeDiff } from './diff.js';
+const REVIEW_TOP_FILES_LIMIT = 8;
 export function formatReviewMarkdown(review) {
     const trendIcon = review.status === 'regressed' ? '⚠️' : review.status === 'improved' ? '✅' : 'ℹ️';
     const topFiles = review.diff.files
-        .slice(0, 8)
+        .slice(0, REVIEW_TOP_FILES_LIMIT)
         .map((file) => {
         const sign = file.scoreDelta > 0 ? '+' : '';
         return `- \`${file.path}\`: ${file.scoreBefore} -> ${file.scoreAfter} (${sign}${file.scoreDelta}), +${file.newIssues.length} new / -${file.resolvedIssues.length} resolved`;
@@ -48,7 +49,7 @@ export async function generateReview(projectPath, baseRef) {
             ...baseReport,
             files: baseReport.files.map((file) => ({
                 ...file,
-                path: file.path.replace(tempDir, resolvedPath),
+                path: resolve(resolvedPath, relative(tempDir, file.path)),
             })),
         };
         const diff = computeDiff(remappedBase, currentReport, baseRef);

package/dist/rules/comments.js

@@ -1,4 +1,4 @@
-import { hasIgnoreComment } from './shared.js';
+import { hasIgnoreComment, getFileLines } from './shared.js';
 const TRIVIAL_COMMENT_PATTERNS = [
     { comment: /\/\/\s*return\b/i, code: /^\s*return\b/ },
     { comment: /\/\/\s*(increment|increase|add\s+1|plus\s+1)\b/i, code: /\+\+|(\+= ?1)\b/ },
@@ -31,7 +31,7 @@ function checkLineForContradiction(commentLine, nextLine, lineNumber, file) {
 }
 export function detectCommentContradiction(file) {
     const issues = [];
-    const lines = file.getFullText().split('\n');
+    const lines = getFileLines(file);
     for (let i = 0; i < lines.length - 1; i++) {
         const commentLine = lines[i].trim();
         const nextLine = lines[i + 1];

package/dist/rules/complexity.js

@@ -1,5 +1,5 @@
 import { SyntaxKind } from 'ts-morph';
-import { hasIgnoreComment, getSnippet } from './shared.js';
+import { hasIgnoreComment, getSnippet, collectFunctionLikes } from './shared.js';
 const COMPLEXITY_THRESHOLD = 10;
 const INCREMENT_KINDS = [
     SyntaxKind.IfStatement,
@@ -24,12 +24,7 @@ function getCyclomaticComplexity(fn) {
 }
 export function detectHighComplexity(file) {
     const issues = [];
-    const fns = [
-        ...file.getFunctions(),
-        ...file.getDescendantsOfKind(SyntaxKind.ArrowFunction),
-        ...file.getDescendantsOfKind(SyntaxKind.FunctionExpression),
-        ...file.getClasses().flatMap((c) => c.getMethods()),
-    ];
+    const fns = collectFunctionLikes(file);
     for (const fn of fns) {
         const complexity = getCyclomaticComplexity(fn);
         if (complexity > COMPLEXITY_THRESHOLD) {

package/dist/rules/nesting.js

@@ -1,5 +1,5 @@
 import { SyntaxKind } from 'ts-morph';
-import { hasIgnoreComment, getSnippet } from './shared.js';
+import { hasIgnoreComment, getSnippet, collectFunctionLikes } from './shared.js';
 const NESTING_THRESHOLD = 3;
 const PARAMS_THRESHOLD = 4;
 const NESTING_KINDS = new Set([
@@ -29,12 +29,7 @@ function getMaxNestingDepth(fn) {
 }
 export function detectDeepNesting(file) {
     const issues = [];
-    const fns = [
-        ...file.getFunctions(),
-        ...file.getDescendantsOfKind(SyntaxKind.ArrowFunction),
-        ...file.getDescendantsOfKind(SyntaxKind.FunctionExpression),
-        ...file.getClasses().flatMap((c) => c.getMethods()),
-    ];
+    const fns = collectFunctionLikes(file);
     for (const fn of fns) {
         const depth = getMaxNestingDepth(fn);
         if (depth > NESTING_THRESHOLD) {
@@ -55,12 +50,7 @@ export function detectDeepNesting(file) {
 }
 export function detectTooManyParams(file) {
     const issues = [];
-    const fns = [
-        ...file.getFunctions(),
-        ...file.getDescendantsOfKind(SyntaxKind.ArrowFunction),
-        ...file.getDescendantsOfKind(SyntaxKind.FunctionExpression),
-        ...file.getClasses().flatMap((c) => c.getMethods()),
-    ];
+    const fns = collectFunctionLikes(file);
     for (const fn of fns) {
         const paramCount = fn.getParameters().length;
         if (paramCount > PARAMS_THRESHOLD) {

package/dist/rules/phase0-basic.js

@@ -1,5 +1,5 @@
 import { SyntaxKind } from 'ts-morph';
-import { hasIgnoreComment, getSnippet, getFunctionLikeLines } from './shared.js';
+import { hasIgnoreComment, getSnippet, getFunctionLikeLines, collectFunctionLikes, getFileLines } from './shared.js';
 const LARGE_FILE_THRESHOLD = 300;
 const LARGE_FUNCTION_THRESHOLD = 50;
 const SNIPPET_TRUNCATE_SHORT = 60;
@@ -22,12 +22,7 @@ export function detectLargeFile(file) {
 }
 export function detectLargeFunctions(file) {
     const issues = [];
-    const fns = [
-        ...file.getFunctions(),
-        ...file.getDescendantsOfKind(SyntaxKind.ArrowFunction),
-        ...file.getDescendantsOfKind(SyntaxKind.FunctionExpression),
-        ...file.getClasses().flatMap((c) => c.getMethods()),
-    ];
+    const fns = collectFunctionLikes(file);
     for (const fn of fns) {
         const lines = getFunctionLikeLines(fn);
         const startLine = fn.getStartLineNumber();
@@ -64,7 +59,7 @@ export function detectDebugLeftovers(file) {
             });
         }
     }
-    const lines = file.getFullText().split('\n');
+    const lines = getFileLines(file);
     lines.forEach((lineContent, i) => {
         if (/\/\/\s*(TODO|FIXME|HACK|XXX|TEMP)\b/i.test(lineContent)) {
             if (hasIgnoreComment(file, i + 1))
@@ -83,11 +78,16 @@ export function detectDebugLeftovers(file) {
 }
 export function detectDeadCode(file) {
     const issues = [];
+    const identifierCounts = new Map();
+    for (const id of file.getDescendantsOfKind(SyntaxKind.Identifier)) {
+        const text = id.getText();
+        identifierCounts.set(text, (identifierCounts.get(text) ?? 0) + 1);
+    }
     for (const imp of file.getImportDeclarations()) {
         for (const named of imp.getNamedImports()) {
             const name = named.getName();
-            const refs = file.getDescendantsOfKind(SyntaxKind.Identifier).filter((id) => id.getText() === name && id !== named.getNameNode());
-            if (refs.length === 0) {
+            const refsCount = Math.max(0, (identifierCounts.get(name) ?? 0) - 1);
+            if (refsCount === 0) {
                 issues.push({
                     rule: 'dead-code',
                     severity: 'warning',

package/dist/rules/phase3-configurable.js

@@ -19,11 +19,13 @@ const HTTP_IMPORT_PATTERNS = [
 ];
 function isControllerFile(filePath) {
     const normalized = filePath.replace(/\\/g, '/').toLowerCase();
-    return normalized.includes('/controller/') || normalized.includes('/controllers/') || normalized.endsWith('controller.ts') || normalized.endsWith('controller.js');
+    const segments = normalized.split('/');
+    return segments.includes('controller') || segments.includes('controllers') || normalized.endsWith('controller.ts') || normalized.endsWith('controller.js');
 }
 function isServiceFile(filePath) {
     const normalized = filePath.replace(/\\/g, '/').toLowerCase();
-    return normalized.includes('/service/') || normalized.includes('/services/') || normalized.endsWith('service.ts') || normalized.endsWith('service.js');
+    const segments = normalized.split('/');
+    return segments.includes('service') || segments.includes('services') || normalized.endsWith('service.ts') || normalized.endsWith('service.js');
 }
 function createIssue(rule, message, line, snippet) {
     return {
@@ -74,24 +76,30 @@ export function detectMaxFunctionLines(file, config) {
     if (!maxLines || maxLines <= 0)
         return [];
     const issues = [];
+    collectFunctionLineIssues(file, maxLines, issues);
+    collectMethodLineIssues(file, maxLines, issues);
+    return issues;
+}
+function countBodyLines(body) {
+    if (!body)
+        return 0;
+    return body.getEndLineNumber() - body.getStartLineNumber() - 1;
+}
+function collectFunctionLineIssues(file, maxLines, issues) {
     for (const fn of file.getFunctions()) {
-        const body = fn.getBody();
-        if (!body)
+        const lines = countBodyLines(fn.getBody());
+        if (lines <= maxLines)
             continue;
-        const lines = body.getEndLineNumber() - body.getStartLineNumber() - 1;
-        if (lines > maxLines) {
-            issues.push(createIssue('max-function-lines', `Function '${fn.getName() ?? '(anonymous)'}' has ${lines} lines (max: ${maxLines}).`, fn.getStartLineNumber(), fn.getName() ?? '(anonymous)'));
-        }
+        const functionName = fn.getName() ?? '(anonymous)';
+        issues.push(createIssue('max-function-lines', `Function '${functionName}' has ${lines} lines (max: ${maxLines}).`, fn.getStartLineNumber(), functionName));
     }
+}
+function collectMethodLineIssues(file, maxLines, issues) {
     for (const method of file.getDescendantsOfKind(SyntaxKind.MethodDeclaration)) {
-        const body = method.getBody();
-        if (!body)
+        const lines = countBodyLines(method.getBody());
+        if (lines <= maxLines)
             continue;
-        const lines = body.getEndLineNumber() - body.getStartLineNumber() - 1;
-        if (lines > maxLines) {
-            issues.push(createIssue('max-function-lines', `Method '${method.getName()}' has ${lines} lines (max: ${maxLines}).`, method.getStartLineNumber(), method.getName()));
-        }
+        issues.push(createIssue('max-function-lines', `Method '${method.getName()}' has ${lines} lines (max: ${maxLines}).`, method.getStartLineNumber(), method.getName()));
     }
-    return issues;
 }
 //# sourceMappingURL=phase3-configurable.js.map

package/dist/rules/shared.d.ts

@@ -1,5 +1,7 @@
 import { SourceFile, Node, FunctionDeclaration, ArrowFunction, FunctionExpression, MethodDeclaration } from 'ts-morph';
 export type FunctionLike = FunctionDeclaration | ArrowFunction | FunctionExpression | MethodDeclaration;
+export declare function getFileLines(file: SourceFile): string[];
+export declare function collectFunctionLikes(file: SourceFile): FunctionLike[];
 export declare function hasIgnoreComment(file: SourceFile, line: number): boolean;
 export declare function isFileIgnored(file: SourceFile): boolean;
 export declare function getSnippet(node: Node, file: SourceFile): string;

package/dist/rules/shared.js

@@ -1,5 +1,29 @@
-export function hasIgnoreComment(file, line) {
+import { SyntaxKind, } from 'ts-morph';
+const fileLinesCache = new WeakMap();
+const functionLikesCache = new WeakMap();
+export function getFileLines(file) {
+    const cached = fileLinesCache.get(file);
+    if (cached)
+        return cached;
     const lines = file.getFullText().split('\n');
+    fileLinesCache.set(file, lines);
+    return lines;
+}
+export function collectFunctionLikes(file) {
+    const cached = functionLikesCache.get(file);
+    if (cached)
+        return cached;
+    const fns = [
+        ...file.getFunctions(),
+        ...file.getDescendantsOfKind(SyntaxKind.ArrowFunction),
+        ...file.getDescendantsOfKind(SyntaxKind.FunctionExpression),
+        ...file.getClasses().flatMap((c) => c.getMethods()),
+    ];
+    functionLikesCache.set(file, fns);
+    return fns;
+}
+export function hasIgnoreComment(file, line) {
+    const lines = getFileLines(file);
     const currentLine = lines[line - 1] ?? '';
     const prevLine = lines[line - 2] ?? '';
     if (/\/\/\s*drift-ignore\b/.test(currentLine))
@@ -9,12 +33,12 @@ export function hasIgnoreComment(file, line) {
     return false;
 }
 export function isFileIgnored(file) {
-    const firstLines = file.getFullText().split('\n').slice(0, 10).join('\n'); // drift-ignore
+    const firstLines = getFileLines(file).slice(0, 10).join('\n'); // drift-ignore
     return /\/\/\s*drift-ignore-file\b/.test(firstLines);
 }
 export function getSnippet(node, file) {
     const startLine = node.getStartLineNumber();
-    const lines = file.getFullText().split('\n');
+    const lines = getFileLines(file);
     return lines
         .slice(Math.max(0, startLine - 1), startLine + 1)
         .join('\n')