@eduardbar/drift 1.1.0 → 1.3.0

package/dist/analyzer.js

@@ -1,5 +1,6 @@
 // drift-ignore-file
 import * as path from 'node:path';
+import { readdirSync, statSync } from 'node:fs';
 import { Project } from 'ts-morph';
 // Rules
 import { isFileIgnored } from './rules/shared.js';
@@ -61,6 +62,9 @@ export const RULE_WEIGHTS = {
     // Phase 8: semantic duplication
     'semantic-duplication': { severity: 'warning', weight: 12 },
     'plugin-error': { severity: 'warning', weight: 4 },
+    'plugin-warning': { severity: 'info', weight: 0 },
+    'analysis-skip-max-files': { severity: 'info', weight: 0 },
+    'analysis-skip-file-size': { severity: 'info', weight: 0 },
 };
 const AI_SMELL_SIGNALS = new Set([
     'over-commented',
@@ -107,12 +111,41 @@ function runPluginRules(file, loadedPlugins, config, projectRoot) {
     for (const loaded of loadedPlugins) {
         for (const rule of loaded.plugin.rules) {
             try {
-                const detected = rule.detect(file, context) ?? [];
-                for (const issue of detected) {
+                const detected = rule.detect(file, context);
+                if (detected == null)
+                    continue;
+                if (!Array.isArray(detected)) {
+                    throw new Error(`detect() must return DriftIssue[], got ${typeof detected}`);
+                }
+                for (const [issueIndex, issue] of detected.entries()) {
+                    if (!issue || typeof issue !== 'object') {
+                        issues.push({
+                            rule: 'plugin-error',
+                            severity: 'warning',
+                            message: `Plugin '${loaded.plugin.name}' rule '${rule.name}' returned a non-object issue at index ${issueIndex}`,
+                            line: 1,
+                            column: 1,
+                            snippet: file.getBaseName(),
+                        });
+                        continue;
+                    }
+                    const line = typeof issue.line === 'number' ? issue.line : 1;
+                    const column = typeof issue.column === 'number' ? issue.column : 1;
+                    const message = typeof issue.message === 'string'
+                        ? issue.message
+                        : `Invalid plugin issue at index ${issueIndex}: missing string 'message'`;
+                    const snippet = typeof issue.snippet === 'string' ? issue.snippet : file.getBaseName();
+                    const severity = issue.severity === 'error' || issue.severity === 'warning' || issue.severity === 'info'
+                        ? issue.severity
+                        : (rule.severity ?? 'warning');
                     issues.push({
                         ...issue,
                         rule: issue.rule || `${loaded.plugin.name}/${rule.name}`,
-                        severity: issue.severity ?? (rule.severity ?? 'warning'),
+                        severity,
+                        line,
+                        column,
+                        message,
+                        snippet,
                     });
                 }
             }
@@ -130,6 +163,218 @@ function runPluginRules(file, loadedPlugins, config, projectRoot) {
     }
     return issues;
 }
+function normalizeDiagnosticFilePart(value) {
+    return value.replace(/[^a-zA-Z0-9._-]+/g, '_');
+}
+function pluginDiagnosticHint(code) {
+    switch (code) {
+        case 'plugin-api-version-implicit':
+            return 'Add apiVersion: 1 to make plugin compatibility explicit.';
+        case 'plugin-api-version-invalid':
+            return 'Use a positive integer apiVersion (for example: 1).';
+        case 'plugin-api-version-unsupported':
+            return 'Upgrade/downgrade the plugin to the currently supported API version.';
+        case 'plugin-rule-id-invalid':
+            return 'Rename the rule id to lowercase/kebab-case format.';
+        case 'plugin-rule-id-duplicate':
+            return 'Ensure each rule id is unique within the plugin.';
+        case 'plugin-capabilities-invalid':
+        case 'plugin-capabilities-value-invalid':
+            return 'Set capabilities as an object map with primitive values only.';
+        default:
+            return 'Review plugin contract docs and adjust exported metadata and rule shape.';
+    }
+}
+function pluginDiagnosticToIssue(targetPath, diagnostic, kind) {
+    const prefix = kind === 'error' ? 'Failed to load plugin' : 'Plugin validation warning';
+    const ruleLabel = diagnostic.ruleId ? ` rule '${diagnostic.ruleId}'` : '';
+    const codeLabel = diagnostic.code ? ` [${diagnostic.code}]` : '';
+    const hint = pluginDiagnosticHint(diagnostic.code);
+    const pluginLabel = diagnostic.pluginName
+        ? `'${diagnostic.pluginId}' (${diagnostic.pluginName})`
+        : `'${diagnostic.pluginId}'`;
+    const issue = {
+        rule: kind === 'error' ? 'plugin-error' : 'plugin-warning',
+        severity: kind === 'error' ? 'warning' : 'info',
+        message: `${prefix}${codeLabel} ${pluginLabel}${ruleLabel}: ${diagnostic.message} Next: ${hint}`,
+        line: 1,
+        column: 1,
+        snippet: diagnostic.pluginId,
+    };
+    const safePluginId = normalizeDiagnosticFilePart(diagnostic.pluginId);
+    const safeRuleId = diagnostic.ruleId ? `.${normalizeDiagnosticFilePart(diagnostic.ruleId)}` : '';
+    const kindDir = kind === 'error' ? '.drift-plugin-errors' : '.drift-plugin-warnings';
+    return {
+        path: path.join(targetPath, kindDir, `${safePluginId}${safeRuleId}.plugin`),
+        issues: [issue],
+        score: calculateScore([issue], RULE_WEIGHTS),
+    };
+}
+const ANALYZABLE_EXTENSIONS = new Set(['.ts', '.tsx', '.js', '.jsx']);
+const EXCLUDED_DIR_NAMES = new Set(['node_modules', 'dist', '.next', 'build']);
+function shouldAnalyzeFile(fileName) {
+    if (fileName.endsWith('.d.ts'))
+        return false;
+    if (/\.test\.[^.]+$/.test(fileName))
+        return false;
+    if (/\.spec\.[^.]+$/.test(fileName))
+        return false;
+    return ANALYZABLE_EXTENSIONS.has(path.extname(fileName));
+}
+function collectAnalyzableSources(targetPath) {
+    const sourcePaths = [];
+    const queue = [targetPath];
+    while (queue.length > 0) {
+        const currentDir = queue.pop();
+        if (!currentDir)
+            continue;
+        let entries;
+        try {
+            entries = readdirSync(currentDir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            const entryPath = path.join(currentDir, entry.name);
+            if (entry.isDirectory()) {
+                if (EXCLUDED_DIR_NAMES.has(entry.name))
+                    continue;
+                queue.push(entryPath);
+                continue;
+            }
+            if (!entry.isFile())
+                continue;
+            if (!shouldAnalyzeFile(entry.name))
+                continue;
+            let sizeBytes = 0;
+            try {
+                sizeBytes = statSync(entryPath).size;
+            }
+            catch {
+                sizeBytes = 0;
+            }
+            sourcePaths.push({ path: entryPath, sizeBytes });
+        }
+    }
+    sourcePaths.sort((a, b) => a.path.localeCompare(b.path));
+    return sourcePaths;
+}
+function resolveAnalysisOptions(config, options) {
+    const performance = config?.performance;
+    const lowMemory = options?.lowMemory ?? performance?.lowMemory ?? false;
+    const chunkSize = Math.max(1, options?.chunkSize ?? performance?.chunkSize ?? (lowMemory ? 40 : 200));
+    const includeSemanticDuplication = options?.includeSemanticDuplication
+        ?? performance?.includeSemanticDuplication
+        ?? !lowMemory;
+    return {
+        lowMemory,
+        chunkSize,
+        maxFiles: options?.maxFiles ?? performance?.maxFiles,
+        maxFileSizeKb: options?.maxFileSizeKb ?? performance?.maxFileSizeKb,
+        includeSemanticDuplication,
+    };
+}
+function chunkPaths(paths, chunkSize) {
+    if (paths.length === 0)
+        return [];
+    const chunks = [];
+    for (let i = 0; i < paths.length; i += chunkSize) {
+        chunks.push(paths.slice(i, i + chunkSize));
+    }
+    return chunks;
+}
+function toPathKey(filePath) {
+    let normalized = path.normalize(filePath);
+    if (process.platform === 'win32' && /^\\[A-Za-z]:\\/.test(normalized)) {
+        normalized = normalized.slice(1);
+    }
+    return process.platform === 'win32' ? normalized.toLowerCase() : normalized;
+}
+function createAnalysisSkipReport(filePath, rule, message) {
+    const issue = {
+        rule,
+        severity: RULE_WEIGHTS[rule].severity,
+        message,
+        line: 1,
+        column: 1,
+        snippet: path.basename(filePath),
+    };
+    return {
+        path: filePath,
+        issues: [issue],
+        score: calculateScore([issue], RULE_WEIGHTS),
+    };
+}
+function selectSourcesForAnalysis(sources, options) {
+    let selected = sources;
+    const skippedReports = [];
+    if (typeof options.maxFiles === 'number' && options.maxFiles >= 0 && selected.length > options.maxFiles) {
+        const allowed = selected.slice(0, options.maxFiles);
+        const skipped = selected.slice(options.maxFiles);
+        selected = allowed;
+        for (const source of skipped) {
+            skippedReports.push(createAnalysisSkipReport(source.path, 'analysis-skip-max-files', `Skipped by maxFiles guardrail (${options.maxFiles})`));
+        }
+    }
+    if (typeof options.maxFileSizeKb === 'number' && options.maxFileSizeKb > 0) {
+        const maxBytes = options.maxFileSizeKb * 1024;
+        const keep = [];
+        for (const source of selected) {
+            if (source.sizeBytes > maxBytes) {
+                const fileSizeKb = Math.ceil(source.sizeBytes / 1024);
+                skippedReports.push(createAnalysisSkipReport(source.path, 'analysis-skip-file-size', `Skipped by maxFileSizeKb guardrail (${fileSizeKb}KB > ${options.maxFileSizeKb}KB)`));
+            }
+            else {
+                keep.push(source);
+            }
+        }
+        selected = keep;
+    }
+    return {
+        selectedPaths: selected.map((source) => source.path),
+        skippedReports,
+    };
+}
+function resolveImportTargetPath(importerPath, moduleSpecifier, sourcePathMap) {
+    if (!moduleSpecifier.startsWith('.') && !path.isAbsolute(moduleSpecifier)) {
+        return undefined;
+    }
+    const normalizedSpecifier = moduleSpecifier.replace(/\\/g, '/');
+    const basePath = path.resolve(path.dirname(importerPath), normalizedSpecifier);
+    const ext = path.extname(basePath);
+    const candidates = new Set();
+    const addCandidate = (candidate) => {
+        candidates.add(path.normalize(candidate));
+    };
+    if (ext.length > 0) {
+        addCandidate(basePath);
+        if (ext === '.js' || ext === '.jsx' || ext === '.ts' || ext === '.tsx') {
+            const withoutExt = basePath.slice(0, -ext.length);
+            addCandidate(`${withoutExt}.ts`);
+            addCandidate(`${withoutExt}.tsx`);
+            addCandidate(`${withoutExt}.js`);
+            addCandidate(`${withoutExt}.jsx`);
+        }
+    }
+    else {
+        addCandidate(basePath);
+        addCandidate(`${basePath}.ts`);
+        addCandidate(`${basePath}.tsx`);
+        addCandidate(`${basePath}.js`);
+        addCandidate(`${basePath}.jsx`);
+        addCandidate(path.join(basePath, 'index.ts'));
+        addCandidate(path.join(basePath, 'index.tsx'));
+        addCandidate(path.join(basePath, 'index.js'));
+        addCandidate(path.join(basePath, 'index.jsx'));
+    }
+    for (const candidate of candidates) {
+        const resolved = sourcePathMap.get(toPathKey(candidate));
+        if (resolved)
+            return resolved;
+    }
+    return undefined;
+}
 // ---------------------------------------------------------------------------
 // Per-file analysis
 // ---------------------------------------------------------------------------
@@ -184,128 +429,161 @@ export function analyzeFile(file, options) {
 // ---------------------------------------------------------------------------
 // Project-level analysis (phases 2, 3, 8 require the full file set)
 // ---------------------------------------------------------------------------
-export function analyzeProject(targetPath, config) {
-    const project = new Project({
-        skipAddingFilesFromTsConfig: true,
-        compilerOptions: { allowJs: true, jsx: 1 }, // 1 = JsxEmit.Preserve
-    });
-    project.addSourceFilesAtPaths([
-        `${targetPath}/**/*.ts`,
-        `${targetPath}/**/*.tsx`,
-        `${targetPath}/**/*.js`,
-        `${targetPath}/**/*.jsx`,
-        `!${targetPath}/**/node_modules/**`,
-        `!${targetPath}/**/dist/**`,
-        `!${targetPath}/**/.next/**`,
-        `!${targetPath}/**/build/**`,
-        `!${targetPath}/**/*.d.ts`,
-        `!${targetPath}/**/*.test.*`,
-        `!${targetPath}/**/*.spec.*`,
-    ]);
-    const sourceFiles = project.getSourceFiles();
+export function analyzeProject(targetPath, config, options) {
+    const analysisOptions = resolveAnalysisOptions(config, options);
+    const discoveredSources = collectAnalyzableSources(targetPath);
+    const { selectedPaths: sourcePaths, skippedReports } = selectSourcesForAnalysis(discoveredSources, analysisOptions);
+    const sourcePathMap = new Map(sourcePaths.map((filePath) => [toPathKey(filePath), filePath]));
     const pluginRuntime = loadPlugins(targetPath, config?.plugins);
-    // Phase 1: per-file analysis
-    const reports = sourceFiles.map((file) => analyzeFile(file, {
-        config,
-        loadedPlugins: pluginRuntime.plugins,
-        projectRoot: targetPath,
-    }));
+    const reports = [...skippedReports];
     const reportByPath = new Map();
-    for (const r of reports)
-        reportByPath.set(r.path, r);
-    // Build set of ignored paths so cross-file phases don't re-add issues
-    const ignoredPaths = new Set(sourceFiles.filter(sf => isFileIgnored(sf)).map(sf => sf.getFilePath()));
-    // ── Phase 2 setup: build import graph ──────────────────────────────────────
-    const allImportedPaths = new Set();
-    const allImportedNames = new Map();
+    const ignoredPaths = new Set();
+    const allImportedPathKeys = new Set();
+    const allImportedNamesByKey = new Map();
     const allLiteralImports = new Set();
     const importGraph = new Map();
-    for (const sf of sourceFiles) {
-        const sfPath = sf.getFilePath();
-        for (const decl of sf.getImportDeclarations()) {
+    const fingerprintMap = new Map();
+    const getReport = (filePath) => {
+        const fileKey = toPathKey(filePath);
+        if (ignoredPaths.has(fileKey))
+            return undefined;
+        return reportByPath.get(fileKey);
+    };
+    const addImportedName = (resolvedPath, name) => {
+        const resolvedKey = toPathKey(resolvedPath);
+        if (!allImportedNamesByKey.has(resolvedKey)) {
+            allImportedNamesByKey.set(resolvedKey, new Set());
+        }
+        allImportedNamesByKey.get(resolvedKey).add(name);
+    };
+    const collectCrossFileMetadata = (sourceFile) => {
+        const sourceFilePath = sourceFile.getFilePath();
+        const sourceFileKey = toPathKey(sourceFilePath);
+        const sourceFilePathCanonical = sourcePathMap.get(sourceFileKey) ?? sourceFilePath;
+        for (const decl of sourceFile.getImportDeclarations()) {
             const moduleSpecifier = decl.getModuleSpecifierValue();
             allLiteralImports.add(moduleSpecifier);
-            const resolved = decl.getModuleSpecifierSourceFile();
-            if (resolved) {
-                const resolvedPath = resolved.getFilePath();
-                allImportedPaths.add(resolvedPath);
-                if (!importGraph.has(sfPath))
-                    importGraph.set(sfPath, new Set());
-                importGraph.get(sfPath).add(resolvedPath);
-                const named = decl.getNamedImports().map(n => n.getName());
-                const def = decl.getDefaultImport()?.getText();
-                const ns = decl.getNamespaceImport()?.getText();
-                if (!allImportedNames.has(resolvedPath)) {
-                    allImportedNames.set(resolvedPath, new Set());
-                }
-                const nameSet = allImportedNames.get(resolvedPath);
-                for (const n of named)
-                    nameSet.add(n);
-                if (def)
-                    nameSet.add('default');
-                if (ns)
-                    nameSet.add('*');
+            const resolvedPath = analysisOptions.lowMemory
+                ? resolveImportTargetPath(sourceFilePath, moduleSpecifier, sourcePathMap)
+                : decl.getModuleSpecifierSourceFile()?.getFilePath();
+            if (!resolvedPath)
+                continue;
+            const resolvedPathKey = toPathKey(resolvedPath);
+            const resolvedPathCanonical = sourcePathMap.get(resolvedPathKey) ?? resolvedPath;
+            allImportedPathKeys.add(resolvedPathKey);
+            if (!importGraph.has(sourceFilePathCanonical))
+                importGraph.set(sourceFilePathCanonical, new Set());
+            importGraph.get(sourceFilePathCanonical).add(resolvedPathCanonical);
+            for (const named of decl.getNamedImports().map((namedImport) => namedImport.getName())) {
+                addImportedName(resolvedPathCanonical, named);
             }
+            if (decl.getDefaultImport())
+                addImportedName(resolvedPathCanonical, 'default');
+            if (decl.getNamespaceImport())
+                addImportedName(resolvedPathCanonical, '*');
         }
-        for (const exportDecl of sf.getExportDeclarations()) {
-            const reExportedModule = exportDecl.getModuleSpecifierSourceFile();
-            if (!reExportedModule)
+        for (const exportDecl of sourceFile.getExportDeclarations()) {
+            const moduleSpecifier = exportDecl.getModuleSpecifierValue();
+            if (!moduleSpecifier)
                 continue;
-            const reExportedPath = reExportedModule.getFilePath();
-            allImportedPaths.add(reExportedPath);
-            if (!allImportedNames.has(reExportedPath)) {
-                allImportedNames.set(reExportedPath, new Set());
-            }
-            const nameSet = allImportedNames.get(reExportedPath);
+            const reExportedPath = analysisOptions.lowMemory
+                ? resolveImportTargetPath(sourceFilePath, moduleSpecifier, sourcePathMap)
+                : exportDecl.getModuleSpecifierSourceFile()?.getFilePath();
+            if (!reExportedPath)
+                continue;
+            const reExportedPathKey = toPathKey(reExportedPath);
+            const reExportedPathCanonical = sourcePathMap.get(reExportedPathKey) ?? reExportedPath;
+            allImportedPathKeys.add(reExportedPathKey);
             const namedExports = exportDecl.getNamedExports();
             if (namedExports.length === 0) {
-                nameSet.add('*');
+                addImportedName(reExportedPathCanonical, '*');
             }
             else {
-                for (const ne of namedExports)
-                    nameSet.add(ne.getName());
+                for (const namedExport of namedExports) {
+                    addImportedName(reExportedPathCanonical, namedExport.getName());
+                }
             }
         }
+        if (!analysisOptions.includeSemanticDuplication || ignoredPaths.has(sourceFileKey)) {
+            return;
+        }
+        for (const { fn, name, line, col } of collectFunctions(sourceFile)) {
+            const fp = fingerprintFunction(fn);
+            if (!fingerprintMap.has(fp))
+                fingerprintMap.set(fp, []);
+            fingerprintMap.get(fp).push({ filePath: sourceFilePathCanonical, name, line, col });
+        }
+    };
+    const analyzeChunk = (chunk) => {
+        const project = new Project({
+            skipAddingFilesFromTsConfig: true,
+            compilerOptions: { allowJs: true, jsx: 1 },
+        });
+        project.addSourceFilesAtPaths(chunk);
+        for (const sourceFile of project.getSourceFiles()) {
+            const sourceFilePath = sourceFile.getFilePath();
+            const sourceFileKey = toPathKey(sourceFilePath);
+            const sourceFilePathCanonical = sourcePathMap.get(sourceFileKey) ?? sourceFilePath;
+            const report = analyzeFile(sourceFile, {
+                config,
+                loadedPlugins: pluginRuntime.plugins,
+                projectRoot: targetPath,
+            });
+            report.path = sourceFilePathCanonical;
+            reports.push(report);
+            reportByPath.set(sourceFileKey, report);
+            if (isFileIgnored(sourceFile))
+                ignoredPaths.add(sourceFileKey);
+            collectCrossFileMetadata(sourceFile);
+        }
+    };
+    const chunks = chunkPaths(sourcePaths, analysisOptions.lowMemory ? analysisOptions.chunkSize : sourcePaths.length || 1);
+    for (const chunk of chunks) {
+        analyzeChunk(chunk);
     }
-    // Plugin load failures are surfaced as synthetic report entries.
+    // Plugin diagnostics are surfaced as synthetic report entries.
     if (pluginRuntime.errors.length > 0) {
         for (const err of pluginRuntime.errors) {
-            const pluginIssue = {
-                rule: 'plugin-error',
-                severity: 'warning',
-                message: `Failed to load plugin '${err.pluginId}': ${err.message}`,
-                line: 1,
-                column: 1,
-                snippet: err.pluginId,
-            };
-            reports.push({
-                path: path.join(targetPath, '.drift-plugin-errors', `${err.pluginId}.plugin`),
-                issues: [pluginIssue],
-                score: calculateScore([pluginIssue], RULE_WEIGHTS),
-            });
+            reports.push(pluginDiagnosticToIssue(targetPath, err, 'error'));
         }
     }
-    // ── Phase 2: dead-file + unused-export + unused-dependency ─────────────────
-    const deadFiles = detectDeadFiles(sourceFiles, allImportedPaths, RULE_WEIGHTS);
-    for (const [sfPath, issue] of deadFiles) {
-        if (ignoredPaths.has(sfPath))
-            continue;
-        const report = reportByPath.get(sfPath);
-        if (report) {
-            report.issues.push(issue);
-            report.score = calculateScore(report.issues, RULE_WEIGHTS);
+    if (pluginRuntime.warnings.length > 0) {
+        for (const warning of pluginRuntime.warnings) {
+            reports.push(pluginDiagnosticToIssue(targetPath, warning, 'warning'));
         }
     }
-    const unusedExports = detectUnusedExports(sourceFiles, allImportedNames, RULE_WEIGHTS);
-    for (const [sfPath, issues] of unusedExports) {
-        if (ignoredPaths.has(sfPath))
-            continue;
-        const report = reportByPath.get(sfPath);
-        if (report) {
+    for (const chunk of chunks) {
+        const project = new Project({
+            skipAddingFilesFromTsConfig: true,
+            compilerOptions: { allowJs: true, jsx: 1 },
+        });
+        project.addSourceFilesAtPaths(chunk);
+        const sourceFiles = project.getSourceFiles();
+        const importedPathsForChunk = new Set();
+        const importedNamesForChunk = new Map();
+        for (const sourceFile of sourceFiles) {
+            const sfPath = sourceFile.getFilePath();
+            const sfKey = toPathKey(sfPath);
+            if (allImportedPathKeys.has(sfKey))
+                importedPathsForChunk.add(sfPath);
+            const importedNames = allImportedNamesByKey.get(sfKey);
+            if (importedNames)
+                importedNamesForChunk.set(sfPath, new Set(importedNames));
+        }
+        const deadFiles = detectDeadFiles(sourceFiles, importedPathsForChunk, RULE_WEIGHTS);
+        for (const [sfPath, issue] of deadFiles) {
+            const report = getReport(sfPath);
+            if (report)
+                report.issues.push(issue);
+        }
+        const unusedExports = detectUnusedExports(sourceFiles, importedNamesForChunk, RULE_WEIGHTS);
+        for (const [sfPath, issues] of unusedExports) {
+            const report = getReport(sfPath);
+            if (!report)
+                continue;
             for (const issue of issues) {
                 report.issues.push(issue);
             }
-            report.score = calculateScore(report.issues, RULE_WEIGHTS);
         }
     }
     const unusedDepIssues = detectUnusedDependencies(targetPath, allLiteralImports, RULE_WEIGHTS);
@@ -317,86 +595,69 @@ export function analyzeProject(targetPath, config) {
             score: calculateScore(unusedDepIssues, RULE_WEIGHTS),
         });
     }
-    // ── Phase 3: circular-dependency ────────────────────────────────────────────
     const circularIssues = detectCircularDependencies(importGraph, RULE_WEIGHTS);
     for (const [filePath, issue] of circularIssues) {
-        if (ignoredPaths.has(filePath))
-            continue;
-        const report = reportByPath.get(filePath);
-        if (report) {
+        const report = getReport(filePath);
+        if (report)
             report.issues.push(issue);
-            report.score = calculateScore(report.issues, RULE_WEIGHTS);
-        }
     }
-    // ── Phase 3b: layer-violation ────────────────────────────────────────────────
     if (config?.layers && config.layers.length > 0) {
         const layerIssues = detectLayerViolations(importGraph, config.layers, targetPath, RULE_WEIGHTS);
         for (const [filePath, issues] of layerIssues) {
-            if (ignoredPaths.has(filePath))
+            const report = getReport(filePath);
+            if (!report)
                 continue;
-            const report = reportByPath.get(filePath);
-            if (report) {
-                for (const issue of issues) {
-                    report.issues.push(issue);
-                    report.score = Math.min(100, report.score + (RULE_WEIGHTS['layer-violation']?.weight ?? 5));
-                }
+            for (const issue of issues) {
+                report.issues.push(issue);
             }
         }
     }
-    // ── Phase 3c: cross-boundary-import ─────────────────────────────────────────
     if (config?.modules && config.modules.length > 0) {
         const boundaryIssues = detectCrossBoundaryImports(importGraph, config.modules, targetPath, RULE_WEIGHTS);
         for (const [filePath, issues] of boundaryIssues) {
-            if (ignoredPaths.has(filePath))
+            const report = getReport(filePath);
+            if (!report)
                 continue;
-            const report = reportByPath.get(filePath);
-            if (report) {
-                for (const issue of issues) {
-                    report.issues.push(issue);
-                    report.score = Math.min(100, report.score + (RULE_WEIGHTS['cross-boundary-import']?.weight ?? 5));
-                }
+            for (const issue of issues) {
+                report.issues.push(issue);
             }
         }
     }
-    // ── Phase 8: semantic-duplication ───────────────────────────────────────────
-    const fingerprintMap = new Map();
-    for (const sf of sourceFiles) {
-        if (isFileIgnored(sf))
-            continue;
-        const sfPath = sf.getFilePath();
-        for (const { fn, name, line, col } of collectFunctions(sf)) {
-            const fp = fingerprintFunction(fn);
-            if (!fingerprintMap.has(fp))
-                fingerprintMap.set(fp, []);
-            fingerprintMap.get(fp).push({ filePath: sfPath, name, line, col });
-        }
-    }
-    for (const [, entries] of fingerprintMap) {
-        if (entries.length < 2)
-            continue;
-        for (const entry of entries) {
-            const report = reportByPath.get(entry.filePath);
-            if (!report)
+    if (analysisOptions.includeSemanticDuplication) {
+        const relativePathCache = new Map();
+        const toRelativePath = (filePath) => {
+            const cached = relativePathCache.get(filePath);
+            if (cached)
+                return cached;
+            const value = path.relative(targetPath, filePath).replace(/\\/g, '/');
+            relativePathCache.set(filePath, value);
+            return value;
+        };
+        for (const [, entries] of fingerprintMap) {
+            if (entries.length < 2)
                 continue;
-            const others = entries
-                .filter(e => e !== entry)
-                .map(e => {
-                const rel = path.relative(targetPath, e.filePath).replace(/\\/g, '/');
-                return `${rel}:${e.line} (${e.name})`;
-            })
-                .join(', ');
-            const weight = RULE_WEIGHTS['semantic-duplication']?.weight ?? 12;
-            report.issues.push({
-                rule: 'semantic-duplication',
-                severity: 'warning',
-                message: `Function '${entry.name}' is semantically identical to: ${others}`,
-                line: entry.line,
-                column: entry.col,
-                snippet: `function ${entry.name} — duplicated in ${entries.length - 1} other location${entries.length > 2 ? 's' : ''}`,
-            });
-            report.score = Math.min(100, report.score + weight);
+            for (const entry of entries) {
+                const report = getReport(entry.filePath);
+                if (!report)
+                    continue;
+                const others = entries
+                    .filter((other) => other !== entry)
+                    .map((other) => `${toRelativePath(other.filePath)}:${other.line} (${other.name})`)
+                    .join(', ');
+                report.issues.push({
+                    rule: 'semantic-duplication',
+                    severity: 'warning',
+                    message: `Function '${entry.name}' is semantically identical to: ${others}`,
+                    line: entry.line,
+                    column: entry.col,
+                    snippet: `function ${entry.name} - duplicated in ${entries.length - 1} other location${entries.length > 2 ? 's' : ''}`,
+                });
+            }
         }
     }
+    for (const report of reportByPath.values()) {
+        report.score = calculateScore(report.issues, RULE_WEIGHTS);
+    }
     return reports;
 }
 //# sourceMappingURL=analyzer.js.map