@eduardbar/drift 1.0.0 → 1.2.0

package/dist/reporter.js

@@ -1,4 +1,5 @@
 import { scoreToGradeText, severityIcon } from './utils.js';
+import { computeRepoQuality, computeMaintenanceRisk } from './metrics.js';
 const FIX_SUGGESTIONS = {
     'large-file': 'Consider splitting this file into smaller modules with single responsibility',
     'large-function': 'Extract logic into smaller functions with descriptive names',
@@ -21,6 +22,17 @@ const RULE_EFFORT = {
 };
 const SEVERITY_ORDER = { error: 0, warning: 1, info: 2 };
 const EFFORT_ORDER = { low: 0, medium: 1, high: 2 };
+const AI_SIGNAL_RULES = new Set([
+    'over-commented',
+    'hardcoded-config',
+    'inconsistent-error-handling',
+    'unnecessary-abstraction',
+    'naming-inconsistency',
+    'comment-contradiction',
+    'promise-style-mix',
+    'any-abuse',
+    'ai-code-smell',
+]);
 export function buildReport(targetPath, files) {
     const allIssues = files.flatMap((f) => f.issues);
     const byRule = {};
@@ -30,10 +42,11 @@ export function buildReport(targetPath, files) {
     const totalScore = files.length > 0
         ? Math.round(files.reduce((sum, f) => sum + f.score, 0) / files.length)
         : 0;
-    return {
+    const sortedFiles = files.filter((f) => f.issues.length > 0).sort((a, b) => b.score - a.score);
+    const baseReport = {
         scannedAt: new Date().toISOString(),
         targetPath,
-        files: files.filter((f) => f.issues.length > 0).sort((a, b) => b.score - a.score),
+        files: sortedFiles,
         totalIssues: allIssues.length,
         totalScore,
         totalFiles: files.length,
@@ -43,7 +56,29 @@ export function buildReport(targetPath, files) {
             infos: allIssues.filter((i) => i.severity === 'info').length,
             byRule,
         },
+        quality: {
+            overall: 100,
+            dimensions: {
+                architecture: 100,
+                complexity: 100,
+                'ai-patterns': 100,
+                testing: 100,
+            },
+        },
+        maintenanceRisk: {
+            score: 0,
+            level: 'low',
+            hotspots: [],
+            signals: {
+                highComplexityFiles: 0,
+                filesWithoutNearbyTests: 0,
+                frequentChangeFiles: 0,
+            },
+        },
     };
+    baseReport.quality = computeRepoQuality(targetPath, files);
+    baseReport.maintenanceRisk = computeMaintenanceRisk(baseReport);
+    return baseReport;
 }
 function formatHeader(report, grade) {
     return [
@@ -146,12 +181,55 @@ function buildRecommendedAction(priorityOrder) {
     }
     return 'Start with the highest priority issue and work through them in order.';
 }
+function fileAILikelihood(fileIssues) {
+    if (fileIssues.length === 0)
+        return { score: 0, triggers: [] };
+    const triggerCounts = new Map();
+    for (const issue of fileIssues) {
+        if (!AI_SIGNAL_RULES.has(issue.rule))
+            continue;
+        triggerCounts.set(issue.rule, (triggerCounts.get(issue.rule) ?? 0) + 1);
+    }
+    const triggerTotal = [...triggerCounts.values()].reduce((sum, count) => sum + count, 0);
+    const smellBoost = fileIssues.some((issue) => issue.rule === 'ai-code-smell') ? 20 : 0;
+    const ratioScore = Math.round((triggerTotal / Math.max(fileIssues.length, 1)) * 100);
+    const score = Math.max(0, Math.min(100, ratioScore + smellBoost));
+    const triggers = [...triggerCounts.entries()]
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 4)
+        .map(([rule]) => rule);
+    return { score, triggers };
+}
+function computeAILikelihood(report) {
+    const suspected = report.files
+        .map((file) => {
+        const likelihood = fileAILikelihood(file.issues);
+        return {
+            path: file.path,
+            ai_likelihood: likelihood.score,
+            triggers: likelihood.triggers,
+        };
+    })
+        .filter((entry) => entry.ai_likelihood >= 35)
+        .sort((a, b) => b.ai_likelihood - a.ai_likelihood);
+    const overall = suspected.length === 0
+        ? 0
+        : Math.round(suspected.reduce((sum, entry) => sum + entry.ai_likelihood, 0) / suspected.length);
+    const smellCount = report.files.flatMap((file) => file.issues).filter((issue) => issue.rule === 'ai-code-smell').length;
+    const smellScore = Math.min(100, smellCount * 15);
+    return {
+        overall,
+        files: suspected.slice(0, 10),
+        smellScore,
+    };
+}
 export function formatAIOutput(report) {
     const allIssues = collectAllIssues(report);
     const sortedIssues = sortIssues(allIssues);
     const priorityOrder = sortedIssues.map((item, i) => buildAIIssue(item, i + 1));
     const rulesDetected = [...new Set(allIssues.map((i) => i.issue.rule))];
     const grade = scoreToGradeText(report.totalScore);
+    const aiLikelihood = computeAILikelihood(report);
     return {
         summary: {
             score: report.totalScore,
@@ -159,8 +237,13 @@ export function formatAIOutput(report) {
             total_issues: report.totalIssues,
             files_affected: report.files.length,
             files_clean: report.totalFiles - report.files.length,
+            ai_likelihood: aiLikelihood.overall,
+            ai_code_smell_score: aiLikelihood.smellScore,
         },
+        files_suspected: aiLikelihood.files,
         priority_order: priorityOrder,
+        maintenance_risk: report.maintenanceRisk,
+        quality: report.quality,
         context_for_ai: {
             project_type: 'typescript',
             scan_path: report.targetPath,

package/dist/review.d.ts

@@ -0,0 +1,15 @@
+import type { DriftDiff } from './types.js';
+export interface DriftReview {
+    baseRef: string;
+    scannedAt: string;
+    totalDelta: number;
+    newIssues: number;
+    resolvedIssues: number;
+    status: 'clean' | 'improved' | 'regressed';
+    summary: string;
+    markdown: string;
+    diff: DriftDiff;
+}
+export declare function formatReviewMarkdown(review: DriftReview): string;
+export declare function generateReview(projectPath: string, baseRef: string): Promise<DriftReview>;
+//# sourceMappingURL=review.d.ts.map

package/dist/review.js

@@ -0,0 +1,80 @@
+import { resolve } from 'node:path';
+import { analyzeProject } from './analyzer.js';
+import { loadConfig } from './config.js';
+import { buildReport } from './reporter.js';
+import { cleanupTempDir, extractFilesAtRef } from './git.js';
+import { computeDiff } from './diff.js';
+export function formatReviewMarkdown(review) {
+    const trendIcon = review.status === 'regressed' ? '⚠️' : review.status === 'improved' ? '✅' : 'ℹ️';
+    const topFiles = review.diff.files
+        .slice(0, 8)
+        .map((file) => {
+        const sign = file.scoreDelta > 0 ? '+' : '';
+        return `- \`${file.path}\`: ${file.scoreBefore} -> ${file.scoreAfter} (${sign}${file.scoreDelta}), +${file.newIssues.length} new / -${file.resolvedIssues.length} resolved`;
+    })
+        .join('\n');
+    return [
+        '## drift review',
+        '',
+        `${trendIcon} ${review.summary}`,
+        '',
+        `- Base ref: \`${review.baseRef}\``,
+        `- Score delta: **${review.totalDelta >= 0 ? '+' : ''}${review.totalDelta}**`,
+        `- New issues: **${review.newIssues}**`,
+        `- Resolved issues: **${review.resolvedIssues}**`,
+        '',
+        '### File breakdown',
+        topFiles || '- No file-level deltas detected',
+    ].join('\n');
+}
+function getStatus(totalDelta, newIssues) {
+    if (totalDelta > 0 || newIssues > 0)
+        return 'regressed';
+    if (totalDelta < 0)
+        return 'improved';
+    return 'clean';
+}
+export async function generateReview(projectPath, baseRef) {
+    const resolvedPath = resolve(projectPath);
+    const config = await loadConfig(resolvedPath);
+    const currentFiles = analyzeProject(resolvedPath, config);
+    const currentReport = buildReport(resolvedPath, currentFiles);
+    let tempDir;
+    try {
+        tempDir = extractFilesAtRef(resolvedPath, baseRef);
+        const baseFiles = analyzeProject(tempDir, config);
+        const baseReport = buildReport(tempDir, baseFiles);
+        const remappedBase = {
+            ...baseReport,
+            files: baseReport.files.map((file) => ({
+                ...file,
+                path: file.path.replace(tempDir, resolvedPath),
+            })),
+        };
+        const diff = computeDiff(remappedBase, currentReport, baseRef);
+        const status = getStatus(diff.totalDelta, diff.newIssuesCount);
+        const summary = status === 'regressed'
+            ? `Drift regressed: +${diff.totalDelta} score and ${diff.newIssuesCount} new issue(s).`
+            : status === 'improved'
+                ? `Drift improved: ${diff.totalDelta} score delta and ${diff.resolvedIssuesCount} issue(s) resolved.`
+                : 'No drift changes detected against base ref.';
+        const review = {
+            baseRef,
+            scannedAt: new Date().toISOString(),
+            totalDelta: diff.totalDelta,
+            newIssues: diff.newIssuesCount,
+            resolvedIssues: diff.resolvedIssuesCount,
+            status,
+            summary,
+            markdown: '',
+            diff,
+        };
+        review.markdown = formatReviewMarkdown(review);
+        return review;
+    }
+    finally {
+        if (tempDir)
+            cleanupTempDir(tempDir);
+    }
+}
+//# sourceMappingURL=review.js.map

package/dist/rules/comments.d.ts

@@ -0,0 +1,4 @@
+import { SourceFile } from 'ts-morph';
+import type { DriftIssue } from '../types.js';
+export declare function detectCommentContradiction(file: SourceFile): DriftIssue[];
+//# sourceMappingURL=comments.d.ts.map

package/dist/rules/comments.js

@@ -0,0 +1,45 @@
+import { hasIgnoreComment } from './shared.js';
+const TRIVIAL_COMMENT_PATTERNS = [
+    { comment: /\/\/\s*return\b/i, code: /^\s*return\b/ },
+    { comment: /\/\/\s*(increment|increase|add\s+1|plus\s+1)\b/i, code: /\+\+|(\+= ?1)\b/ },
+    { comment: /\/\/\s*(decrement|decrease|subtract\s+1|minus\s+1)\b/i, code: /--|(-= ?1)\b/ },
+    { comment: /\/\/\s*log\b/i, code: /console\.(log|warn|error)/ },
+    { comment: /\/\/\s*(set|assign)\b/i, code: /^\s*\w[\w.[\]]*\s*=(?!=)/ },
+    { comment: /\/\/\s*call\b/i, code: /^\s*\w[\w.]*\(/ },
+    { comment: /\/\/\s*(declare|define|create|initialize)\b/i, code: /^\s*(const|let|var)\b/ },
+    { comment: /\/\/\s*check\s+if\b/i, code: /^\s*if\s*\(/ },
+    { comment: /\/\/\s*(loop|iterate|for each|foreach)\b/i, code: /^\s*(for|while)\b/ },
+    { comment: /\/\/\s*import\b/i, code: /^\s*import\b/ },
+];
+const SNIPPET_TRUNCATE = 60;
+function checkLineForContradiction(commentLine, nextLine, lineNumber, file) {
+    for (const { comment, code } of TRIVIAL_COMMENT_PATTERNS) {
+        if (comment.test(commentLine) && code.test(nextLine)) {
+            if (hasIgnoreComment(file, lineNumber))
+                return null;
+            return {
+                rule: 'comment-contradiction',
+                severity: 'warning',
+                message: `Comment restates what the code already says. AI documents the obvious instead of the why.`,
+                line: lineNumber,
+                column: 1,
+                snippet: `${commentLine.slice(0, SNIPPET_TRUNCATE)}\n${nextLine.trim().slice(0, SNIPPET_TRUNCATE)}`,
+            };
+        }
+    }
+    return null;
+}
+export function detectCommentContradiction(file) {
+    const issues = [];
+    const lines = file.getFullText().split('\n');
+    for (let i = 0; i < lines.length - 1; i++) {
+        const commentLine = lines[i].trim();
+        const nextLine = lines[i + 1];
+        const issue = checkLineForContradiction(commentLine, nextLine, i + 1, file);
+        if (issue) {
+            issues.push(issue);
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=comments.js.map

package/dist/rules/complexity.d.ts

@@ -0,0 +1,4 @@
+import { SourceFile } from 'ts-morph';
+import type { DriftIssue } from '../types.js';
+export declare function detectHighComplexity(file: SourceFile): DriftIssue[];
+//# sourceMappingURL=complexity.d.ts.map

package/dist/rules/complexity.js

@@ -0,0 +1,51 @@
+import { SyntaxKind } from 'ts-morph';
+import { hasIgnoreComment, getSnippet } from './shared.js';
+const COMPLEXITY_THRESHOLD = 10;
+const INCREMENT_KINDS = [
+    SyntaxKind.IfStatement,
+    SyntaxKind.ForStatement,
+    SyntaxKind.ForInStatement,
+    SyntaxKind.ForOfStatement,
+    SyntaxKind.WhileStatement,
+    SyntaxKind.DoStatement,
+    SyntaxKind.CaseClause,
+    SyntaxKind.CatchClause,
+    SyntaxKind.ConditionalExpression,
+    SyntaxKind.AmpersandAmpersandToken,
+    SyntaxKind.BarBarToken,
+    SyntaxKind.QuestionQuestionToken,
+];
+function getCyclomaticComplexity(fn) {
+    let complexity = 1;
+    for (const kind of INCREMENT_KINDS) {
+        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 > COMPLEXITY_THRESHOLD) {
+            const startLine = fn.getStartLineNumber();
+            if (hasIgnoreComment(file, startLine))
+                continue;
+            issues.push({
+                rule: 'high-complexity',
+                severity: 'error',
+                message: `Cyclomatic complexity is ${complexity} (threshold: ${COMPLEXITY_THRESHOLD}). AI generates correct code, not simple code.`,
+                line: startLine,
+                column: fn.getStartLinePos(),
+                snippet: getSnippet(fn, file),
+            });
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=complexity.js.map

package/dist/rules/coupling.d.ts

@@ -0,0 +1,4 @@
+import { SourceFile } from 'ts-morph';
+import type { DriftIssue } from '../types.js';
+export declare function detectHighCoupling(file: SourceFile): DriftIssue[];
+//# sourceMappingURL=coupling.d.ts.map

package/dist/rules/coupling.js

@@ -0,0 +1,19 @@
+const COUPLING_THRESHOLD = 10;
+export function detectHighCoupling(file) {
+    const imports = file.getImportDeclarations();
+    const sources = new Set(imports.map((i) => i.getModuleSpecifierValue()));
+    if (sources.size > COUPLING_THRESHOLD) {
+        return [
+            {
+                rule: 'high-coupling',
+                severity: 'warning',
+                message: `File imports from ${sources.size} distinct modules (threshold: ${COUPLING_THRESHOLD}). High coupling makes refactoring dangerous.`,
+                line: 1,
+                column: 1,
+                snippet: `// ${sources.size} import sources`,
+            },
+        ];
+    }
+    return [];
+}
+//# sourceMappingURL=coupling.js.map

package/dist/rules/magic.d.ts

@@ -0,0 +1,4 @@
+import { SourceFile } from 'ts-morph';
+import type { DriftIssue } from '../types.js';
+export declare function detectMagicNumbers(file: SourceFile): DriftIssue[];
+//# sourceMappingURL=magic.d.ts.map

package/dist/rules/magic.js

@@ -0,0 +1,33 @@
+import { SyntaxKind } from 'ts-morph';
+import { hasIgnoreComment, getSnippet } from './shared.js';
+const ALLOWED_NUMBERS = new Set([0, 1, -1, 2, 100]);
+export function detectMagicNumbers(file) {
+    const issues = [];
+    for (const node of file.getDescendantsOfKind(SyntaxKind.NumericLiteral)) {
+        const value = Number(node.getLiteralValue());
+        if (ALLOWED_NUMBERS.has(value))
+            continue;
+        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;
+}
+//# sourceMappingURL=magic.js.map

package/dist/rules/nesting.d.ts

@@ -0,0 +1,5 @@
+import { SourceFile } from 'ts-morph';
+import type { DriftIssue } from '../types.js';
+export declare function detectDeepNesting(file: SourceFile): DriftIssue[];
+export declare function detectTooManyParams(file: SourceFile): DriftIssue[];
+//# sourceMappingURL=nesting.d.ts.map

package/dist/rules/nesting.js

@@ -0,0 +1,82 @@
+import { SyntaxKind } from 'ts-morph';
+import { hasIgnoreComment, getSnippet } from './shared.js';
+const NESTING_THRESHOLD = 3;
+const PARAMS_THRESHOLD = 4;
+const NESTING_KINDS = new Set([
+    SyntaxKind.IfStatement,
+    SyntaxKind.ForStatement,
+    SyntaxKind.ForInStatement,
+    SyntaxKind.ForOfStatement,
+    SyntaxKind.WhileStatement,
+    SyntaxKind.DoStatement,
+    SyntaxKind.TryStatement,
+    SyntaxKind.SwitchStatement,
+]);
+function getMaxNestingDepth(fn) {
+    let maxDepth = 0;
+    function walk(node, depth) {
+        if (NESTING_KINDS.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 > NESTING_THRESHOLD) {
+            const startLine = fn.getStartLineNumber();
+            if (hasIgnoreComment(file, startLine))
+                continue;
+            issues.push({
+                rule: 'deep-nesting',
+                severity: 'warning',
+                message: `Maximum nesting depth is ${depth} (threshold: ${NESTING_THRESHOLD}). Deep nesting is the #1 readability killer.`,
+                line: startLine,
+                column: fn.getStartLinePos(),
+                snippet: getSnippet(fn, file),
+            });
+        }
+    }
+    return issues;
+}
+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 > PARAMS_THRESHOLD) {
+            const startLine = fn.getStartLineNumber();
+            if (hasIgnoreComment(file, startLine))
+                continue;
+            issues.push({
+                rule: 'too-many-params',
+                severity: 'warning',
+                message: `Function has ${paramCount} parameters (threshold: ${PARAMS_THRESHOLD}). AI avoids refactoring into options objects.`,
+                line: startLine,
+                column: fn.getStartLinePos(),
+                snippet: getSnippet(fn, file),
+            });
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=nesting.js.map

package/dist/rules/phase0-basic.js

@@ -1,13 +1,17 @@
 import { SyntaxKind } from 'ts-morph';
 import { hasIgnoreComment, getSnippet, getFunctionLikeLines } 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) {
     const lineCount = file.getEndLineNumber();
-    if (lineCount > 300) {
+    if (lineCount > LARGE_FILE_THRESHOLD) {
         return [
             {
                 rule: 'large-file',
                 severity: 'error',
-                message: `File has ${lineCount} lines (threshold: 300). Large files are the #1 sign of AI-generated structural drift.`,
+                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`,
@@ -27,13 +31,13 @@ export function detectLargeFunctions(file) {
     for (const fn of fns) {
         const lines = getFunctionLikeLines(fn);
         const startLine = fn.getStartLineNumber();
-        if (lines > 50) {
+        if (lines > LARGE_FUNCTION_THRESHOLD) {
             if (hasIgnoreComment(file, startLine))
                 continue;
             issues.push({
                 rule: 'large-function',
                 severity: 'error',
-                message: `Function spans ${lines} lines (threshold: 50). AI tends to dump logic into single functions.`,
+                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),
@@ -68,10 +72,10 @@ export function detectDebugLeftovers(file) {
             issues.push({
                 rule: 'debug-leftover',
                 severity: 'warning',
-                message: `Unresolved marker found: ${lineContent.trim().slice(0, 60)}`,
+                message: `Unresolved marker found: ${lineContent.trim().slice(0, SNIPPET_TRUNCATE_SHORT)}`,
                 line: i + 1,
                 column: 1,
-                snippet: lineContent.trim().slice(0, 120),
+                snippet: lineContent.trim().slice(0, SNIPPET_TRUNCATE_LONG),
             });
         }
     });
@@ -145,11 +149,14 @@ export function detectCatchSwallow(file) {
         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: catchClause.getStartLineNumber(),
+                line,
                 column: catchClause.getStartLinePos(),
                 snippet: getSnippet(catchClause, file),
             });

package/dist/rules/phase1-complexity.d.ts

@@ -1,31 +1,7 @@
-import { SourceFile } from 'ts-morph';
-import type { DriftIssue } from '../types.js';
-export declare function detectHighComplexity(file: SourceFile): DriftIssue[];
-export declare function detectDeepNesting(file: SourceFile): DriftIssue[];
-/**
- * Too many parameters: functions with more than 4 parameters.
- * AI avoids refactoring parameters into objects/options bags.
- */
-export declare function detectTooManyParams(file: SourceFile): DriftIssue[];
-/**
- * High coupling: files with more than 10 distinct import sources.
- * AI imports broadly without considering module cohesion.
- */
-export declare function detectHighCoupling(file: SourceFile): DriftIssue[];
-/**
- * Promise style mix: async/await and .then()/.catch() used in the same file.
- * AI generates both styles without consistency.
- */
-export declare function detectPromiseStyleMix(file: SourceFile): DriftIssue[];
-/**
- * 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 declare function detectMagicNumbers(file: SourceFile): DriftIssue[];
-/**
- * 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 declare function detectCommentContradiction(file: SourceFile): DriftIssue[];
+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.d.ts.map