@rigour-labs/core 2.22.0 → 3.0.1

package/src/gates/context.ts

@@ -1,270 +0,0 @@
-import { Gate, GateContext } from './base.js';
-import { Failure, Gates } from '../types/index.js';
-import { FileScanner } from '../utils/scanner.js';
-import { Logger } from '../utils/logger.js';
-import fs from 'fs-extra';
-import path from 'path';
-
-/**
- * Extended Context Configuration (v2.14+)
- * For 1M token frontier models like Opus 4.6
- */
-export interface ExtendedContextConfig {
-    enabled?: boolean;
-    sensitivity?: number;
-    mining_depth?: number;
-    cross_file_patterns?: boolean;  // NEW: Enable cross-file pattern analysis
-    naming_consistency?: boolean;   // NEW: Check naming convention drift
-    import_relationships?: boolean; // NEW: Validate import patterns
-    max_cross_file_depth?: number;  // NEW: How many related files to analyze
-}
-
-export class ContextGate extends Gate {
-    private extendedConfig: ExtendedContextConfig;
-
-    constructor(private config: Gates) {
-        super('context-drift', 'Context Awareness & Drift Detection');
-        this.extendedConfig = {
-            enabled: config.context?.enabled ?? false,
-            sensitivity: config.context?.sensitivity ?? 0.8,
-            mining_depth: config.context?.mining_depth ?? 100,
-            cross_file_patterns: true,  // Default ON for frontier model support
-            naming_consistency: true,
-            import_relationships: true,
-            max_cross_file_depth: 50,
-        };
-    }
-
-    async run(context: GateContext): Promise<Failure[]> {
-        const failures: Failure[] = [];
-        const record = context.record;
-        if (!record || !this.extendedConfig.enabled) return [];
-
-        const files = await FileScanner.findFiles({ cwd: context.cwd });
-        const envAnchors = record.anchors.filter(a => a.type === 'env' && a.confidence >= 1);
-
-        // Collect all patterns across files for cross-file analysis
-        const namingPatterns: Map<string, { casing: string; file: string; count: number }[]> = new Map();
-        const importPatterns: Map<string, string[]> = new Map();
-
-        for (const file of files) {
-            try {
-                const content = await fs.readFile(path.join(context.cwd, file), 'utf-8');
-
-                // 1. Original: Detect Redundant Suffixes (The Golden Example)
-                this.checkEnvDrift(content, file, envAnchors, failures);
-
-                // 2. NEW: Cross-file pattern collection
-                if (this.extendedConfig.cross_file_patterns) {
-                    this.collectNamingPatterns(content, file, namingPatterns);
-                    this.collectImportPatterns(content, file, importPatterns);
-                }
-
-            } catch (e) { }
-        }
-
-        // 3. NEW: Analyze naming consistency across files
-        if (this.extendedConfig.naming_consistency) {
-            this.analyzeNamingConsistency(namingPatterns, failures);
-        }
-
-        // 4. NEW: Analyze import relationship patterns
-        if (this.extendedConfig.import_relationships) {
-            this.analyzeImportPatterns(importPatterns, failures);
-        }
-
-        return failures;
-    }
-
-    private checkEnvDrift(content: string, file: string, anchors: any[], failures: Failure[]) {
-        // Find all environment variable accesses in the content
-        const matches = content.matchAll(/process\.env(?:\.([A-Z0-9_]+)|\[['"]([A-Z0-9_]+)['"]\])/g);
-
-        for (const match of matches) {
-            const accessedVar = match[1] || match[2];
-
-            for (const anchor of anchors) {
-                // If the accessed variable contains the anchor but is not equal to it, 
-                // it's a potential "invented" redundancy (e.g. CORE_URL vs CORE_URL_PROD)
-                if (accessedVar !== anchor.id && accessedVar.includes(anchor.id)) {
-                    const deviation = accessedVar.replace(anchor.id, '').replace(/^_|_$/, '');
-
-                    failures.push(this.createFailure(
-                        `Context Drift: Redundant variation '${accessedVar}' detected in ${file}.`,
-                        [file],
-                        `The project already uses '${anchor.id}' as a standard anchor. Avoid inventing variations like '${deviation}'. Reuse the existing anchor or align with established project patterns.`,
-                        undefined, undefined, undefined, 'high'
-                    ));
-                }
-            }
-        }
-    }
-
-    /**
-     * Collect naming patterns (function names, class names, variable names)
-     */
-    private collectNamingPatterns(
-        content: string,
-        file: string,
-        patterns: Map<string, { casing: string; file: string; count: number }[]>
-    ) {
-        // Named function declarations: function fetchData() { ... }
-        const namedFuncMatches = content.matchAll(/function\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\(/g);
-        for (const match of namedFuncMatches) {
-            const casing = this.detectCasing(match[1]);
-            this.addPattern(patterns, 'function', { casing, file, count: 1 });
-        }
-
-        // Arrow function expressions: (export) const fetchData = (async) (...) => { ... }
-        const arrowFuncMatches = content.matchAll(/(?:export\s+)?(?:const|let|var)\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=\s*(?:async\s+)?(?:\([^)]*\)|[a-zA-Z_$][a-zA-Z0-9_$]*)\s*=>/g);
-        for (const match of arrowFuncMatches) {
-            const casing = this.detectCasing(match[1]);
-            this.addPattern(patterns, 'function', { casing, file, count: 1 });
-        }
-
-        // Function expressions: (export) const fetchData = (async) function(...) { ... }
-        const funcExprMatches = content.matchAll(/(?:export\s+)?(?:const|let|var)\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=\s*(?:async\s+)?function\s*\(/g);
-        for (const match of funcExprMatches) {
-            const casing = this.detectCasing(match[1]);
-            this.addPattern(patterns, 'function', { casing, file, count: 1 });
-        }
-
-        // Class declarations
-        const classMatches = content.matchAll(/class\s+([A-Za-z_$][A-Za-z0-9_$]*)/g);
-        for (const match of classMatches) {
-            const casing = this.detectCasing(match[1]);
-            this.addPattern(patterns, 'class', { casing, file, count: 1 });
-        }
-
-        // Interface declarations (TypeScript)
-        const interfaceMatches = content.matchAll(/interface\s+([A-Za-z_$][A-Za-z0-9_$]*)/g);
-        for (const match of interfaceMatches) {
-            const casing = this.detectCasing(match[1]);
-            this.addPattern(patterns, 'interface', { casing, file, count: 1 });
-        }
-    }
-
-    /**
-     * Collect import patterns
-     */
-    private collectImportPatterns(content: string, file: string, patterns: Map<string, string[]>) {
-        // ES6 imports
-        const importMatches = content.matchAll(/import\s+(?:{[^}]+}|\*\s+as\s+\w+|\w+)\s+from\s+['"]([^'"]+)['"]/g);
-        for (const match of importMatches) {
-            const importPath = match[1];
-            if (!patterns.has(file)) {
-                patterns.set(file, []);
-            }
-            patterns.get(file)!.push(importPath);
-        }
-    }
-
-    /**
-     * Analyze naming consistency across files
-     */
-    private analyzeNamingConsistency(
-        patterns: Map<string, { casing: string; file: string; count: number }[]>,
-        failures: Failure[]
-    ) {
-        for (const [type, entries] of patterns) {
-            const casingCounts = new Map<string, number>();
-            for (const entry of entries) {
-                casingCounts.set(entry.casing, (casingCounts.get(entry.casing) || 0) + entry.count);
-            }
-
-            // Find dominant casing
-            let dominant = '';
-            let maxCount = 0;
-            for (const [casing, count] of casingCounts) {
-                if (count > maxCount) {
-                    dominant = casing;
-                    maxCount = count;
-                }
-            }
-
-            // Report violations (non-dominant casing with significant usage)
-            const total = entries.reduce((sum, e) => sum + e.count, 0);
-            const threshold = total * (1 - (this.extendedConfig.sensitivity ?? 0.8));
-
-            for (const [casing, count] of casingCounts) {
-                if (casing !== dominant && count > threshold) {
-                    const violatingFiles = entries.filter(e => e.casing === casing).map(e => e.file);
-                    const uniqueFiles = [...new Set(violatingFiles)].slice(0, 5);
-
-                    failures.push(this.createFailure(
-                        `Cross-file naming inconsistency: ${type} names use ${casing} in ${count} places (dominant is ${dominant})`,
-                        uniqueFiles,
-                        `Standardize ${type} naming to ${dominant}. Found ${casing} in: ${uniqueFiles.join(', ')}`,
-                        'Naming Convention Drift',
-                        undefined, undefined, 'high'
-                    ));
-                }
-            }
-        }
-    }
-
-    /**
-     * Analyze import patterns for consistency
-     */
-    private analyzeImportPatterns(patterns: Map<string, string[]>, failures: Failure[]) {
-        // Check for mixed import styles (relative vs absolute)
-        const relativeCount = new Map<string, number>();
-        const absoluteCount = new Map<string, number>();
-
-        for (const [file, imports] of patterns) {
-            for (const imp of imports) {
-                if (imp.startsWith('.') || imp.startsWith('..')) {
-                    relativeCount.set(file, (relativeCount.get(file) || 0) + 1);
-                } else if (!imp.startsWith('@') && !imp.includes('/')) {
-                    // Skip external packages
-                } else {
-                    absoluteCount.set(file, (absoluteCount.get(file) || 0) + 1);
-                }
-            }
-        }
-
-        // Detect files with both relative AND absolute local imports
-        const mixedFiles: string[] = [];
-        for (const file of patterns.keys()) {
-            const hasRelative = (relativeCount.get(file) || 0) > 0;
-            const hasAbsolute = (absoluteCount.get(file) || 0) > 0;
-            if (hasRelative && hasAbsolute) {
-                mixedFiles.push(file);
-            }
-        }
-
-        if (mixedFiles.length > 3) {
-            failures.push(this.createFailure(
-                `Cross-file import inconsistency: ${mixedFiles.length} files mix relative and absolute imports`,
-                mixedFiles.slice(0, 5),
-                'Standardize import style across the codebase. Use either relative (./foo) or path aliases (@/foo) consistently.',
-                'Import Pattern Drift',
-                undefined, undefined, 'high'
-            ));
-        }
-    }
-
-    /**
-     * Detect casing convention of an identifier
-     */
-    private detectCasing(name: string): string {
-        if (/^[A-Z][a-z]/.test(name) && /[a-z][A-Z]/.test(name)) return 'PascalCase';
-        if (/^[a-z]/.test(name) && /[a-z][A-Z]/.test(name)) return 'camelCase';
-        if (/^[a-z][a-zA-Z0-9]*$/.test(name)) return 'camelCase';  // single-word lowercase (e.g. fetch, use, get)
-        if (/^[a-z]+(_[a-z]+)+$/.test(name)) return 'snake_case';
-        if (/^[A-Z]+(_[A-Z]+)*$/.test(name)) return 'SCREAMING_SNAKE';
-        if (/^[A-Z][a-zA-Z]*$/.test(name)) return 'PascalCase';
-        return 'unknown';
-    }
-
-    private addPattern(
-        patterns: Map<string, { casing: string; file: string; count: number }[]>,
-        type: string,
-        entry: { casing: string; file: string; count: number }
-    ) {
-        if (!patterns.has(type)) {
-            patterns.set(type, []);
-        }
-        patterns.get(type)!.push(entry);
-    }
-}

package/src/gates/coverage.ts

@@ -1,74 +0,0 @@
-import fs from 'fs-extra';
-import path from 'path';
-import { Gate, GateContext } from './base.js';
-import { Failure, Gates } from '../types/index.js';
-import { globby } from 'globby';
-
-export class CoverageGate extends Gate {
-    constructor(private config: Gates) {
-        super('coverage-guard', 'Dynamic Coverage Guard');
-    }
-
-    async run(context: GateContext): Promise<Failure[]> {
-        const failures: Failure[] = [];
-
-        // 1. Locate coverage report (lcov.info is standard)
-        const reports = await globby(['**/lcov.info', '**/coverage-final.json'], {
-            cwd: context.cwd,
-            ignore: ['node_modules/**']
-        });
-
-        if (reports.length === 0) {
-            // If no reports found, and coverage is required, we could flag it.
-            // But for now, we'll just skip silently if not configured.
-            return [];
-        }
-
-        // 2. Parse coverage (Simplified LCOV parser for demonstration)
-        const coverageData = await this.parseLcov(path.join(context.cwd, reports[0]));
-
-        // 3. Quality Handshake: SME SME LOGIC
-        // We look for files that have high complexity but low coverage.
-        // In a real implementation, we would share data between ASTGate and CoverageGate.
-        // For this demo, we'll implement a standalone check.
-
-        for (const [file, stats] of Object.entries(coverageData)) {
-            const coverage = (stats.hit / stats.found) * 100;
-            const threshold = stats.isComplex ? 80 : 50; // SME logic: Complex files need higher coverage
-
-            if (coverage < threshold) {
-                failures.push({
-                    id: 'DYNAMIC_COVERAGE_LOW',
-                    title: `Low coverage for high-risk file: ${file}`,
-                    details: `Current coverage: ${coverage.toFixed(2)}%. Required: ${threshold}% due to structural risk.`,
-                    files: [file],
-                    hint: `Add dynamic tests to cover complex logical branches in this file.`
-                });
-            }
-        }
-
-        return failures;
-    }
-
-    private async parseLcov(reportPath: string): Promise<Record<string, { found: number, hit: number, isComplex: boolean }>> {
-        const content = await fs.readFile(reportPath, 'utf-8');
-        const results: Record<string, { found: number, hit: number, isComplex: boolean }> = {};
-        let currentFile = '';
-
-        for (const line of content.split('\n')) {
-            if (line.startsWith('SF:')) {
-                currentFile = line.substring(3);
-                results[currentFile] = { found: 0, hit: 0, isComplex: false };
-            } else if (line.startsWith('LF:')) {
-                const found = parseInt(line.substring(3));
-                results[currentFile].found = found;
-                // SME Logic: If a file has > 100 logical lines, it's considered "Complex"
-                // and triggers the higher (80%) coverage requirement.
-                if (found > 100) results[currentFile].isComplex = true;
-            } else if (line.startsWith('LH:')) {
-                results[currentFile].hit = parseInt(line.substring(3));
-            }
-        }
-        return results;
-    }
-}

package/src/gates/dependency.ts

@@ -1,108 +0,0 @@
-import fs from 'fs-extra';
-import path from 'path';
-import { Failure, Config } from '../types/index.js';
-import { Gate, GateContext } from './base.js';
-
-export class DependencyGate extends Gate {
-    constructor(private config: Config) {
-        super('dependency-guardian', 'Dependency Guardian');
-    }
-
-    async run(context: GateContext): Promise<Failure[]> {
-        const failures: Failure[] = [];
-        const forbidden = this.config.gates.dependencies?.forbid || [];
-
-        if (forbidden.length === 0) return [];
-
-        const { cwd } = context;
-
-        // 1. Scan Node.js (package.json)
-        const pkgPath = path.join(cwd, 'package.json');
-        if (await fs.pathExists(pkgPath)) {
-            try {
-                const pkg = await fs.readJson(pkgPath);
-                const allDeps = {
-                    ...(pkg.dependencies || {}),
-                    ...(pkg.devDependencies || {}),
-                    ...(pkg.peerDependencies || {}),
-                };
-
-                for (const dep of forbidden) {
-                    if (allDeps[dep]) {
-                        failures.push(this.createFailure(
-                            `The package '${dep}' is forbidden by project standards.`,
-                            ['package.json'],
-                            `Remove '${dep}' from package.json and use approved alternatives.`,
-                            'Forbidden Dependency'
-                        ));
-                    }
-                }
-            } catch (e) { }
-        }
-
-        // 2. Scan Python (requirements.txt, pyproject.toml)
-        const reqPath = path.join(cwd, 'requirements.txt');
-        if (await fs.pathExists(reqPath)) {
-            const content = await fs.readFile(reqPath, 'utf-8');
-            for (const dep of forbidden) {
-                if (new RegExp(`^${dep}([=<>! ]|$)`, 'm').test(content)) {
-                    failures.push(this.createFailure(
-                        `The Python package '${dep}' is forbidden.`,
-                        ['requirements.txt'],
-                        `Remove '${dep}' from requirements.txt.`,
-                        'Forbidden Dependency'
-                    ));
-                }
-            }
-        }
-
-        const pyprojPath = path.join(cwd, 'pyproject.toml');
-        if (await fs.pathExists(pyprojPath)) {
-            const content = await fs.readFile(pyprojPath, 'utf-8');
-            for (const dep of forbidden) {
-                if (new RegExp(`^${dep}\\s*=`, 'm').test(content)) {
-                    failures.push(this.createFailure(
-                        `The Python package '${dep}' is forbidden in pyproject.toml.`,
-                        ['pyproject.toml'],
-                        `Remove '${dep}' from pyproject.toml dependencies.`,
-                        'Forbidden Dependency'
-                    ));
-                }
-            }
-        }
-
-        // 3. Scan Go (go.mod)
-        const goModPath = path.join(cwd, 'go.mod');
-        if (await fs.pathExists(goModPath)) {
-            const content = await fs.readFile(goModPath, 'utf-8');
-            for (const dep of forbidden) {
-                if (content.includes(dep)) {
-                    failures.push(this.createFailure(
-                        `The Go module '${dep}' is forbidden.`,
-                        ['go.mod'],
-                        `Remove '${dep}' from go.mod.`,
-                        'Forbidden Dependency'
-                    ));
-                }
-            }
-        }
-
-        // 4. Scan Java (pom.xml)
-        const pomPath = path.join(cwd, 'pom.xml');
-        if (await fs.pathExists(pomPath)) {
-            const content = await fs.readFile(pomPath, 'utf-8');
-            for (const dep of forbidden) {
-                if (content.includes(`<artifactId>${dep}</artifactId>`)) {
-                    failures.push(this.createFailure(
-                        `The Java artifact '${dep}' is forbidden.`,
-                        ['pom.xml'],
-                        `Remove '${dep}' from pom.xml.`,
-                        'Forbidden Dependency'
-                    ));
-                }
-            }
-        }
-
-        return failures;
-    }
-}

package/src/gates/duplication-drift.ts

@@ -1,231 +0,0 @@
-/**
- * Duplication Drift Gate
- *
- * Detects when AI generates near-identical functions across files because
- * it doesn't remember what it already wrote. This is an AI-specific failure
- * mode — humans reuse via copy-paste (same file), AI re-invents (cross-file).
- *
- * Detection strategy:
- * 1. Extract all function bodies (normalized: strip whitespace, comments)
- * 2. Compare function signatures + body hashes across files
- * 3. Flag functions with >80% similarity in different files
- *
- * @since v2.16.0
- */
-
-import { Gate, GateContext } from './base.js';
-import { Failure } from '../types/index.js';
-import { FileScanner } from '../utils/scanner.js';
-import { Logger } from '../utils/logger.js';
-import crypto from 'crypto';
-import path from 'path';
-
-interface FunctionSignature {
-    name: string;
-    file: string;
-    line: number;
-    paramCount: number;
-    bodyHash: string;
-    bodyLength: number;
-    normalized: string;
-}
-
-export interface DuplicationDriftConfig {
-    enabled?: boolean;
-    similarity_threshold?: number; // 0-1, default 0.8
-    min_body_lines?: number;       // Ignore trivial functions, default 5
-}
-
-export class DuplicationDriftGate extends Gate {
-    private config: Required<DuplicationDriftConfig>;
-
-    constructor(config: DuplicationDriftConfig = {}) {
-        super('duplication-drift', 'AI Duplication Drift Detection');
-        this.config = {
-            enabled: config.enabled ?? true,
-            similarity_threshold: config.similarity_threshold ?? 0.8,
-            min_body_lines: config.min_body_lines ?? 5,
-        };
-    }
-
-    async run(context: GateContext): Promise<Failure[]> {
-        if (!this.config.enabled) return [];
-
-        const failures: Failure[] = [];
-        const functions: FunctionSignature[] = [];
-
-        const files = await FileScanner.findFiles({
-            cwd: context.cwd,
-            patterns: ['**/*.{ts,js,tsx,jsx,py}'],
-            ignore: [...(context.ignore || []), '**/node_modules/**', '**/dist/**', '**/*.test.*', '**/*.spec.*'],
-        });
-
-        Logger.info(`Duplication Drift: Scanning ${files.length} files`);
-
-        for (const file of files) {
-            try {
-                const { readFile } = await import('fs-extra');
-                const content = await readFile(path.join(context.cwd, file), 'utf-8');
-                const ext = path.extname(file);
-
-                if (['.ts', '.js', '.tsx', '.jsx'].includes(ext)) {
-                    this.extractJSFunctions(content, file, functions);
-                } else if (ext === '.py') {
-                    this.extractPyFunctions(content, file, functions);
-                }
-            } catch (e) { }
-        }
-
-        // Compare all function pairs across different files
-        const duplicateGroups = this.findDuplicateGroups(functions);
-
-        for (const group of duplicateGroups) {
-            const files = group.map(f => f.file);
-            const locations = group.map(f => `${f.file}:${f.line} (${f.name})`).join(', ');
-
-            failures.push(this.createFailure(
-                `AI Duplication Drift: Function '${group[0].name}' has ${group.length} near-identical copies across files`,
-                [...new Set(files)],
-                `Found duplicate implementations at: ${locations}. Extract to a shared module and import.`,
-                'Duplication Drift',
-                group[0].line,
-                undefined,
-                'high'
-            ));
-        }
-
-        return failures;
-    }
-
-    private extractJSFunctions(content: string, file: string, functions: FunctionSignature[]) {
-        const lines = content.split('\n');
-
-        // Match function declarations, arrow functions, and method definitions
-        const patterns = [
-            // function name(...) {
-            /^(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\(([^)]*)\)/,
-            // const name = (...) => {
-            /^(?:export\s+)?(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?(?:\([^)]*\)|(\w+))\s*=>/,
-            // name(...) { — class method
-            /^\s+(?:async\s+)?(\w+)\s*\(([^)]*)\)\s*\{/,
-        ];
-
-        for (let i = 0; i < lines.length; i++) {
-            const line = lines[i];
-            for (const pattern of patterns) {
-                const match = line.match(pattern);
-                if (match) {
-                    const name = match[1];
-                    const params = match[2] || '';
-                    const body = this.extractFunctionBody(lines, i);
-
-                    if (body.length >= this.config.min_body_lines) {
-                        const normalized = this.normalizeBody(body.join('\n'));
-                        functions.push({
-                            name,
-                            file,
-                            line: i + 1,
-                            paramCount: params ? params.split(',').length : 0,
-                            bodyHash: this.hash(normalized),
-                            bodyLength: body.length,
-                            normalized,
-                        });
-                    }
-                    break;
-                }
-            }
-        }
-    }
-
-    private extractPyFunctions(content: string, file: string, functions: FunctionSignature[]) {
-        const lines = content.split('\n');
-
-        for (let i = 0; i < lines.length; i++) {
-            const match = lines[i].match(/^(?:\s*)(?:async\s+)?def\s+(\w+)\s*\(([^)]*)\)/);
-            if (match) {
-                const name = match[1];
-                const params = match[2] || '';
-                const indent = lines[i].match(/^(\s*)/)?.[1]?.length || 0;
-
-                // Extract body by indentation
-                const body: string[] = [];
-                for (let j = i + 1; j < lines.length; j++) {
-                    const lineIndent = lines[j].match(/^(\s*)/)?.[1]?.length || 0;
-                    if (lines[j].trim() === '' || lineIndent > indent) {
-                        body.push(lines[j]);
-                    } else {
-                        break;
-                    }
-                }
-
-                if (body.length >= this.config.min_body_lines) {
-                    const normalized = this.normalizeBody(body.join('\n'));
-                    functions.push({
-                        name,
-                        file,
-                        line: i + 1,
-                        paramCount: params ? params.split(',').length : 0,
-                        bodyHash: this.hash(normalized),
-                        bodyLength: body.length,
-                        normalized,
-                    });
-                }
-            }
-        }
-    }
-
-    private extractFunctionBody(lines: string[], startIndex: number): string[] {
-        let braceDepth = 0;
-        let started = false;
-        const body: string[] = [];
-
-        for (let i = startIndex; i < lines.length; i++) {
-            const line = lines[i];
-            for (const ch of line) {
-                if (ch === '{') { braceDepth++; started = true; }
-                if (ch === '}') braceDepth--;
-            }
-            if (started) body.push(line);
-            if (started && braceDepth === 0) break;
-        }
-
-        return body;
-    }
-
-    private normalizeBody(body: string): string {
-        return body
-            .replace(/\/\/.*/g, '')           // strip single-line comments
-            .replace(/\/\*[\s\S]*?\*\//g, '') // strip multi-line comments
-            .replace(/#.*/g, '')              // strip Python comments
-            .replace(/\s+/g, ' ')            // collapse whitespace
-            .replace(/['"`]/g, '"')          // normalize quotes
-            .trim();
-    }
-
-    private hash(text: string): string {
-        return crypto.createHash('md5').update(text).digest('hex');
-    }
-
-    private findDuplicateGroups(functions: FunctionSignature[]): FunctionSignature[][] {
-        const groups = new Map<string, FunctionSignature[]>();
-
-        // Group by body hash (exact duplicates across files)
-        for (const fn of functions) {
-            const existing = groups.get(fn.bodyHash) || [];
-            existing.push(fn);
-            groups.set(fn.bodyHash, existing);
-        }
-
-        // Filter: only groups with functions from DIFFERENT files, 2+ members
-        const duplicates: FunctionSignature[][] = [];
-        for (const group of groups.values()) {
-            if (group.length < 2) continue;
-            const uniqueFiles = new Set(group.map(f => f.file));
-            if (uniqueFiles.size >= 2) {
-                duplicates.push(group);
-            }
-        }
-
-        return duplicates;
-    }
-}