@eduardbar/drift 1.0.0 → 1.2.0

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;

package/dist/rules/phase2-crossfile.js

@@ -1,5 +1,9 @@
+// drift-ignore-file
 import * as fs from 'node:fs';
 import * as path from 'node:path';
+const SNIPPET_LENGTH = 80;
+// drift-ignore
+const BIN_DIR = '/bin/';
 /**
  * Detect files that are never imported by any other file in the project.
  * Entry-point files (index, main, cli, app, bin/) are excluded.
@@ -9,7 +13,7 @@ export function detectDeadFiles(sourceFiles, allImportedPaths, ruleWeights) {
     for (const sf of sourceFiles) {
         const sfPath = sf.getFilePath();
         const basename = path.basename(sfPath);
-        const isBinFile = sfPath.replace(/\\/g, '/').includes('/bin/');
+        const isBinFile = sfPath.replace(/\\/g, '/').includes(BIN_DIR);
         const isEntryPoint = /^(index|main|cli|app)\.(ts|tsx|js|jsx)$/.test(basename) || isBinFile;
         if (!isEntryPoint && !allImportedPaths.has(sfPath)) {
             issues.set(sfPath, {
@@ -28,6 +32,49 @@ export function detectDeadFiles(sourceFiles, allImportedPaths, ruleWeights) {
  * Detect named exports that are never imported by any other file.
  * Barrel files (index.*) are excluded since their entire surface is the public API.
  */
+function checkExportDeclarations(sf, sfPath, importedNamesForFile, ruleWeights) {
+    const issues = [];
+    for (const exportDecl of sf.getExportDeclarations()) {
+        for (const namedExport of exportDecl.getNamedExports()) {
+            const name = namedExport.getName();
+            if (!importedNamesForFile?.has(name)) {
+                issues.push({
+                    rule: 'unused-export',
+                    severity: ruleWeights['unused-export'].severity,
+                    message: `'${name}' is exported but never imported`,
+                    line: namedExport.getStartLineNumber(),
+                    column: 1,
+                    snippet: namedExport.getText().slice(0, SNIPPET_LENGTH),
+                });
+            }
+        }
+    }
+    return issues;
+}
+function checkInlineExports(sf, sfPath, importedNamesForFile, ruleWeights) {
+    const issues = [];
+    for (const exportSymbol of sf.getExportedDeclarations()) {
+        const [exportName, declarations] = [exportSymbol[0], exportSymbol[1]];
+        if (exportName === 'default')
+            continue;
+        if (importedNamesForFile?.has(exportName))
+            continue;
+        for (const decl of declarations) {
+            if (decl.getSourceFile().getFilePath() !== sfPath)
+                continue;
+            issues.push({
+                rule: 'unused-export',
+                severity: ruleWeights['unused-export'].severity,
+                message: `'${exportName}' is exported but never imported`,
+                line: decl.getStartLineNumber(),
+                column: 1,
+                snippet: decl.getText().split('\n')[0].slice(0, SNIPPET_LENGTH),
+            });
+            break;
+        }
+    }
+    return issues;
+}
 export function detectUnusedExports(sourceFiles, allImportedNames, ruleWeights) {
     const result = new Map();
     for (const sf of sourceFiles) {
@@ -38,44 +85,10 @@ export function detectUnusedExports(sourceFiles, allImportedNames, ruleWeights)
         const hasNamespaceImport = importedNamesForFile?.has('*') ?? false;
         if (isBarrel || hasNamespaceImport)
             continue;
-        const issues = [];
-        for (const exportDecl of sf.getExportDeclarations()) {
-            for (const namedExport of exportDecl.getNamedExports()) {
-                const name = namedExport.getName();
-                if (!importedNamesForFile?.has(name)) {
-                    issues.push({
-                        rule: 'unused-export',
-                        severity: ruleWeights['unused-export'].severity,
-                        message: `'${name}' is exported but never imported`,
-                        line: namedExport.getStartLineNumber(),
-                        column: 1,
-                        snippet: namedExport.getText().slice(0, 80),
-                    });
-                }
-            }
-        }
-        // Also check inline export declarations (export function foo, export const bar)
-        for (const exportSymbol of sf.getExportedDeclarations()) {
-            const [exportName, declarations] = [exportSymbol[0], exportSymbol[1]];
-            if (exportName === 'default')
-                continue;
-            if (importedNamesForFile?.has(exportName))
-                continue;
-            for (const decl of declarations) {
-                // Skip if this is a re-export from another file
-                if (decl.getSourceFile().getFilePath() !== sfPath)
-                    continue;
-                issues.push({
-                    rule: 'unused-export',
-                    severity: ruleWeights['unused-export'].severity,
-                    message: `'${exportName}' is exported but never imported`,
-                    line: decl.getStartLineNumber(),
-                    column: 1,
-                    snippet: decl.getText().split('\n')[0].slice(0, 80),
-                });
-                break; // one issue per export name is enough
-            }
-        }
+        const issues = [
+            ...checkExportDeclarations(sf, sfPath, importedNamesForFile, ruleWeights),
+            ...checkInlineExports(sf, sfPath, importedNamesForFile, ruleWeights),
+        ];
         if (issues.length > 0) {
             result.set(sfPath, issues);
         }

package/dist/rules/phase3-arch.d.ts

@@ -12,18 +12,10 @@ export declare function detectCircularDependencies(importGraph: Map<string, Set<
     severity: DriftIssue['severity'];
     weight: number;
 }>): Map<string, DriftIssue>;
-/**
- * Detect layer violations based on user-defined layer configuration.
- * Returns a map of filePath → issues[].
- */
 export declare function detectLayerViolations(importGraph: Map<string, Set<string>>, layers: LayerDefinition[], targetPath: string, ruleWeights: Record<string, {
     severity: DriftIssue['severity'];
     weight: number;
 }>): Map<string, DriftIssue[]>;
-/**
- * Detect cross-boundary imports based on user-defined module boundary configuration.
- * Returns a map of filePath → issues[].
- */
 export declare function detectCrossBoundaryImports(importGraph: Map<string, Set<string>>, modules: ModuleBoundary[], targetPath: string, ruleWeights: Record<string, {
     severity: DriftIssue['severity'];
     weight: number;

package/dist/rules/phase3-arch.js

@@ -1,3 +1,4 @@
+// drift-ignore-file
 import * as path from 'node:path';
 /**
  * DFS cycle detection in a directed import graph.
@@ -66,26 +67,26 @@ export function detectCircularDependencies(importGraph, ruleWeights) {
  * Detect layer violations based on user-defined layer configuration.
  * Returns a map of filePath → issues[].
  */
+function matchLayer(filePath, layers) {
+    const rel = filePath.replace(/\\/g, '/');
+    return layers.find(layer => layer.patterns.some(pattern => {
+        const regexStr = pattern
+            .replace(/\\/g, '/')
+            .replace(/[.+^${}()|[\]]/g, '\\$&')
+            .replace(/\*\*/g, '###DOUBLESTAR###')
+            .replace(/\*/g, '[^/]*')
+            .replace(/###DOUBLESTAR###/g, '.*');
+        return new RegExp(`^${regexStr}`).test(rel);
+    }));
+}
 export function detectLayerViolations(importGraph, layers, targetPath, ruleWeights) {
     const result = new Map();
-    function getLayer(filePath) {
-        const rel = filePath.replace(/\\/g, '/');
-        return layers.find(layer => layer.patterns.some(pattern => {
-            const regexStr = pattern
-                .replace(/\\/g, '/')
-                .replace(/[.+^${}()|[\]]/g, '\\$&')
-                .replace(/\*\*/g, '###DOUBLESTAR###')
-                .replace(/\*/g, '[^/]*')
-                .replace(/###DOUBLESTAR###/g, '.*');
-            return new RegExp(`^${regexStr}`).test(rel);
-        }));
-    }
     for (const [filePath, imports] of importGraph.entries()) {
-        const fileLayer = getLayer(filePath);
+        const fileLayer = matchLayer(filePath, layers);
         if (!fileLayer)
             continue;
         for (const importedPath of imports) {
-            const importedLayer = getLayer(importedPath);
+            const importedLayer = matchLayer(importedPath, layers);
             if (!importedLayer)
                 continue;
             if (importedLayer.name === fileLayer.name)
@@ -110,26 +111,28 @@ export function detectLayerViolations(importGraph, layers, targetPath, ruleWeigh
  * Detect cross-boundary imports based on user-defined module boundary configuration.
  * Returns a map of filePath → issues[].
  */
+function matchModule(filePath, modules) {
+    const rel = filePath.replace(/\\/g, '/');
+    return modules.find(m => rel.startsWith(m.root.replace(/\\/g, '/')));
+}
+function isAllowedImport(importedPath, allowedImports) {
+    const relImported = importedPath.replace(/\\/g, '/');
+    return allowedImports.some(allowed => relImported.startsWith(allowed.replace(/\\/g, '/')));
+}
 export function detectCrossBoundaryImports(importGraph, modules, targetPath, ruleWeights) {
     const result = new Map();
-    function getModule(filePath) {
-        const rel = filePath.replace(/\\/g, '/');
-        return modules.find(m => rel.startsWith(m.root.replace(/\\/g, '/')));
-    }
     for (const [filePath, imports] of importGraph.entries()) {
-        const fileModule = getModule(filePath);
+        const fileModule = matchModule(filePath, modules);
         if (!fileModule)
             continue;
         for (const importedPath of imports) {
-            const importedModule = getModule(importedPath);
+            const importedModule = matchModule(importedPath, modules);
             if (!importedModule)
                 continue;
             if (importedModule.name === fileModule.name)
                 continue;
             const allowedImports = fileModule.allowedExternalImports ?? [];
-            const relImported = importedPath.replace(/\\/g, '/');
-            const isAllowed = allowedImports.some(allowed => relImported.startsWith(allowed.replace(/\\/g, '/')));
-            if (!isAllowed) {
+            if (!isAllowedImport(importedPath, allowedImports)) {
                 if (!result.has(filePath))
                     result.set(filePath, []);
                 result.get(filePath).push({

package/dist/rules/phase3-configurable.d.ts

@@ -0,0 +1,6 @@
+import { type SourceFile } from 'ts-morph';
+import type { DriftConfig, DriftIssue } from '../types.js';
+export declare function detectControllerNoDb(file: SourceFile, config?: DriftConfig): DriftIssue[];
+export declare function detectServiceNoHttp(file: SourceFile, config?: DriftConfig): DriftIssue[];
+export declare function detectMaxFunctionLines(file: SourceFile, config?: DriftConfig): DriftIssue[];
+//# sourceMappingURL=phase3-configurable.d.ts.map

package/dist/rules/phase3-configurable.js

@@ -0,0 +1,97 @@
+import { SyntaxKind } from 'ts-morph';
+const DB_IMPORT_PATTERNS = [
+    /\bprisma\b/i,
+    /\btypeorm\b/i,
+    /\bsequelize\b/i,
+    /\bmongoose\b/i,
+    /\bknex\b/i,
+    /\brepository\b/i,
+    /\/db\//i,
+    /\/database\//i,
+];
+const HTTP_IMPORT_PATTERNS = [
+    /\bexpress\b/i,
+    /\bfastify\b/i,
+    /\bkoa\b/i,
+    /\bhono\b/i,
+    /^http$/i,
+    /^https$/i,
+];
+function isControllerFile(filePath) {
+    const normalized = filePath.replace(/\\/g, '/').toLowerCase();
+    return normalized.includes('/controller/') || normalized.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');
+}
+function createIssue(rule, message, line, snippet) {
+    return {
+        rule,
+        severity: 'warning',
+        message,
+        line,
+        column: 1,
+        snippet,
+    };
+}
+export function detectControllerNoDb(file, config) {
+    if (!config?.architectureRules?.controllerNoDb)
+        return [];
+    if (!isControllerFile(file.getFilePath()))
+        return [];
+    const issues = [];
+    for (const decl of file.getImportDeclarations()) {
+        const value = decl.getModuleSpecifierValue();
+        if (DB_IMPORT_PATTERNS.some((pattern) => pattern.test(value))) {
+            issues.push(createIssue('controller-no-db', `Controller imports database module '${value}'. Controllers should delegate persistence through services.`, decl.getStartLineNumber(), value));
+        }
+    }
+    return issues;
+}
+export function detectServiceNoHttp(file, config) {
+    if (!config?.architectureRules?.serviceNoHttp)
+        return [];
+    if (!isServiceFile(file.getFilePath()))
+        return [];
+    const issues = [];
+    for (const decl of file.getImportDeclarations()) {
+        const value = decl.getModuleSpecifierValue();
+        if (HTTP_IMPORT_PATTERNS.some((pattern) => pattern.test(value))) {
+            issues.push(createIssue('service-no-http', `Service imports HTTP framework '${value}'. Keep transport concerns outside service layer.`, decl.getStartLineNumber(), value));
+        }
+    }
+    for (const call of file.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+        const expressionText = call.getExpression().getText();
+        if (/\bfetch\b/.test(expressionText)) {
+            issues.push(createIssue('service-no-http', 'Service executes HTTP call directly (fetch). Move this to an adapter/client.', call.getStartLineNumber(), expressionText));
+        }
+    }
+    return issues;
+}
+export function detectMaxFunctionLines(file, config) {
+    const maxLines = config?.architectureRules?.maxFunctionLines;
+    if (!maxLines || maxLines <= 0)
+        return [];
+    const issues = [];
+    for (const fn of file.getFunctions()) {
+        const body = fn.getBody();
+        if (!body)
+            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)'));
+        }
+    }
+    for (const method of file.getDescendantsOfKind(SyntaxKind.MethodDeclaration)) {
+        const body = method.getBody();
+        if (!body)
+            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()));
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=phase3-configurable.js.map

package/dist/rules/phase8-semantic.d.ts

@@ -1,11 +1,6 @@
 import { SourceFile, FunctionDeclaration, ArrowFunction, FunctionExpression, MethodDeclaration } from 'ts-morph';
 import type { DriftIssue } from '../types.js';
 export type FunctionLikeNode = FunctionDeclaration | ArrowFunction | FunctionExpression | MethodDeclaration;
-/** Normalize a function body to a canonical string (Type-2 clone detection).
- *  Variable names, parameter names, and numeric/string literals are replaced
- *  with canonical tokens so that two functions with identical logic but
- *  different identifiers produce the same fingerprint.
- */
 export declare function normalizeFunctionBody(fn: FunctionLikeNode): string;
 /** Return a SHA-256 fingerprint for a function body (normalized). */
 export declare function fingerprintFunction(fn: FunctionLikeNode): string;