nexusforge-cli 1.1.1 → 1.2.1

package/dist/modules/projectScanner.js

@@ -0,0 +1,859 @@
+/**
+ * Project Scanner for NexusForge CLI
+ * Analyzes project structure, dependencies, and content
+ * Ported from Python nexusforge/modules/project/scanner.py
+ *
+ * Now with optional native Rust acceleration (10-20x faster)
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as native from '../native/index.js';
+// ============================================================================
+// PROJECT SCANNER CLASS
+// ============================================================================
+export class ProjectScanner {
+    projectPath;
+    useCache;
+    cacheDir;
+    cacheFile;
+    files = new Map();
+    dependencies = {};
+    technologies = new Set();
+    stats;
+    // File extensions to language mapping
+    static LANGUAGE_MAP = {
+        // Python
+        '.py': 'python',
+        '.pyx': 'python',
+        '.pyi': 'python',
+        // JavaScript/TypeScript
+        '.js': 'javascript',
+        '.jsx': 'javascript',
+        '.ts': 'typescript',
+        '.tsx': 'typescript',
+        '.mjs': 'javascript',
+        '.cjs': 'javascript',
+        // Web
+        '.html': 'html',
+        '.htm': 'html',
+        '.css': 'css',
+        '.scss': 'scss',
+        '.sass': 'sass',
+        '.less': 'less',
+        '.vue': 'vue',
+        '.svelte': 'svelte',
+        // Systems
+        '.rs': 'rust',
+        '.go': 'go',
+        '.c': 'c',
+        '.cpp': 'cpp',
+        '.cc': 'cpp',
+        '.cxx': 'cpp',
+        '.h': 'c',
+        '.hpp': 'cpp',
+        '.hxx': 'cpp',
+        // JVM
+        '.java': 'java',
+        '.kt': 'kotlin',
+        '.kts': 'kotlin',
+        '.scala': 'scala',
+        '.groovy': 'groovy',
+        // .NET
+        '.cs': 'csharp',
+        '.fs': 'fsharp',
+        '.vb': 'vb',
+        // Other
+        '.rb': 'ruby',
+        '.php': 'php',
+        '.swift': 'swift',
+        '.r': 'r',
+        '.m': 'objective-c',
+        '.jl': 'julia',
+        '.sh': 'bash',
+        '.bash': 'bash',
+        '.zsh': 'zsh',
+        '.fish': 'fish',
+        '.ps1': 'powershell',
+        '.sql': 'sql',
+        '.lua': 'lua',
+        '.pl': 'perl',
+        '.ex': 'elixir',
+        '.exs': 'elixir',
+        '.erl': 'erlang',
+        '.hrl': 'erlang',
+        '.dart': 'dart',
+    };
+    // Directories to always ignore
+    static IGNORE_DIRS = new Set([
+        '.git', '.svn', '.hg', '.bzr',
+        '__pycache__', '.pytest_cache', '.mypy_cache',
+        'node_modules', 'bower_components',
+        '.nexusforge', '.vscode', '.idea',
+        'venv', 'env', '.env', 'virtualenv',
+        'dist', 'build', 'target', 'out',
+        '.next', '.nuxt', '.cache',
+        'coverage', '.nyc_output',
+        'vendor', 'packages',
+    ]);
+    constructor(projectPath, useCache = true) {
+        this.projectPath = path.resolve(projectPath);
+        this.useCache = useCache;
+        this.cacheDir = path.join(this.projectPath, '.nexusforge');
+        this.cacheFile = path.join(this.cacheDir, 'project_scan.cache.json');
+        // Ensure cache directory exists
+        if (!fs.existsSync(this.cacheDir)) {
+            try {
+                fs.mkdirSync(this.cacheDir, { recursive: true });
+            }
+            catch {
+                // Ignore errors
+            }
+        }
+        this.stats = {
+            filesScanned: 0,
+            filesSkipped: 0,
+            totalSize: 0,
+            scanErrors: 0,
+            cacheEnabled: useCache,
+        };
+    }
+    // ========================================================================
+    // CACHING
+    // ========================================================================
+    loadCache() {
+        if (!this.useCache || !fs.existsSync(this.cacheFile)) {
+            return null;
+        }
+        try {
+            const data = JSON.parse(fs.readFileSync(this.cacheFile, 'utf-8'));
+            // Check if cache is less than 1 hour old
+            const cacheAge = Date.now() - (data.scanTime || 0);
+            if (cacheAge < 3600000) {
+                return data;
+            }
+        }
+        catch {
+            // Ignore errors
+        }
+        return null;
+    }
+    saveCache(result) {
+        if (!this.useCache)
+            return;
+        try {
+            fs.writeFileSync(this.cacheFile, JSON.stringify(result, null, 2));
+        }
+        catch {
+            // Ignore errors
+        }
+    }
+    // ========================================================================
+    // SCANNING
+    // ========================================================================
+    /**
+     * Scan using native Rust module (10-20x faster)
+     * Returns null if native module not available
+     */
+    scanNative() {
+        const nativeResult = native.scanDirectory({
+            root: this.projectPath,
+            extractImports: true,
+            extractSymbols: true,
+            computeHashes: false,
+        });
+        if (!nativeResult) {
+            return null;
+        }
+        // Convert native result to our format
+        for (const file of nativeResult.files) {
+            const relPath = file.relativePath;
+            const lang = file.language?.toLowerCase() || 'unknown';
+            this.files.set(relPath, {
+                path: file.path,
+                language: lang,
+                size: file.size,
+                lines: file.lineCount,
+                imports: file.imports,
+                functions: file.functions,
+                classes: file.classes,
+                complexity: 0,
+                lastModified: null,
+            });
+        }
+        this.stats.filesScanned = nativeResult.stats.totalFiles;
+        this.stats.totalSize = nativeResult.stats.totalSize;
+        // Build language stats
+        const languages = {};
+        for (const [lang, count] of Object.entries(nativeResult.stats.filesByLanguage)) {
+            languages[lang.toLowerCase()] = count;
+        }
+        return {
+            projectPath: this.projectPath,
+            fileCount: nativeResult.stats.totalFiles,
+            totalLines: nativeResult.stats.totalLines,
+            totalSize: nativeResult.stats.totalSize,
+            languages,
+            technologies: [], // Will be filled by detectTechnologies
+            dependencies: {},
+            structure: {},
+            entryPoints: [],
+            configFiles: [],
+            testFiles: [],
+            scanTime: Date.now(),
+            scanDuration: nativeResult.stats.scanDurationMs / 1000,
+        };
+    }
+    scan() {
+        const startTime = Date.now();
+        // Check cache
+        const cached = this.loadCache();
+        if (cached) {
+            return cached;
+        }
+        // Try native scan first (10-20x faster)
+        let nativeResult = null;
+        if (native.isNativeAvailable()) {
+            nativeResult = this.scanNative();
+        }
+        if (nativeResult) {
+            // Native scan succeeded, complete with additional analysis
+            this.detectTechnologies();
+            this.analyzeDependencies();
+            const result = {
+                ...nativeResult,
+                technologies: Array.from(this.technologies),
+                dependencies: this.dependencies,
+                structure: this.getDirectoryStructure(),
+                entryPoints: this.findEntryPoints(),
+                configFiles: this.findConfigFiles(),
+                testFiles: this.findTestFiles(),
+                scanDuration: (Date.now() - startTime) / 1000,
+            };
+            this.saveCache(result);
+            return result;
+        }
+        // Fallback to TypeScript scan
+        this.scanFiles();
+        this.detectTechnologies();
+        this.analyzeDependencies();
+        // Create result
+        const result = {
+            projectPath: this.projectPath,
+            fileCount: this.files.size,
+            totalLines: Array.from(this.files.values()).reduce((sum, f) => sum + f.lines, 0),
+            totalSize: this.stats.totalSize,
+            languages: this.getLanguageStats(),
+            technologies: Array.from(this.technologies),
+            dependencies: this.dependencies,
+            structure: this.getDirectoryStructure(),
+            entryPoints: this.findEntryPoints(),
+            configFiles: this.findConfigFiles(),
+            testFiles: this.findTestFiles(),
+            scanTime: Date.now(),
+            scanDuration: (Date.now() - startTime) / 1000,
+        };
+        // Save cache
+        this.saveCache(result);
+        return result;
+    }
+    quickScan() {
+        let fileCount = 0;
+        const techHints = new Set();
+        const languages = new Set();
+        const scan = (dir) => {
+            try {
+                const entries = fs.readdirSync(dir, { withFileTypes: true });
+                for (const entry of entries) {
+                    const fullPath = path.join(dir, entry.name);
+                    if (entry.isDirectory()) {
+                        if (!this.shouldIgnore(fullPath)) {
+                            scan(fullPath);
+                        }
+                    }
+                    else {
+                        const ext = path.extname(entry.name).toLowerCase();
+                        if (ProjectScanner.LANGUAGE_MAP[ext]) {
+                            fileCount++;
+                            languages.add(ProjectScanner.LANGUAGE_MAP[ext]);
+                        }
+                        this.quickDetectTech(entry.name, techHints);
+                    }
+                }
+            }
+            catch {
+                // Ignore errors
+            }
+        };
+        scan(this.projectPath);
+        return {
+            projectPath: this.projectPath,
+            fileCount,
+            languages: Array.from(languages),
+            technologies: Array.from(techHints),
+            quickScan: true,
+        };
+    }
+    quickDetectTech(filename, techHints) {
+        const techFiles = {
+            'package.json': 'nodejs',
+            'yarn.lock': 'yarn',
+            'pnpm-lock.yaml': 'pnpm',
+            'Cargo.toml': 'rust',
+            'requirements.txt': 'python',
+            'Pipfile': 'pipenv',
+            'pyproject.toml': 'python',
+            'go.mod': 'go',
+            'pom.xml': 'maven',
+            'build.gradle': 'gradle',
+            'Dockerfile': 'docker',
+        };
+        if (techFiles[filename]) {
+            techHints.add(techFiles[filename]);
+        }
+    }
+    shouldIgnore(filepath) {
+        const parts = filepath.split(path.sep);
+        for (const part of parts) {
+            if (ProjectScanner.IGNORE_DIRS.has(part)) {
+                return true;
+            }
+        }
+        const basename = path.basename(filepath);
+        if (basename.startsWith('.') && !['.gitignore', '.env', '.env.example', '.dockerignore'].includes(basename)) {
+            return true;
+        }
+        return false;
+    }
+    scanFiles() {
+        const scan = (dir) => {
+            try {
+                const entries = fs.readdirSync(dir, { withFileTypes: true });
+                for (const entry of entries) {
+                    const fullPath = path.join(dir, entry.name);
+                    if (entry.isDirectory()) {
+                        if (!this.shouldIgnore(fullPath)) {
+                            scan(fullPath);
+                        }
+                    }
+                    else {
+                        const ext = path.extname(entry.name).toLowerCase();
+                        if (ProjectScanner.LANGUAGE_MAP[ext]) {
+                            this.scanFile(fullPath);
+                        }
+                    }
+                }
+            }
+            catch {
+                // Ignore errors
+            }
+        };
+        scan(this.projectPath);
+    }
+    scanFile(filePath) {
+        try {
+            const stat = fs.statSync(filePath);
+            // Skip very large files (>10MB)
+            if (stat.size > 10 * 1024 * 1024) {
+                this.stats.filesSkipped++;
+                return;
+            }
+            const relPath = path.relative(this.projectPath, filePath);
+            const ext = path.extname(filePath).toLowerCase();
+            const language = ProjectScanner.LANGUAGE_MAP[ext] || 'unknown';
+            const fileInfo = {
+                path: filePath,
+                language,
+                size: stat.size,
+                lines: this.countLines(filePath),
+                imports: this.extractImports(filePath, language),
+                functions: this.extractFunctions(filePath, language),
+                classes: this.extractClasses(filePath, language),
+                complexity: 0,
+                lastModified: stat.mtimeMs,
+            };
+            this.files.set(relPath, fileInfo);
+            this.stats.filesScanned++;
+            this.stats.totalSize += stat.size;
+        }
+        catch {
+            this.stats.filesSkipped++;
+        }
+    }
+    // ========================================================================
+    // FILE ANALYSIS
+    // ========================================================================
+    countLines(filePath) {
+        try {
+            const content = fs.readFileSync(filePath, 'utf-8');
+            return content.split('\n').length;
+        }
+        catch {
+            return 0;
+        }
+    }
+    extractImports(filePath, language) {
+        const imports = [];
+        try {
+            const content = fs.readFileSync(filePath, 'utf-8');
+            if (language === 'python') {
+                const importPattern = /^(?:from\s+(\S+)|import\s+(\S+))/gm;
+                let match;
+                while ((match = importPattern.exec(content)) !== null) {
+                    imports.push((match[1] || match[2]).split('.')[0]);
+                }
+            }
+            else if (language === 'javascript' || language === 'typescript') {
+                // ES6 imports
+                const es6Pattern = /import\s+.*?\s+from\s+['"](.+?)['"]/g;
+                let match;
+                while ((match = es6Pattern.exec(content)) !== null) {
+                    imports.push(match[1]);
+                }
+                // CommonJS requires
+                const cjsPattern = /require\s*\(\s*['"](.+?)['"]\s*\)/g;
+                while ((match = cjsPattern.exec(content)) !== null) {
+                    imports.push(match[1]);
+                }
+            }
+            else if (language === 'rust') {
+                const usePattern = /use\s+(\w+(?:::\w+)*)/g;
+                let match;
+                while ((match = usePattern.exec(content)) !== null) {
+                    imports.push(match[1]);
+                }
+            }
+            else if (language === 'go') {
+                const singlePattern = /import\s+"([^"]+)"/g;
+                let match;
+                while ((match = singlePattern.exec(content)) !== null) {
+                    imports.push(match[1]);
+                }
+                const multiPattern = /import\s*\(([\s\S]*?)\)/g;
+                while ((match = multiPattern.exec(content)) !== null) {
+                    const pkgPattern = /"([^"]+)"/g;
+                    let pkgMatch;
+                    while ((pkgMatch = pkgPattern.exec(match[1])) !== null) {
+                        imports.push(pkgMatch[1]);
+                    }
+                }
+            }
+        }
+        catch {
+            // Ignore errors
+        }
+        return imports;
+    }
+    extractFunctions(filePath, language) {
+        const functions = [];
+        try {
+            const content = fs.readFileSync(filePath, 'utf-8');
+            if (language === 'python') {
+                const funcPattern = /^def\s+(\w+)\s*\(/gm;
+                let match;
+                while ((match = funcPattern.exec(content)) !== null) {
+                    functions.push(match[1]);
+                }
+            }
+            else if (language === 'javascript' || language === 'typescript') {
+                // Function declarations
+                const funcPattern = /function\s+(\w+)\s*\(/g;
+                let match;
+                while ((match = funcPattern.exec(content)) !== null) {
+                    functions.push(match[1]);
+                }
+                // Arrow functions
+                const arrowPattern = /const\s+(\w+)\s*=\s*(?:\([^)]*\)|[^=])\s*=>/g;
+                while ((match = arrowPattern.exec(content)) !== null) {
+                    functions.push(match[1]);
+                }
+            }
+            else if (language === 'rust') {
+                const fnPattern = /fn\s+(\w+)\s*[<(]/g;
+                let match;
+                while ((match = fnPattern.exec(content)) !== null) {
+                    functions.push(match[1]);
+                }
+            }
+        }
+        catch {
+            // Ignore errors
+        }
+        return functions;
+    }
+    extractClasses(filePath, language) {
+        const classes = [];
+        try {
+            const content = fs.readFileSync(filePath, 'utf-8');
+            if (language === 'python') {
+                const classPattern = /^class\s+(\w+)/gm;
+                let match;
+                while ((match = classPattern.exec(content)) !== null) {
+                    classes.push(match[1]);
+                }
+            }
+            else if (language === 'javascript' || language === 'typescript') {
+                const classPattern = /class\s+(\w+)/g;
+                let match;
+                while ((match = classPattern.exec(content)) !== null) {
+                    classes.push(match[1]);
+                }
+            }
+            else if (language === 'rust') {
+                const structPattern = /struct\s+(\w+)/g;
+                const enumPattern = /enum\s+(\w+)/g;
+                let match;
+                while ((match = structPattern.exec(content)) !== null) {
+                    classes.push(match[1]);
+                }
+                while ((match = enumPattern.exec(content)) !== null) {
+                    classes.push(match[1]);
+                }
+            }
+        }
+        catch {
+            // Ignore errors
+        }
+        return classes;
+    }
+    // ========================================================================
+    // TECHNOLOGY DETECTION
+    // ========================================================================
+    detectTechnologies() {
+        const configFiles = {
+            'package.json': ['nodejs', 'npm'],
+            'yarn.lock': ['yarn'],
+            'pnpm-lock.yaml': ['pnpm'],
+            'Cargo.toml': ['rust', 'cargo'],
+            'requirements.txt': ['python'],
+            'Pipfile': ['python', 'pipenv'],
+            'poetry.lock': ['python', 'poetry'],
+            'pyproject.toml': ['python'],
+            'go.mod': ['go'],
+            'pom.xml': ['java', 'maven'],
+            'build.gradle': ['java', 'gradle'],
+            'build.gradle.kts': ['kotlin', 'gradle'],
+            'composer.json': ['php', 'composer'],
+            'Gemfile': ['ruby', 'bundler'],
+            'Dockerfile': ['docker'],
+            'docker-compose.yml': ['docker', 'docker-compose'],
+            'docker-compose.yaml': ['docker', 'docker-compose'],
+            'kubernetes.yaml': ['kubernetes'],
+            'k8s.yaml': ['kubernetes'],
+            'terraform.tf': ['terraform'],
+            'Jenkinsfile': ['jenkins'],
+            '.gitlab-ci.yml': ['gitlab-ci'],
+            '.travis.yml': ['travis-ci'],
+            'azure-pipelines.yml': ['azure-pipelines'],
+        };
+        for (const [configFile, techs] of Object.entries(configFiles)) {
+            if (fs.existsSync(path.join(this.projectPath, configFile))) {
+                for (const tech of techs) {
+                    this.technologies.add(tech);
+                }
+            }
+        }
+        // Check for GitHub Actions
+        if (fs.existsSync(path.join(this.projectPath, '.github', 'workflows'))) {
+            this.technologies.add('github-actions');
+        }
+        // Check package.json for frameworks
+        this.detectNpmFrameworks();
+        // Check for Python frameworks
+        this.detectPythonFrameworks();
+    }
+    detectNpmFrameworks() {
+        const pkgJsonPath = path.join(this.projectPath, 'package.json');
+        if (!fs.existsSync(pkgJsonPath))
+            return;
+        try {
+            const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf-8'));
+            const deps = {
+                ...pkg.dependencies,
+                ...pkg.devDependencies,
+            };
+            const frameworkMap = {
+                'react': 'react',
+                'vue': 'vue',
+                '@angular/core': 'angular',
+                'svelte': 'svelte',
+                'next': 'nextjs',
+                'nuxt': 'nuxt',
+                'gatsby': 'gatsby',
+                'express': 'express',
+                'fastify': 'fastify',
+                'koa': 'koa',
+                '@nestjs/core': 'nestjs',
+                'electron': 'electron',
+                '@tauri-apps/api': 'tauri',
+                'vite': 'vite',
+                'webpack': 'webpack',
+                'typescript': 'typescript',
+                'jest': 'jest',
+                'vitest': 'vitest',
+                'cypress': 'cypress',
+                'playwright': 'playwright',
+            };
+            for (const [dep, tech] of Object.entries(frameworkMap)) {
+                if (dep in deps) {
+                    this.technologies.add(tech);
+                }
+            }
+        }
+        catch {
+            // Ignore errors
+        }
+    }
+    detectPythonFrameworks() {
+        if (!this.technologies.has('python'))
+            return;
+        const frameworkImports = {
+            'django': 'django',
+            'flask': 'flask',
+            'fastapi': 'fastapi',
+            'tornado': 'tornado',
+            'pyramid': 'pyramid',
+            'bottle': 'bottle',
+            'pytest': 'pytest',
+            'unittest': 'unittest',
+        };
+        for (const fileInfo of this.files.values()) {
+            if (fileInfo.language === 'python') {
+                for (const imp of fileInfo.imports) {
+                    const baseImp = imp.split('.')[0];
+                    if (frameworkImports[baseImp]) {
+                        this.technologies.add(frameworkImports[baseImp]);
+                    }
+                }
+            }
+        }
+    }
+    // ========================================================================
+    // DEPENDENCY ANALYSIS
+    // ========================================================================
+    analyzeDependencies() {
+        // Python dependencies
+        for (const file of ['requirements.txt', 'Pipfile', 'pyproject.toml']) {
+            const filePath = path.join(this.projectPath, file);
+            if (fs.existsSync(filePath)) {
+                this.dependencies['python'] = this.parsePythonDeps(filePath);
+                break;
+            }
+        }
+        // Node dependencies
+        const pkgJson = path.join(this.projectPath, 'package.json');
+        if (fs.existsSync(pkgJson)) {
+            this.dependencies['npm'] = this.parseNpmDeps(pkgJson);
+        }
+        // Rust dependencies
+        const cargoToml = path.join(this.projectPath, 'Cargo.toml');
+        if (fs.existsSync(cargoToml)) {
+            this.dependencies['cargo'] = this.parseCargoDeps(cargoToml);
+        }
+        // Go dependencies
+        const goMod = path.join(this.projectPath, 'go.mod');
+        if (fs.existsSync(goMod)) {
+            this.dependencies['go'] = this.parseGoDeps(goMod);
+        }
+    }
+    parsePythonDeps(filePath) {
+        const deps = [];
+        if (filePath.endsWith('requirements.txt')) {
+            try {
+                const content = fs.readFileSync(filePath, 'utf-8');
+                for (const line of content.split('\n')) {
+                    const trimmed = line.trim();
+                    if (trimmed && !trimmed.startsWith('#')) {
+                        const pkg = trimmed.split('==')[0].split('>=')[0].split('~=')[0].trim();
+                        deps.push(pkg);
+                    }
+                }
+            }
+            catch {
+                // Ignore errors
+            }
+        }
+        else if (filePath.endsWith('pyproject.toml')) {
+            try {
+                const content = fs.readFileSync(filePath, 'utf-8');
+                // Simple parsing for dependencies
+                const depMatch = content.match(/dependencies\s*=\s*\[([\s\S]*?)\]/);
+                if (depMatch) {
+                    const pkgPattern = /"([^">=<~!]+)/g;
+                    let match;
+                    while ((match = pkgPattern.exec(depMatch[1])) !== null) {
+                        deps.push(match[1].trim());
+                    }
+                }
+            }
+            catch {
+                // Ignore errors
+            }
+        }
+        return deps;
+    }
+    parseNpmDeps(filePath) {
+        try {
+            const pkg = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+            return Object.keys({
+                ...pkg.dependencies,
+                ...pkg.devDependencies,
+            });
+        }
+        catch {
+            return [];
+        }
+    }
+    parseCargoDeps(filePath) {
+        try {
+            const content = fs.readFileSync(filePath, 'utf-8');
+            const deps = [];
+            const depSection = content.match(/\[dependencies\]([\s\S]*?)(?:\[|$)/);
+            if (depSection) {
+                const lines = depSection[1].split('\n');
+                for (const line of lines) {
+                    const match = line.match(/^(\w+)\s*=/);
+                    if (match) {
+                        deps.push(match[1]);
+                    }
+                }
+            }
+            return deps;
+        }
+        catch {
+            return [];
+        }
+    }
+    parseGoDeps(filePath) {
+        const deps = [];
+        try {
+            const content = fs.readFileSync(filePath, 'utf-8');
+            const requirePattern = /require\s+([^\s]+)/g;
+            let match;
+            while ((match = requirePattern.exec(content)) !== null) {
+                deps.push(match[1]);
+            }
+        }
+        catch {
+            // Ignore errors
+        }
+        return deps;
+    }
+    // ========================================================================
+    // PROJECT STRUCTURE
+    // ========================================================================
+    getDirectoryStructure() {
+        const structure = {};
+        for (const filePath of this.files.keys()) {
+            const parts = filePath.split(path.sep);
+            let current = structure;
+            for (let i = 0; i < parts.length - 1; i++) {
+                if (!(parts[i] in current)) {
+                    current[parts[i]] = {};
+                }
+                current = current[parts[i]];
+            }
+            current[parts[parts.length - 1]] = 'file';
+        }
+        return structure;
+    }
+    findEntryPoints() {
+        const entryPoints = [];
+        const commonEntries = new Set([
+            'main.py', 'app.py', 'index.py', '__main__.py', 'run.py', 'wsgi.py',
+            'index.js', 'app.js', 'main.js', 'server.js', 'index.ts', 'main.ts',
+            'main.rs', 'lib.rs',
+            'main.go',
+            'Main.java', 'Application.java',
+            'Program.cs',
+            'index.html', 'index.php',
+        ]);
+        for (const filePath of this.files.keys()) {
+            const fileName = path.basename(filePath);
+            if (commonEntries.has(fileName)) {
+                entryPoints.push(filePath);
+            }
+        }
+        return entryPoints;
+    }
+    findConfigFiles() {
+        const configFiles = [];
+        const configPatterns = [
+            'config', 'settings', '.env', 'environment',
+            'package.json', 'tsconfig.json', 'webpack.config',
+            'Cargo.toml', 'pom.xml', 'build.gradle',
+            'requirements.txt', 'setup.py', 'pyproject.toml',
+            'docker-compose', 'Dockerfile', '.gitignore',
+            '.eslintrc', '.prettierrc', 'babel.config',
+        ];
+        for (const filePath of this.files.keys()) {
+            const fileName = path.basename(filePath).toLowerCase();
+            if (configPatterns.some(pattern => fileName.includes(pattern))) {
+                configFiles.push(filePath);
+            }
+        }
+        return configFiles;
+    }
+    findTestFiles() {
+        const testFiles = [];
+        const testPatterns = ['test', 'spec', '_test', '.test.', '.spec.', '__test__'];
+        const testDirs = ['test', 'tests', '__tests__'];
+        for (const filePath of this.files.keys()) {
+            const fileName = path.basename(filePath).toLowerCase();
+            const fileDir = path.dirname(filePath).toLowerCase();
+            if (testPatterns.some(pattern => fileName.includes(pattern))) {
+                testFiles.push(filePath);
+            }
+            else if (testDirs.some(pattern => fileDir.includes(pattern))) {
+                testFiles.push(filePath);
+            }
+        }
+        return testFiles;
+    }
+    // ========================================================================
+    // STATISTICS
+    // ========================================================================
+    getLanguageStats() {
+        const stats = {};
+        for (const fileInfo of this.files.values()) {
+            stats[fileInfo.language] = (stats[fileInfo.language] || 0) + 1;
+        }
+        return stats;
+    }
+    getProjectStatus() {
+        if (this.files.size === 0) {
+            this.scan();
+        }
+        const langStats = this.getLanguageStats();
+        const mainLanguage = Object.entries(langStats).sort((a, b) => b[1] - a[1])[0]?.[0] || 'unknown';
+        return {
+            totalFiles: this.files.size,
+            languages: Object.keys(langStats),
+            mainLanguage,
+            hasTests: Array.from(this.files.keys()).some(f => f.toLowerCase().includes('test')),
+            hasCi: ['github-actions', 'jenkins', 'gitlab-ci', 'travis-ci'].some(ci => this.technologies.has(ci)),
+            hasDocker: this.technologies.has('docker'),
+            isGitRepo: fs.existsSync(path.join(this.projectPath, '.git')),
+            technologies: Array.from(this.technologies),
+        };
+    }
+    getStatistics() {
+        return this.stats;
+    }
+    getFiles() {
+        return this.files;
+    }
+}
+// ============================================================================
+// SINGLETON INSTANCE
+// ============================================================================
+let scannerInstance = null;
+export function getProjectScanner(projectPath) {
+    if (!scannerInstance || (projectPath && scannerInstance['projectPath'] !== path.resolve(projectPath))) {
+        scannerInstance = new ProjectScanner(projectPath || process.cwd());
+    }
+    return scannerInstance;
+}
+export function resetProjectScanner() {
+    scannerInstance = null;
+}
+//# sourceMappingURL=projectScanner.js.map