@eduardbar/drift 1.0.0 → 1.2.0

package/src/rules/phase1-complexity.ts

@@ -1,302 +1,8 @@
-import { SourceFile, SyntaxKind, Node } from 'ts-morph'
-import type { DriftIssue } from '../types.js'
-import { hasIgnoreComment, getSnippet, type FunctionLike } 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: FunctionLike): number {
-  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: SourceFile): DriftIssue[] {
-  const issues: DriftIssue[] = []
-  const fns: FunctionLike[] = [
-    ...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: FunctionLike): number {
-  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: Node, depth: number): void {
-    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: SourceFile): DriftIssue[] {
-  const issues: DriftIssue[] = []
-  const fns: FunctionLike[] = [
-    ...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: SourceFile): DriftIssue[] {
-  const issues: DriftIssue[] = []
-  const fns: FunctionLike[] = [
-    ...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: SourceFile): DriftIssue[] {
-  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: SourceFile): DriftIssue[] {
-  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: SourceFile): DriftIssue[] {
-  const issues: DriftIssue[] = []
-  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: SourceFile): DriftIssue[] {
-  const issues: DriftIssue[] = []
-  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'

package/src/rules/phase2-crossfile.ts

@@ -1,8 +1,13 @@
+// drift-ignore-file
 import * as fs from 'node:fs'
 import * as path from 'node:path'
 import { SourceFile } from 'ts-morph'
 import type { DriftIssue } from '../types.js'
 
+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.
@@ -17,7 +22,7 @@ export function detectDeadFiles(
   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)) {
@@ -39,6 +44,64 @@ export function detectDeadFiles(
  * 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: SourceFile,
+  sfPath: string,
+  importedNamesForFile: Set<string> | undefined,
+  ruleWeights: Record<string, { severity: DriftIssue['severity']; weight: number }>,
+): DriftIssue[] {
+  const issues: DriftIssue[] = []
+
+  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: SourceFile,
+  sfPath: string,
+  importedNamesForFile: Set<string> | undefined,
+  ruleWeights: Record<string, { severity: DriftIssue['severity']; weight: number }>,
+): DriftIssue[] {
+  const issues: DriftIssue[] = []
+
+  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: SourceFile[],
   allImportedNames: Map<string, Set<string>>,
@@ -55,45 +118,10 @@ export function detectUnusedExports(
 
     if (isBarrel || hasNamespaceImport) continue
 
-    const issues: DriftIssue[] = []
-
-    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: DriftIssue[] = [
+      ...checkExportDeclarations(sf, sfPath, importedNamesForFile, ruleWeights),
+      ...checkInlineExports(sf, sfPath, importedNamesForFile, ruleWeights),
+    ]
 
     if (issues.length > 0) {
       result.set(sfPath, issues)

package/src/rules/phase3-arch.ts

@@ -1,3 +1,5 @@
+// drift-ignore-file
+
 import * as path from 'node:path'
 import type { DriftIssue, LayerDefinition, ModuleBoundary } from '../types.js'
 
@@ -80,6 +82,21 @@ export function detectCircularDependencies(
  * Detect layer violations based on user-defined layer configuration.
  * Returns a map of filePath → issues[].
  */
+function matchLayer(filePath: string, layers: LayerDefinition[]): LayerDefinition | undefined {
+  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: Map<string, Set<string>>,
   layers: LayerDefinition[],
@@ -88,27 +105,12 @@ export function detectLayerViolations(
 ): Map<string, DriftIssue[]> {
   const result = new Map<string, DriftIssue[]>()
 
-  function getLayer(filePath: string): LayerDefinition | undefined {
-    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) continue
 
@@ -133,6 +135,18 @@ export function detectLayerViolations(
  * Detect cross-boundary imports based on user-defined module boundary configuration.
  * Returns a map of filePath → issues[].
  */
+function matchModule(filePath: string, modules: ModuleBoundary[]): ModuleBoundary | undefined {
+  const rel = filePath.replace(/\\/g, '/')
+  return modules.find(m => rel.startsWith(m.root.replace(/\\/g, '/')))
+}
+
+function isAllowedImport(importedPath: string, allowedImports: string[]): boolean {
+  const relImported = importedPath.replace(/\\/g, '/')
+  return allowedImports.some(allowed =>
+    relImported.startsWith(allowed.replace(/\\/g, '/'))
+  )
+}
+
 export function detectCrossBoundaryImports(
   importGraph: Map<string, Set<string>>,
   modules: ModuleBoundary[],
@@ -141,27 +155,17 @@ export function detectCrossBoundaryImports(
 ): Map<string, DriftIssue[]> {
   const result = new Map<string, DriftIssue[]>()
 
-  function getModule(filePath: string): ModuleBoundary | undefined {
-    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({
           rule: 'cross-boundary-import',

package/src/rules/phase3-configurable.ts

@@ -0,0 +1,132 @@
+import { SyntaxKind, type SourceFile } from 'ts-morph'
+import type { DriftConfig, DriftIssue } from '../types.js'
+
+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: string): boolean {
+  const normalized = filePath.replace(/\\/g, '/').toLowerCase()
+  return normalized.includes('/controller/') || normalized.includes('/controllers/') || normalized.endsWith('controller.ts') || normalized.endsWith('controller.js')
+}
+
+function isServiceFile(filePath: string): boolean {
+  const normalized = filePath.replace(/\\/g, '/').toLowerCase()
+  return normalized.includes('/service/') || normalized.includes('/services/') || normalized.endsWith('service.ts') || normalized.endsWith('service.js')
+}
+
+function createIssue(rule: string, message: string, line: number, snippet: string): DriftIssue {
+  return {
+    rule,
+    severity: 'warning',
+    message,
+    line,
+    column: 1,
+    snippet,
+  }
+}
+
+export function detectControllerNoDb(file: SourceFile, config?: DriftConfig): DriftIssue[] {
+  if (!config?.architectureRules?.controllerNoDb) return []
+  if (!isControllerFile(file.getFilePath())) return []
+
+  const issues: DriftIssue[] = []
+  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: SourceFile, config?: DriftConfig): DriftIssue[] {
+  if (!config?.architectureRules?.serviceNoHttp) return []
+  if (!isServiceFile(file.getFilePath())) return []
+
+  const issues: DriftIssue[] = []
+  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: SourceFile, config?: DriftConfig): DriftIssue[] {
+  const maxLines = config?.architectureRules?.maxFunctionLines
+  if (!maxLines || maxLines <= 0) return []
+
+  const issues: DriftIssue[] = []
+
+  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
+}