@eduardbar/drift 0.9.1 → 1.1.0

package/src/rules/phase0-basic.ts

@@ -0,0 +1,194 @@
+import { SourceFile, SyntaxKind } from 'ts-morph'
+import type { DriftIssue } from '../types.js'
+import { hasIgnoreComment, getSnippet, getFunctionLikeLines, type FunctionLike } from './shared.js'
+
+const LARGE_FILE_THRESHOLD = 300
+const LARGE_FUNCTION_THRESHOLD = 50
+const SNIPPET_TRUNCATE_SHORT = 60
+const SNIPPET_TRUNCATE_LONG = 120
+
+export function detectLargeFile(file: SourceFile): DriftIssue[] {
+  const lineCount = file.getEndLineNumber()
+  if (lineCount > LARGE_FILE_THRESHOLD) {
+    return [
+      {
+        rule: 'large-file',
+        severity: 'error',
+        message: `File has ${lineCount} lines (threshold: ${LARGE_FILE_THRESHOLD}). Large files are the #1 sign of AI-generated structural drift.`,
+        line: 1,
+        column: 1,
+        snippet: `// ${lineCount} lines total`,
+      },
+    ]
+  }
+  return []
+}
+
+export function detectLargeFunctions(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 lines = getFunctionLikeLines(fn)
+    const startLine = fn.getStartLineNumber()
+    if (lines > LARGE_FUNCTION_THRESHOLD) {
+      if (hasIgnoreComment(file, startLine)) continue
+      issues.push({
+        rule: 'large-function',
+        severity: 'error',
+        message: `Function spans ${lines} lines (threshold: ${LARGE_FUNCTION_THRESHOLD}). AI tends to dump logic into single functions.`,
+        line: startLine,
+        column: fn.getStartLinePos(),
+        snippet: getSnippet(fn, file),
+      })
+    }
+  }
+  return issues
+}
+
+export function detectDebugLeftovers(file: SourceFile): DriftIssue[] {
+  const issues: DriftIssue[] = []
+
+  for (const call of file.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+    const expr = call.getExpression().getText()
+    const line = call.getStartLineNumber()
+    if (/^console\.(log|warn|error|debug|info)\b/.test(expr)) {
+      if (hasIgnoreComment(file, line)) continue
+      issues.push({
+        rule: 'debug-leftover',
+        severity: 'warning',
+        message: `console.${expr.split('.')[1]} left in production code.`,
+        line,
+        column: call.getStartLinePos(),
+        snippet: getSnippet(call, file),
+      })
+    }
+  }
+
+  const lines = file.getFullText().split('\n')
+  lines.forEach((lineContent, i) => {
+    if (/\/\/\s*(TODO|FIXME|HACK|XXX|TEMP)\b/i.test(lineContent)) {
+      if (hasIgnoreComment(file, i + 1)) return
+      issues.push({
+        rule: 'debug-leftover',
+        severity: 'warning',
+        message: `Unresolved marker found: ${lineContent.trim().slice(0, SNIPPET_TRUNCATE_SHORT)}`,
+        line: i + 1,
+        column: 1,
+        snippet: lineContent.trim().slice(0, SNIPPET_TRUNCATE_LONG),
+      })
+    }
+  })
+
+  return issues
+}
+
+export function detectDeadCode(file: SourceFile): DriftIssue[] {
+  const issues: DriftIssue[] = []
+
+  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) {
+        issues.push({
+          rule: 'dead-code',
+          severity: 'warning',
+          message: `Unused import '${name}'. AI often imports more than it uses.`,
+          line: imp.getStartLineNumber(),
+          column: imp.getStartLinePos(),
+          snippet: getSnippet(imp, file),
+        })
+      }
+    }
+  }
+
+  return issues
+}
+
+export function detectDuplicateFunctionNames(file: SourceFile): DriftIssue[] {
+  const issues: DriftIssue[] = []
+  const seen = new Map<string, number>()
+
+  const fns = file.getFunctions()
+  for (const fn of fns) {
+    const name = fn.getName()
+    if (!name) continue
+    const normalized = name.toLowerCase().replace(/[_-]/g, '')
+    if (seen.has(normalized)) {
+      issues.push({
+        rule: 'duplicate-function-name',
+        severity: 'error',
+        message: `Function '${name}' looks like a duplicate of a previously defined function. AI often generates near-identical helpers.`,
+        line: fn.getStartLineNumber(),
+        column: fn.getStartLinePos(),
+        snippet: getSnippet(fn, file),
+      })
+    } else {
+      seen.set(normalized, fn.getStartLineNumber())
+    }
+  }
+  return issues
+}
+
+export function detectAnyAbuse(file: SourceFile): DriftIssue[] {
+  const issues: DriftIssue[] = []
+  for (const node of file.getDescendantsOfKind(SyntaxKind.AnyKeyword)) {
+    issues.push({
+      rule: 'any-abuse',
+      severity: 'warning',
+      message: `Explicit 'any' type detected. AI defaults to 'any' when it can't infer types properly.`,
+      line: node.getStartLineNumber(),
+      column: node.getStartLinePos(),
+      snippet: getSnippet(node, file),
+    })
+  }
+  return issues
+}
+
+export function detectCatchSwallow(file: SourceFile): DriftIssue[] {
+  const issues: DriftIssue[] = []
+  for (const tryCatch of file.getDescendantsOfKind(SyntaxKind.TryStatement)) {
+    const catchClause = tryCatch.getCatchClause()
+    if (!catchClause) continue
+    const block = catchClause.getBlock()
+    const stmts = block.getStatements()
+    if (stmts.length === 0) {
+      const line = catchClause.getStartLineNumber()
+      if (hasIgnoreComment(file, line)) continue
+      issues.push({
+        rule: 'catch-swallow',
+        severity: 'warning',
+        message: `Empty catch block silently swallows errors. Classic AI pattern to make code "not throw".`,
+        line,
+        column: catchClause.getStartLinePos(),
+        snippet: getSnippet(catchClause, file),
+      })
+    }
+  }
+  return issues
+}
+
+export function detectMissingReturnTypes(file: SourceFile): DriftIssue[] {
+  const issues: DriftIssue[] = []
+  for (const fn of file.getFunctions()) {
+    if (!fn.getReturnTypeNode()) {
+      issues.push({
+        rule: 'no-return-type',
+        severity: 'info',
+        message: `Function '${fn.getName() ?? 'anonymous'}' has no explicit return type.`,
+        line: fn.getStartLineNumber(),
+        column: fn.getStartLinePos(),
+        snippet: getSnippet(fn, file),
+      })
+    }
+  }
+  return issues
+}

package/src/rules/phase1-complexity.ts

@@ -0,0 +1,8 @@
+// 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

@@ -0,0 +1,177 @@
+// 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.
+ */
+export function detectDeadFiles(
+  sourceFiles: SourceFile[],
+  allImportedPaths: Set<string>,
+  ruleWeights: Record<string, { severity: DriftIssue['severity']; weight: number }>,
+): Map<string, DriftIssue> {
+  const issues = new Map<string, DriftIssue>()
+
+  for (const sf of sourceFiles) {
+    const sfPath = sf.getFilePath()
+    const basename = path.basename(sfPath)
+    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, {
+        rule: 'dead-file',
+        severity: ruleWeights['dead-file'].severity,
+        message: 'File is never imported — may be dead code',
+        line: 1,
+        column: 1,
+        snippet: basename,
+      })
+    }
+  }
+
+  return issues
+}
+
+/**
+ * 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>>,
+  ruleWeights: Record<string, { severity: DriftIssue['severity']; weight: number }>,
+): Map<string, DriftIssue[]> {
+  const result = new Map<string, DriftIssue[]>()
+
+  for (const sf of sourceFiles) {
+    const sfPath = sf.getFilePath()
+    const basename = path.basename(sfPath)
+    const isBarrel = /^index\.(ts|tsx|js|jsx)$/.test(basename)
+    const importedNamesForFile = allImportedNames.get(sfPath)
+    const hasNamespaceImport = importedNamesForFile?.has('*') ?? false
+
+    if (isBarrel || hasNamespaceImport) continue
+
+    const issues: DriftIssue[] = [
+      ...checkExportDeclarations(sf, sfPath, importedNamesForFile, ruleWeights),
+      ...checkInlineExports(sf, sfPath, importedNamesForFile, ruleWeights),
+    ]
+
+    if (issues.length > 0) {
+      result.set(sfPath, issues)
+    }
+  }
+
+  return result
+}
+
+/**
+ * Detect packages in package.json that are never imported in any source file.
+ * @type-only packages (@types/*) are excluded.
+ */
+export function detectUnusedDependencies(
+  targetPath: string,
+  allLiteralImports: Set<string>,
+  ruleWeights: Record<string, { severity: DriftIssue['severity']; weight: number }>,
+): DriftIssue[] {
+  const pkgPath = path.join(targetPath, 'package.json') // drift-ignore
+  if (!fs.existsSync(pkgPath)) return []
+
+  let pkg: Record<string, unknown>
+  try {
+    pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'))
+  } catch {
+    pkg = {}
+  }
+
+  const deps = {
+    ...((pkg.dependencies as Record<string, string>) ?? {}),
+  }
+
+  const unusedDeps: string[] = []
+  for (const depName of Object.keys(deps)) {
+    // Skip type-only packages (@types/*)
+    if (depName.startsWith('@types/')) continue
+
+    // A dependency is "used" if any import specifier starts with the package name
+    const isUsed = [...allLiteralImports].some(
+      imp => imp === depName || imp.startsWith(depName + '/')
+    )
+    if (!isUsed) unusedDeps.push(depName)
+  }
+
+  return unusedDeps.map(dep => ({
+    rule: 'unused-dependency',
+    severity: ruleWeights['unused-dependency'].severity,
+    message: `'${dep}' is in package.json but never imported`,
+    line: 1,
+    column: 1,
+    snippet: `"${dep}"`,
+  }))
+}

package/src/rules/phase3-arch.ts

@@ -0,0 +1,183 @@
+// drift-ignore-file
+
+import * as path from 'node:path'
+import type { DriftIssue, LayerDefinition, ModuleBoundary } from '../types.js'
+
+/**
+ * DFS cycle detection in a directed import graph.
+ * Returns arrays of file paths that form cycles.
+ */
+export function findCycles(graph: Map<string, Set<string>>): Array<string[]> {
+  const visited = new Set<string>()
+  const inStack = new Set<string>()
+  const cycles: Array<string[]> = []
+
+  function dfs(node: string, stack: string[]): void {
+    visited.add(node)
+    inStack.add(node)
+    stack.push(node)
+
+    for (const neighbor of graph.get(node) ?? []) {
+      if (!visited.has(neighbor)) {
+        dfs(neighbor, stack)
+      } else if (inStack.has(neighbor)) {
+        // Found a cycle — extract the cycle portion from the stack
+        const cycleStart = stack.indexOf(neighbor)
+        cycles.push(stack.slice(cycleStart))
+      }
+    }
+
+    stack.pop()
+    inStack.delete(node)
+  }
+
+  for (const node of graph.keys()) {
+    if (!visited.has(node)) {
+      dfs(node, [])
+    }
+  }
+
+  return cycles
+}
+
+/**
+ * Detect circular dependencies from the import graph.
+ * Returns a map of filePath → issue (one per unique cycle).
+ */
+export function detectCircularDependencies(
+  importGraph: Map<string, Set<string>>,
+  ruleWeights: Record<string, { severity: DriftIssue['severity']; weight: number }>,
+): Map<string, DriftIssue> {
+  const cycles = findCycles(importGraph)
+  const reportedCycleKeys = new Set<string>()
+  const result = new Map<string, DriftIssue>()
+
+  for (const cycle of cycles) {
+    const cycleKey = [...cycle].sort().join('|')
+    if (reportedCycleKeys.has(cycleKey)) continue
+    reportedCycleKeys.add(cycleKey)
+
+    const firstFile = cycle[0]
+    if (!firstFile) continue
+
+    const cycleDisplay = cycle
+      .map(p => path.basename(p))
+      .concat(path.basename(cycle[0])) // close the loop visually: A → B → C → A
+      .join(' → ')
+
+    result.set(firstFile, {
+      rule: 'circular-dependency',
+      severity: ruleWeights['circular-dependency'].severity,
+      message: `Circular dependency detected: ${cycleDisplay}`,
+      line: 1,
+      column: 1,
+      snippet: cycleDisplay,
+    })
+  }
+
+  return result
+}
+
+/**
+ * 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[],
+  targetPath: string,
+  ruleWeights: Record<string, { severity: DriftIssue['severity']; weight: number }>,
+): Map<string, DriftIssue[]> {
+  const result = new Map<string, DriftIssue[]>()
+
+  for (const [filePath, imports] of importGraph.entries()) {
+    const fileLayer = matchLayer(filePath, layers)
+    if (!fileLayer) continue
+
+    for (const importedPath of imports) {
+      const importedLayer = matchLayer(importedPath, layers)
+      if (!importedLayer) continue
+      if (importedLayer.name === fileLayer.name) continue
+
+      if (!fileLayer.canImportFrom.includes(importedLayer.name)) {
+        if (!result.has(filePath)) result.set(filePath, [])
+        result.get(filePath)!.push({
+          rule: 'layer-violation',
+          severity: 'error',
+          message: `Layer '${fileLayer.name}' must not import from layer '${importedLayer.name}'`,
+          line: 1,
+          column: 1,
+          snippet: `import from '${path.relative(targetPath, importedPath).replace(/\\/g, '/')}'`,
+        })
+      }
+    }
+  }
+
+  return result
+}
+
+/**
+ * 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[],
+  targetPath: string,
+  ruleWeights: Record<string, { severity: DriftIssue['severity']; weight: number }>,
+): Map<string, DriftIssue[]> {
+  const result = new Map<string, DriftIssue[]>()
+
+  for (const [filePath, imports] of importGraph.entries()) {
+    const fileModule = matchModule(filePath, modules)
+    if (!fileModule) continue
+
+    for (const importedPath of imports) {
+      const importedModule = matchModule(importedPath, modules)
+      if (!importedModule) continue
+      if (importedModule.name === fileModule.name) continue
+
+      const allowedImports = fileModule.allowedExternalImports ?? []
+      if (!isAllowedImport(importedPath, allowedImports)) {
+        if (!result.has(filePath)) result.set(filePath, [])
+        result.get(filePath)!.push({
+          rule: 'cross-boundary-import',
+          severity: 'warning',
+          message: `Module '${fileModule.name}' must not import from module '${importedModule.name}'`,
+          line: 1,
+          column: 1,
+          snippet: `import from '${path.relative(targetPath, importedPath).replace(/\\/g, '/')}'`,
+        })
+      }
+    }
+  }
+
+  return result
+}

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
+}