@eduardbar/drift 1.0.0 → 1.1.0

package/dist/metrics.js

@@ -0,0 +1,176 @@
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { execSync } from 'node:child_process';
+import { join, relative } from 'node:path';
+const ARCH_RULES = new Set([
+    'circular-dependency',
+    'layer-violation',
+    'cross-boundary-import',
+    'controller-no-db',
+    'service-no-http',
+]);
+const COMPLEXITY_RULES = new Set([
+    'large-file',
+    'large-function',
+    'high-complexity',
+    'deep-nesting',
+    'too-many-params',
+    'max-function-lines',
+]);
+const AI_RULES = new Set([
+    'over-commented',
+    'hardcoded-config',
+    'inconsistent-error-handling',
+    'unnecessary-abstraction',
+    'naming-inconsistency',
+    'comment-contradiction',
+    'ai-code-smell',
+]);
+function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+function listFilesRecursively(root) {
+    if (!existsSync(root))
+        return [];
+    const out = [];
+    const stack = [root];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        const entries = readdirSync(current);
+        for (const entry of entries) {
+            const full = join(current, entry);
+            const stat = statSync(full);
+            if (stat.isDirectory()) {
+                if (entry === 'node_modules' || entry === 'dist' || entry === '.git' || entry === '.next' || entry === 'build') {
+                    continue;
+                }
+                stack.push(full);
+            }
+            else {
+                out.push(full);
+            }
+        }
+    }
+    return out;
+}
+function hasNearbyTest(targetPath, filePath) {
+    const rel = relative(targetPath, filePath).replace(/\\/g, '/');
+    const noExt = rel.replace(/\.[^.]+$/, '');
+    const candidates = [
+        `${noExt}.test.ts`,
+        `${noExt}.test.tsx`,
+        `${noExt}.spec.ts`,
+        `${noExt}.spec.tsx`,
+        `${noExt}.test.js`,
+        `${noExt}.spec.js`,
+    ];
+    return candidates.some((candidate) => existsSync(join(targetPath, candidate)));
+}
+function getCommitTouchCount(targetPath, filePath) {
+    try {
+        const rel = relative(targetPath, filePath).replace(/\\/g, '/');
+        const output = execSync(`git rev-list --count HEAD -- "${rel}"`, {
+            cwd: targetPath,
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+        return Number(output) || 0;
+    }
+    catch {
+        return 0;
+    }
+}
+function qualityFromIssues(totalFiles, issues, rules) {
+    const count = issues.filter((issue) => rules.has(issue.rule)).length;
+    if (totalFiles === 0)
+        return 100;
+    return clamp(100 - Math.round((count / totalFiles) * 20), 0, 100);
+}
+export function computeRepoQuality(targetPath, files) {
+    const allIssues = files.flatMap((file) => file.issues);
+    const sourceFiles = files.filter((file) => !file.path.endsWith('package.json'));
+    const totalFiles = Math.max(sourceFiles.length, 1);
+    const testingCandidates = listFilesRecursively(targetPath).filter((filePath) => /\.(ts|tsx|js|jsx)$/.test(filePath) &&
+        !/\.test\.|\.spec\./.test(filePath) &&
+        !filePath.includes('node_modules'));
+    const withoutTests = testingCandidates.filter((filePath) => !hasNearbyTest(targetPath, filePath)).length;
+    const testing = testingCandidates.length === 0
+        ? 100
+        : clamp(100 - Math.round((withoutTests / testingCandidates.length) * 100), 0, 100);
+    const dimensions = {
+        architecture: qualityFromIssues(totalFiles, allIssues, ARCH_RULES),
+        complexity: qualityFromIssues(totalFiles, allIssues, COMPLEXITY_RULES),
+        'ai-patterns': qualityFromIssues(totalFiles, allIssues, AI_RULES),
+        testing,
+    };
+    const overall = Math.round((dimensions.architecture +
+        dimensions.complexity +
+        dimensions['ai-patterns'] +
+        dimensions.testing) / 4);
+    return { overall, dimensions };
+}
+export function computeMaintenanceRisk(report) {
+    const allFiles = report.files;
+    const hotspots = allFiles
+        .map((file) => {
+        const complexityIssues = file.issues.filter((issue) => issue.rule === 'high-complexity' ||
+            issue.rule === 'deep-nesting' ||
+            issue.rule === 'large-function' ||
+            issue.rule === 'max-function-lines').length;
+        const changeFrequency = getCommitTouchCount(report.targetPath, file.path);
+        const hasTests = hasNearbyTest(report.targetPath, file.path);
+        const reasons = [];
+        let risk = 0;
+        if (complexityIssues > 0) {
+            risk += Math.min(40, complexityIssues * 10);
+            reasons.push('high complexity signals');
+        }
+        if (!hasTests) {
+            risk += 25;
+            reasons.push('no nearby tests');
+        }
+        if (changeFrequency >= 8) {
+            risk += 20;
+            reasons.push('frequently changed file');
+        }
+        if (file.score >= 50) {
+            risk += 15;
+            reasons.push('high drift score');
+        }
+        return {
+            file: file.path,
+            driftScore: file.score,
+            complexityIssues,
+            hasNearbyTests: hasTests,
+            changeFrequency,
+            risk: clamp(risk, 0, 100),
+            reasons,
+        };
+    })
+        .filter((hotspot) => hotspot.risk > 0)
+        .sort((a, b) => b.risk - a.risk)
+        .slice(0, 10);
+    const highComplexityFiles = hotspots.filter((hotspot) => hotspot.complexityIssues > 0).length;
+    const filesWithoutNearbyTests = hotspots.filter((hotspot) => !hotspot.hasNearbyTests).length;
+    const frequentChangeFiles = hotspots.filter((hotspot) => hotspot.changeFrequency >= 8).length;
+    const score = hotspots.length === 0
+        ? 0
+        : Math.round(hotspots.reduce((sum, hotspot) => sum + hotspot.risk, 0) / hotspots.length);
+    const level = score >= 75
+        ? 'critical'
+        : score >= 55
+            ? 'high'
+            : score >= 30
+                ? 'medium'
+                : 'low';
+    return {
+        score,
+        level,
+        hotspots,
+        signals: {
+            highComplexityFiles,
+            filesWithoutNearbyTests,
+            frequentChangeFiles,
+        },
+    };
+}
+//# sourceMappingURL=metrics.js.map

package/dist/plugins.d.ts

@@ -0,0 +1,6 @@
+import type { PluginLoadError, LoadedPlugin } from './types.js';
+export declare function loadPlugins(projectRoot: string, pluginIds: string[] | undefined): {
+    plugins: LoadedPlugin[];
+    errors: PluginLoadError[];
+};
+//# sourceMappingURL=plugins.d.ts.map

package/dist/plugins.js

@@ -0,0 +1,74 @@
+import { existsSync } from 'node:fs';
+import { isAbsolute, resolve } from 'node:path';
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+function isPluginShape(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const candidate = value;
+    if (typeof candidate.name !== 'string')
+        return false;
+    if (!Array.isArray(candidate.rules))
+        return false;
+    return candidate.rules.every((rule) => rule &&
+        typeof rule === 'object' &&
+        typeof rule.name === 'string' &&
+        typeof rule.detect === 'function');
+}
+function normalizePluginExport(mod) {
+    if (isPluginShape(mod))
+        return mod;
+    if (mod && typeof mod === 'object' && 'default' in mod) {
+        const maybeDefault = mod.default;
+        if (isPluginShape(maybeDefault))
+            return maybeDefault;
+    }
+    return undefined;
+}
+function resolvePluginSpecifier(projectRoot, pluginId) {
+    if (pluginId.startsWith('.') || pluginId.startsWith('/')) {
+        const abs = isAbsolute(pluginId) ? pluginId : resolve(projectRoot, pluginId);
+        if (existsSync(abs))
+            return abs;
+        if (existsSync(`${abs}.js`))
+            return `${abs}.js`;
+        if (existsSync(`${abs}.cjs`))
+            return `${abs}.cjs`;
+        if (existsSync(`${abs}.mjs`))
+            return `${abs}.mjs`;
+        if (existsSync(`${abs}.ts`))
+            return `${abs}.ts`;
+        return abs;
+    }
+    return pluginId;
+}
+export function loadPlugins(projectRoot, pluginIds) {
+    if (!pluginIds || pluginIds.length === 0) {
+        return { plugins: [], errors: [] };
+    }
+    const loaded = [];
+    const errors = [];
+    for (const pluginId of pluginIds) {
+        const resolved = resolvePluginSpecifier(projectRoot, pluginId);
+        try {
+            const mod = require(resolved);
+            const plugin = normalizePluginExport(mod);
+            if (!plugin) {
+                errors.push({
+                    pluginId,
+                    message: `Invalid plugin contract in '${pluginId}'. Expected: { name, rules[] }`,
+                });
+                continue;
+            }
+            loaded.push({ id: pluginId, plugin });
+        }
+        catch (error) {
+            errors.push({
+                pluginId,
+                message: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    return { plugins: loaded, errors };
+}
+//# sourceMappingURL=plugins.js.map

package/dist/printer.js

@@ -111,6 +111,26 @@ function formatFixSuggestion(issue) {
             'Pick one naming convention (camelCase for variables/functions, PascalCase for types)',
             'Rename snake_case identifiers to camelCase to match TypeScript conventions',
         ],
+        'controller-no-db': [
+            'Move DB access to a service/repository and inject it into the controller',
+            'Keep controllers focused on transport and orchestration only',
+        ],
+        'service-no-http': [
+            'Move HTTP concerns to adapters/clients and keep services framework-agnostic',
+            'Inject interfaces for outbound calls instead of calling fetch/express directly',
+        ],
+        'max-function-lines': [
+            'Split the function into smaller units with clear responsibilities',
+            'Extract branch-heavy chunks into dedicated helpers',
+        ],
+        'ai-code-smell': [
+            'Address the listed AI-smell signals in this file before adding more code',
+            'Prioritize consistency: naming, error handling, and abstraction level',
+        ],
+        'plugin-error': [
+            'Fix or remove the failing plugin in drift.config.*',
+            'Validate plugin contract: export { name, rules[] } and detector functions',
+        ],
     };
     return suggestions[issue.rule] ?? ['Review and fix manually'];
 }

package/dist/report.js

@@ -638,6 +638,8 @@ export function generateHtmlReport(report) {
     const projColor = scoreColor(report.totalScore);
     const projLabel = scoreLabel(report.totalScore);
     const projGrade = scoreGrade(report.totalScore);
+    const quality = report.quality;
+    const risk = report.maintenanceRisk;
     const filesWithIssues = report.files.filter(f => f.issues.length > 0).length;
     // ── Top rules for sidebar ──────────────────────────────────────────────
     const topRules = Object.entries(report.summary.byRule)
@@ -648,6 +650,16 @@ export function generateHtmlReport(report) {
           <span class="rule-name">${escapeHtml(rule)}</span>
           <span class="rule-count">${count}</span>
         </button>`).join('');
+    const hotspotsHtml = risk.hotspots.length === 0
+        ? '<div class="empty-state" style="padding:0.8rem">No hotspots detected.</div>'
+        : risk.hotspots.slice(0, 5).map((hotspot) => `
+      <div class="issue-row" style="grid-template-columns: 62px 1fr;grid-template-rows:auto auto;">
+        <span class="issue-line">R${hotspot.risk}</span>
+        <div class="issue-rule-msg">
+          <span class="issue-rule">hotspot</span>
+          <span class="issue-msg">${escapeHtml(hotspot.file)} (${hotspot.reasons.join(', ')})</span>
+        </div>
+      </div>`).join('');
     // ── File sections ──────────────────────────────────────────────────────
     const fileSections = report.files
         .filter(f => f.issues.length > 0)
@@ -755,6 +767,21 @@ export function generateHtmlReport(report) {
           </div>
         </div>
 
+        <div class="sidebar-block">
+          <div class="sidebar-label">Repo Quality</div>
+          <div style="font-size:1.1rem;font-weight:700;color:${scoreColor(100 - quality.overall)}">${quality.overall}/100</div>
+          <div style="font-size:0.72rem;color:var(--muted)">Architecture ${quality.dimensions.architecture} · Complexity ${quality.dimensions.complexity}</div>
+          <div style="font-size:0.72rem;color:var(--muted)">AI patterns ${quality.dimensions['ai-patterns']} · Testing ${quality.dimensions.testing}</div>
+        </div>
+
+        <div class="sidebar-block">
+          <div class="sidebar-label">Maintenance Risk</div>
+          <div style="font-size:1.1rem;font-weight:700;color:${scoreColor(risk.score)}">${risk.score}/100 (${risk.level.toUpperCase()})</div>
+          <div style="font-size:0.72rem;color:var(--muted)">High complexity: ${risk.signals.highComplexityFiles}</div>
+          <div style="font-size:0.72rem;color:var(--muted)">No tests: ${risk.signals.filesWithoutNearbyTests}</div>
+          <div style="font-size:0.72rem;color:var(--muted)">Frequent changes: ${risk.signals.frequentChangeFiles}</div>
+        </div>
+
         <!-- Severity filters -->
         <div class="sidebar-block">
           <div class="sidebar-label">Severity</div>
@@ -804,6 +831,13 @@ export function generateHtmlReport(report) {
         <div class="main-header">
           <span id="issue-counter" style="color:var(--muted);font-size:0.75rem">Loading…</span>
         </div>
+        <section class="file-section" open>
+          <summary>
+            <span class="file-name">Risk hotspots</span>
+            <span class="file-score" style="color:${scoreColor(risk.score)}">${risk.score}/100</span>
+          </summary>
+          <div class="issues-list">${hotspotsHtml}</div>
+        </section>
         ${fileSections || noIssues}
       </main>
 

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