nexusforge-cli 1.1.1 → 1.2.1

package/dist/modules/domainDetector.js

@@ -0,0 +1,722 @@
+/**
+ * Domain Detector for NexusForge CLI
+ * Automatically identifies project type and loads relevant context
+ * Ported from Python nexusforge/modules/knowledge/domain_detector.py
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+// ============================================================================
+// ENUMERATIONS
+// ============================================================================
+export var Domain;
+(function (Domain) {
+    Domain["AI_ML"] = "ai_ml";
+    Domain["WEB_FRONTEND"] = "web_frontend";
+    Domain["WEB_BACKEND"] = "web_backend";
+    Domain["WEB_FULLSTACK"] = "web_fullstack";
+    Domain["RUST_NATIVE"] = "rust_native";
+    Domain["TAURI_DESKTOP"] = "tauri_desktop";
+    Domain["HVAC_CONTROLS"] = "hvac_controls";
+    Domain["ARC_AGI"] = "arc_agi";
+    Domain["DATABASE"] = "database";
+    Domain["EMBEDDED"] = "embedded";
+    Domain["DEVOPS"] = "devops";
+    Domain["MOBILE"] = "mobile";
+    Domain["GAME_DEV"] = "game_dev";
+    Domain["DATA_SCIENCE"] = "data_science";
+    Domain["BLOCKCHAIN"] = "blockchain";
+    Domain["IOT"] = "iot";
+    Domain["SECURITY"] = "security";
+    Domain["CLOUD"] = "cloud";
+    Domain["API"] = "api";
+    Domain["CLI"] = "cli";
+})(Domain || (Domain = {}));
+// ============================================================================
+// DOMAIN DETECTOR CLASS
+// ============================================================================
+export class DomainDetector {
+    detectedDomains = [];
+    confidenceScores = new Map();
+    evidence = new Map();
+    projectPath = '';
+    // ========================================================================
+    // FILE PATTERNS
+    // ========================================================================
+    static FILE_PATTERNS = [
+        // AI/ML
+        { patterns: ['*.ipynb', 'model*.py', 'train*.py', 'dataset*.py'], domain: Domain.AI_ML },
+        { patterns: ['requirements-ml.txt', 'environment.yml', '*.h5', '*.pth'], domain: Domain.AI_ML },
+        { patterns: ['*.onnx', '*.tflite', '*.pb'], domain: Domain.AI_ML },
+        // Web Frontend
+        { patterns: ['package.json', '*.jsx', '*.tsx', '*.vue', '*.svelte'], domain: Domain.WEB_FRONTEND },
+        { patterns: ['index.html', '*.css', '*.scss', 'vite.config.*', 'next.config.*'], domain: Domain.WEB_FRONTEND },
+        { patterns: ['webpack.config.*', 'tsconfig.json', 'tailwind.config.*'], domain: Domain.WEB_FRONTEND },
+        // Web Backend
+        { patterns: ['server.py', 'app.py', 'main.py', 'wsgi.py'], domain: Domain.WEB_BACKEND },
+        { patterns: ['views.py'], domain: Domain.WEB_BACKEND },
+        // Fullstack
+        { patterns: ['next.config.*', 'remix.config.*', 'astro.config.*'], domain: Domain.WEB_FULLSTACK },
+        // Rust
+        { patterns: ['Cargo.toml', '*.rs', 'Cargo.lock'], domain: Domain.RUST_NATIVE },
+        { patterns: ['tauri.conf.json'], domain: Domain.TAURI_DESKTOP },
+        // HVAC
+        { patterns: ['*bacnet*', '*modbus*', '*hvac*', '*pid*'], domain: Domain.HVAC_CONTROLS },
+        { patterns: ['*AHU*', '*VAV*'], domain: Domain.HVAC_CONTROLS },
+        // ARC-AGI
+        { patterns: ['arc_*.py', 'grid*.py', 'task*.json'], domain: Domain.ARC_AGI },
+        // Database
+        { patterns: ['*.sql', 'schema.*', '*.prisma'], domain: Domain.DATABASE },
+        // Embedded
+        { patterns: ['*.ino', 'platformio.ini', 'Arduino*', 'esp*'], domain: Domain.EMBEDDED },
+        { patterns: ['*.hex', '*.bin'], domain: Domain.EMBEDDED },
+        // DevOps
+        { patterns: ['Dockerfile', 'docker-compose*.yml', '.dockerignore'], domain: Domain.DEVOPS },
+        { patterns: ['Jenkinsfile', '.gitlab-ci.yml'], domain: Domain.DEVOPS },
+        // Mobile
+        { patterns: ['*.swift', '*.kt', 'AndroidManifest.xml'], domain: Domain.MOBILE },
+        { patterns: ['pubspec.yaml'], domain: Domain.MOBILE },
+        // Game Development
+        { patterns: ['*.unity', '*.godot', '*.gd', 'project.godot'], domain: Domain.GAME_DEV },
+        { patterns: ['*.tscn'], domain: Domain.GAME_DEV },
+        // Blockchain
+        { patterns: ['*.sol', 'truffle.js', 'hardhat.config.js', 'foundry.toml'], domain: Domain.BLOCKCHAIN },
+        // IoT
+        { patterns: ['*mqtt*', '*sensor*', '*device*', '*telemetry*'], domain: Domain.IOT },
+        { patterns: ['*sequent*', '*i2c*', '*gpio*', '*spi*', '*uart*'], domain: Domain.IOT },
+        // Security
+        { patterns: ['*.cert', '*.key', '.env*'], domain: Domain.SECURITY },
+        // Cloud
+        { patterns: ['serverless.yml', 'sam.yaml'], domain: Domain.CLOUD },
+        // API
+        { patterns: ['openapi.yaml', 'swagger.json', 'api.yaml'], domain: Domain.API },
+        { patterns: ['*.graphql', 'schema.graphql'], domain: Domain.API },
+        // CLI
+        { patterns: ['cli.py', '__main__.py'], domain: Domain.CLI },
+    ];
+    // ========================================================================
+    // MAIN DETECTION
+    // ========================================================================
+    detectDomains(projectPath, minConfidence = 0.3) {
+        this.projectPath = projectPath;
+        this.detectedDomains = [];
+        this.confidenceScores = new Map();
+        this.evidence = new Map();
+        // Run all detection methods
+        this.detectByFiles();
+        this.detectByDependencies();
+        this.detectByImports();
+        this.detectByKeywords();
+        this.detectByStructure();
+        this.detectByConfigFiles();
+        // Sort by confidence
+        const sortedDomains = Array.from(this.confidenceScores.entries())
+            .sort((a, b) => b[1] - a[1]);
+        // Create results with evidence
+        const results = [];
+        for (const [domain, score] of sortedDomains) {
+            if (score >= minConfidence) {
+                results.push({
+                    domain,
+                    confidence: score,
+                    evidence: this.evidence.get(domain) || [],
+                });
+            }
+        }
+        return results;
+    }
+    // ========================================================================
+    // FILE-BASED DETECTION
+    // ========================================================================
+    detectByFiles() {
+        for (const { patterns, domain } of DomainDetector.FILE_PATTERNS) {
+            let matched = false;
+            for (const pattern of patterns) {
+                if (this.hasFiles(pattern)) {
+                    matched = true;
+                    this.addEvidence(domain, `Found file pattern: ${pattern}`);
+                }
+            }
+            if (matched) {
+                this.addConfidence(domain, 0.3);
+            }
+        }
+    }
+    // ========================================================================
+    // DEPENDENCY-BASED DETECTION
+    // ========================================================================
+    detectByDependencies() {
+        // Python dependencies
+        const pythonDeps = this.getPythonDependencies();
+        if (pythonDeps.size > 0) {
+            const depDomains = [
+                // AI/ML
+                { deps: ['torch', 'tensorflow', 'keras', 'jax', 'flax'], domain: Domain.AI_ML },
+                { deps: ['scikit-learn', 'pandas', 'numpy', 'matplotlib', 'seaborn'], domain: Domain.DATA_SCIENCE },
+                { deps: ['transformers', 'datasets', 'tokenizers', 'accelerate'], domain: Domain.AI_ML },
+                { deps: ['opencv-python', 'pillow', 'torchvision', 'albumentations'], domain: Domain.AI_ML },
+                // Web Backend
+                { deps: ['django', 'flask', 'fastapi', 'aiohttp', 'sanic'], domain: Domain.WEB_BACKEND },
+                { deps: ['uvicorn', 'gunicorn', 'celery', 'redis'], domain: Domain.WEB_BACKEND },
+                // HVAC
+                { deps: ['pymodbus', 'bacpypes', 'bacpypes3', 'paho-mqtt'], domain: Domain.HVAC_CONTROLS },
+                // Database
+                { deps: ['sqlalchemy', 'psycopg2', 'pymongo', 'asyncpg'], domain: Domain.DATABASE },
+                { deps: ['alembic', 'peewee', 'tortoise-orm', 'prisma'], domain: Domain.DATABASE },
+                // IoT
+                { deps: ['paho-mqtt', 'adafruit-circuitpython', 'blynk', 'awsiot'], domain: Domain.IOT },
+                { deps: ['smbus2', 'spidev', 'RPi.GPIO', 'pyserial', 'smbus'], domain: Domain.IOT },
+                // Security
+                { deps: ['cryptography', 'pyjwt', 'passlib', 'bcrypt', 'argon2'], domain: Domain.SECURITY },
+                // Cloud
+                { deps: ['boto3', 'azure-functions', 'google-cloud', 'pulumi'], domain: Domain.CLOUD },
+                // CLI
+                { deps: ['click', 'typer', 'argparse', 'rich', 'questionary'], domain: Domain.CLI },
+            ];
+            for (const { deps, domain } of depDomains) {
+                const matchedDeps = deps.filter(dep => pythonDeps.has(dep));
+                if (matchedDeps.length > 0) {
+                    this.addConfidence(domain, 0.4);
+                    this.addEvidence(domain, `Python deps: ${matchedDeps.slice(0, 3).join(', ')}`);
+                }
+            }
+        }
+        // Node dependencies
+        const nodeDeps = this.getNodeDependencies();
+        if (nodeDeps.size > 0) {
+            const depDomains = [
+                // Web Frontend
+                { deps: ['react', 'vue', '@angular/core', 'svelte', 'solid-js'], domain: Domain.WEB_FRONTEND },
+                { deps: ['next', 'nuxt', 'gatsby', 'astro', 'remix'], domain: Domain.WEB_FULLSTACK },
+                { deps: ['@tanstack/react-query', 'zustand', 'jotai', 'valtio'], domain: Domain.WEB_FRONTEND },
+                // Web Backend
+                { deps: ['express', 'fastify', 'koa', '@nestjs/core', 'hono'], domain: Domain.WEB_BACKEND },
+                // Mobile
+                { deps: ['react-native', 'expo', '@ionic/react', 'capacitor'], domain: Domain.MOBILE },
+                // Desktop
+                { deps: ['electron', '@tauri-apps/api', '@tauri-apps/cli'], domain: Domain.TAURI_DESKTOP },
+                // Blockchain
+                { deps: ['web3', 'ethers', 'viem', 'hardhat', 'foundry'], domain: Domain.BLOCKCHAIN },
+                // DevOps
+                { deps: ['docker', 'kubernetes', 'terraform', 'pulumi'], domain: Domain.DEVOPS },
+            ];
+            for (const { deps, domain } of depDomains) {
+                const matchedDeps = deps.filter(dep => nodeDeps.has(dep));
+                if (matchedDeps.length > 0) {
+                    this.addConfidence(domain, 0.4);
+                    this.addEvidence(domain, `Node deps: ${matchedDeps.slice(0, 3).join(', ')}`);
+                }
+            }
+        }
+        // Rust dependencies
+        const rustDeps = this.getRustDependencies();
+        if (rustDeps.has('tauri')) {
+            this.addConfidence(Domain.TAURI_DESKTOP, 0.8);
+            this.addEvidence(Domain.TAURI_DESKTOP, 'Cargo.toml includes tauri');
+        }
+        const asyncDeps = new Set(['tokio', 'async-std', 'actix-web', 'axum', 'warp']);
+        const hasAsyncDeps = [...asyncDeps].some(dep => rustDeps.has(dep));
+        if (hasAsyncDeps) {
+            this.addConfidence(Domain.RUST_NATIVE, 0.4);
+            this.addEvidence(Domain.RUST_NATIVE, 'Async Rust dependencies');
+        }
+        const embeddedDeps = new Set(['embedded-hal', 'cortex-m', 'esp-hal', 'rp-hal']);
+        const hasEmbeddedDeps = [...embeddedDeps].some(dep => rustDeps.has(dep));
+        if (hasEmbeddedDeps) {
+            this.addConfidence(Domain.EMBEDDED, 0.6);
+            this.addEvidence(Domain.EMBEDDED, 'Embedded Rust dependencies');
+        }
+    }
+    // ========================================================================
+    // IMPORT AND KEYWORD DETECTION
+    // ========================================================================
+    detectByImports() {
+        const imports = this.scanImports();
+        const importPatterns = [
+            // AI/ML
+            { patterns: ['torch', 'tensorflow', 'keras', 'sklearn', 'jax'], domain: Domain.AI_ML },
+            { patterns: ['cv2', 'PIL', 'torchvision', 'transformers'], domain: Domain.AI_ML },
+            // Web
+            { patterns: ['flask', 'django', 'fastapi', 'aiohttp'], domain: Domain.WEB_BACKEND },
+            { patterns: ['react', 'vue', '@angular', 'svelte'], domain: Domain.WEB_FRONTEND },
+            // HVAC
+            { patterns: ['modbus', 'bacnet', 'bacpypes', 'mqtt'], domain: Domain.HVAC_CONTROLS },
+            // Database
+            { patterns: ['sqlalchemy', 'pymongo', 'redis', 'psycopg2'], domain: Domain.DATABASE },
+            // IoT
+            { patterns: ['paho.mqtt', 'awsiot', 'azure.iot', 'smbus'], domain: Domain.IOT },
+            { patterns: ['RPi.GPIO', 'adafruit', 'blynk', 'serial'], domain: Domain.IOT },
+            // Security
+            { patterns: ['cryptography', 'jwt', 'passlib', 'bcrypt'], domain: Domain.SECURITY },
+        ];
+        for (const { patterns, domain } of importPatterns) {
+            const matchingImports = [...imports].filter(imp => patterns.some(p => imp.includes(p)));
+            if (matchingImports.length > 0) {
+                const count = matchingImports.length;
+                this.addConfidence(domain, Math.min(0.1 * count, 0.5));
+                this.addEvidence(domain, `Imports: ${matchingImports.slice(0, 3).join(', ')}`);
+            }
+        }
+    }
+    detectByKeywords() {
+        const keywords = {
+            [Domain.AI_ML]: [
+                'model', 'train', 'epoch', 'batch', 'loss', 'accuracy',
+                'neural', 'network', 'dataset', 'tensor', 'gradient',
+                'optimizer', 'forward', 'backward', 'inference',
+            ],
+            [Domain.HVAC_CONTROLS]: [
+                'temperature', 'setpoint', 'sensor', 'actuator', 'pid',
+                'vav', 'ahu', 'rtu', 'chiller', 'boiler', 'damper', 'valve',
+                'cfm', 'economizer', 'enthalpy', 'humidity',
+            ],
+            [Domain.ARC_AGI]: [
+                'grid', 'pattern', 'transformation', 'symmetry', 'rotation',
+                'task', 'puzzle', 'abstract', 'reasoning', 'arc',
+            ],
+            [Domain.DATABASE]: [
+                'query', 'table', 'schema', 'migration', 'index', 'join',
+                'transaction', 'cursor', 'connection', 'orm',
+            ],
+            [Domain.BLOCKCHAIN]: [
+                'contract', 'blockchain', 'transaction', 'wallet', 'mining',
+                'consensus', 'hash', 'block', 'chain', 'solidity', 'ethereum',
+            ],
+            [Domain.GAME_DEV]: [
+                'sprite', 'collision', 'physics', 'render', 'scene',
+                'player', 'enemy', 'level', 'score', 'game', 'unity',
+            ],
+            [Domain.IOT]: [
+                'sensor', 'device', 'mqtt', 'telemetry', 'gpio', 'i2c',
+                'relay', 'actuator', 'embedded', 'arduino', 'raspberry',
+                'sequent', 'modbus', 'edge', 'gateway', 'protocol', 'firmware',
+            ],
+            [Domain.SECURITY]: [
+                'auth', 'token', 'encrypt', 'decrypt', 'hash', 'salt',
+                'jwt', 'oauth', 'security', 'permission', 'rbac',
+            ],
+            [Domain.DEVOPS]: [
+                'deploy', 'container', 'kubernetes', 'docker', 'ci/cd',
+                'pipeline', 'terraform', 'ansible', 'helm', 'infrastructure',
+            ],
+            [Domain.WEB_FRONTEND]: [],
+            [Domain.WEB_BACKEND]: [],
+            [Domain.WEB_FULLSTACK]: [],
+            [Domain.RUST_NATIVE]: [],
+            [Domain.TAURI_DESKTOP]: [],
+            [Domain.EMBEDDED]: [],
+            [Domain.MOBILE]: [],
+            [Domain.DATA_SCIENCE]: [],
+            [Domain.CLOUD]: [],
+            [Domain.API]: [],
+            [Domain.CLI]: [],
+        };
+        for (const [domain, domainKeywords] of Object.entries(keywords)) {
+            if (domainKeywords.length === 0)
+                continue;
+            const keywordCount = this.countKeywords(domainKeywords);
+            if (keywordCount > 10) {
+                const confidence = Math.min(keywordCount / 100, 0.5);
+                this.addConfidence(domain, confidence);
+                this.addEvidence(domain, `Found ${keywordCount} domain keywords`);
+            }
+        }
+    }
+    // ========================================================================
+    // STRUCTURE AND CONFIG DETECTION
+    // ========================================================================
+    detectByStructure() {
+        const structurePatterns = {
+            [Domain.WEB_FRONTEND]: ['src/components', 'src/pages', 'public', 'src/styles'],
+            [Domain.WEB_BACKEND]: ['routes', 'controllers', 'models', 'middleware', 'api'],
+            [Domain.WEB_FULLSTACK]: ['app', 'pages', 'api', 'components'],
+            [Domain.AI_ML]: ['notebooks', 'models', 'data', 'experiments', 'checkpoints'],
+            [Domain.HVAC_CONTROLS]: ['sequences', 'points', 'graphics', 'alarms', 'controllers'],
+            [Domain.MOBILE]: ['ios', 'android', 'lib', 'assets'],
+            [Domain.GAME_DEV]: ['assets', 'scenes', 'scripts', 'prefabs', 'resources'],
+            [Domain.IOT]: ['devices', 'sensors', 'mqtt', 'telemetry', 'hardware', 'firmware'],
+            [Domain.DEVOPS]: ['kubernetes', 'terraform', 'ansible', 'helm', 'docker'],
+            [Domain.API]: ['api', 'routes', 'endpoints', 'schemas'],
+            [Domain.RUST_NATIVE]: [],
+            [Domain.TAURI_DESKTOP]: [],
+            [Domain.ARC_AGI]: [],
+            [Domain.DATABASE]: [],
+            [Domain.EMBEDDED]: [],
+            [Domain.DATA_SCIENCE]: [],
+            [Domain.BLOCKCHAIN]: [],
+            [Domain.SECURITY]: [],
+            [Domain.CLOUD]: [],
+            [Domain.CLI]: [],
+        };
+        for (const [domain, patterns] of Object.entries(structurePatterns)) {
+            if (patterns.length === 0)
+                continue;
+            const matches = patterns.filter(p => fs.existsSync(path.join(this.projectPath, p)));
+            if (matches.length >= 2) {
+                const confidence = 0.3 * (matches.length / patterns.length);
+                this.addConfidence(domain, confidence);
+                this.addEvidence(domain, `Project structure: ${matches.slice(0, 3).join(', ')}`);
+            }
+        }
+    }
+    detectByConfigFiles() {
+        const configPatterns = {
+            [Domain.WEB_FRONTEND]: [
+                'vite.config.ts', 'webpack.config.js', 'next.config.js',
+                'tailwind.config.js', 'postcss.config.js',
+            ],
+            [Domain.WEB_BACKEND]: [
+                'wsgi.py', 'asgi.py', 'uvicorn.py', 'gunicorn.conf.py',
+            ],
+            [Domain.RUST_NATIVE]: ['Cargo.toml', 'rust-toolchain.toml'],
+            [Domain.TAURI_DESKTOP]: ['tauri.conf.json', 'src-tauri/tauri.conf.json'],
+            [Domain.MOBILE]: ['AndroidManifest.xml', 'Info.plist', 'expo.json'],
+            [Domain.DEVOPS]: ['Dockerfile', 'docker-compose.yml', 'k8s.yaml'],
+            [Domain.DATABASE]: ['prisma/schema.prisma', 'alembic.ini'],
+            [Domain.IOT]: ['platformio.ini', 'esphome.yaml', 'mqtt.conf'],
+            [Domain.WEB_FULLSTACK]: [],
+            [Domain.AI_ML]: [],
+            [Domain.HVAC_CONTROLS]: [],
+            [Domain.ARC_AGI]: [],
+            [Domain.EMBEDDED]: [],
+            [Domain.DATA_SCIENCE]: [],
+            [Domain.GAME_DEV]: [],
+            [Domain.BLOCKCHAIN]: [],
+            [Domain.SECURITY]: [],
+            [Domain.CLOUD]: [],
+            [Domain.API]: [],
+            [Domain.CLI]: [],
+        };
+        for (const [domain, configs] of Object.entries(configPatterns)) {
+            if (configs.length === 0)
+                continue;
+            const foundConfigs = configs.filter(config => fs.existsSync(path.join(this.projectPath, config)));
+            if (foundConfigs.length > 0) {
+                this.addConfidence(domain, 0.4);
+                this.addEvidence(domain, `Config files: ${foundConfigs.slice(0, 2).join(', ')}`);
+            }
+        }
+    }
+    // ========================================================================
+    // HELPER METHODS
+    // ========================================================================
+    hasFiles(pattern) {
+        if (pattern.includes('*')) {
+            // Simple glob matching
+            const files = this.findFiles(pattern);
+            return files.length > 0;
+        }
+        return fs.existsSync(path.join(this.projectPath, pattern));
+    }
+    findFiles(pattern, maxDepth = 3) {
+        const results = [];
+        const regex = this.patternToRegex(pattern);
+        const scan = (dir, depth) => {
+            if (depth > maxDepth)
+                return;
+            try {
+                const entries = fs.readdirSync(dir, { withFileTypes: true });
+                for (const entry of entries) {
+                    const fullPath = path.join(dir, entry.name);
+                    const relativePath = path.relative(this.projectPath, fullPath);
+                    if (entry.isDirectory()) {
+                        if (!this.shouldIgnoreDir(entry.name)) {
+                            scan(fullPath, depth + 1);
+                        }
+                    }
+                    else if (regex.test(relativePath) || regex.test(entry.name)) {
+                        results.push(relativePath);
+                    }
+                }
+            }
+            catch {
+                // Ignore errors
+            }
+        };
+        scan(this.projectPath, 0);
+        return results;
+    }
+    patternToRegex(pattern) {
+        const escaped = pattern
+            .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+            .replace(/\*/g, '.*')
+            .replace(/\?/g, '.');
+        return new RegExp(escaped, 'i');
+    }
+    shouldIgnoreDir(name) {
+        const ignoreDirs = new Set([
+            '.git', 'node_modules', '__pycache__', '.nexusforge',
+            'venv', 'env', 'dist', 'build', 'target', '.next',
+            'coverage', '.pytest_cache', '.mypy_cache',
+        ]);
+        return ignoreDirs.has(name) || name.startsWith('.');
+    }
+    addConfidence(domain, score) {
+        const current = this.confidenceScores.get(domain) || 0;
+        this.confidenceScores.set(domain, Math.min(current + score, 1.0));
+    }
+    addEvidence(domain, evidenceItem) {
+        const current = this.evidence.get(domain) || [];
+        current.push(evidenceItem);
+        this.evidence.set(domain, current);
+    }
+    getPythonDependencies() {
+        const deps = new Set();
+        // requirements.txt
+        const reqFile = path.join(this.projectPath, 'requirements.txt');
+        if (fs.existsSync(reqFile)) {
+            try {
+                const content = fs.readFileSync(reqFile, 'utf-8');
+                for (const line of content.split('\n')) {
+                    if (line && !line.startsWith('#')) {
+                        const pkg = line.split('==')[0].split('>=')[0].split('~=')[0].split('[')[0].trim();
+                        deps.add(pkg.toLowerCase());
+                    }
+                }
+            }
+            catch {
+                // Ignore errors
+            }
+        }
+        // pyproject.toml (basic parsing)
+        const pyproject = path.join(this.projectPath, 'pyproject.toml');
+        if (fs.existsSync(pyproject)) {
+            try {
+                const content = fs.readFileSync(pyproject, 'utf-8');
+                // Simple regex to extract dependencies
+                const depMatches = content.match(/dependencies\s*=\s*\[([\s\S]*?)\]/);
+                if (depMatches) {
+                    const depsStr = depMatches[1];
+                    const pkgPattern = /"([^">=<~!]+)/g;
+                    let match;
+                    while ((match = pkgPattern.exec(depsStr)) !== null) {
+                        deps.add(match[1].toLowerCase().trim());
+                    }
+                }
+            }
+            catch {
+                // Ignore errors
+            }
+        }
+        return deps;
+    }
+    getNodeDependencies() {
+        const deps = new Set();
+        const pkgJson = path.join(this.projectPath, 'package.json');
+        if (fs.existsSync(pkgJson)) {
+            try {
+                const content = JSON.parse(fs.readFileSync(pkgJson, 'utf-8'));
+                const allDeps = {
+                    ...content.dependencies,
+                    ...content.devDependencies,
+                };
+                for (const dep of Object.keys(allDeps)) {
+                    deps.add(dep);
+                }
+            }
+            catch {
+                // Ignore errors
+            }
+        }
+        return deps;
+    }
+    getRustDependencies() {
+        const deps = new Set();
+        const cargoToml = path.join(this.projectPath, 'Cargo.toml');
+        if (fs.existsSync(cargoToml)) {
+            try {
+                const content = fs.readFileSync(cargoToml, 'utf-8');
+                // Simple regex to extract dependencies
+                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.add(match[1]);
+                        }
+                    }
+                }
+            }
+            catch {
+                // Ignore errors
+            }
+        }
+        return deps;
+    }
+    scanImports() {
+        const imports = new Set();
+        let filesScanned = 0;
+        const maxFiles = 100;
+        const scan = (dir) => {
+            if (filesScanned >= maxFiles)
+                return;
+            try {
+                const entries = fs.readdirSync(dir, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (filesScanned >= maxFiles)
+                        break;
+                    const fullPath = path.join(dir, entry.name);
+                    if (entry.isDirectory()) {
+                        if (!this.shouldIgnoreDir(entry.name)) {
+                            scan(fullPath);
+                        }
+                    }
+                    else if (entry.name.endsWith('.py')) {
+                        try {
+                            const content = fs.readFileSync(fullPath, 'utf-8');
+                            const importPattern = /^(?:from\s+(\S+)|import\s+(\S+))/gm;
+                            let match;
+                            while ((match = importPattern.exec(content)) !== null) {
+                                const imp = (match[1] || match[2]).split('.')[0];
+                                imports.add(imp);
+                            }
+                            filesScanned++;
+                        }
+                        catch {
+                            // Ignore errors
+                        }
+                    }
+                    else if (/\.[jt]sx?$/.test(entry.name)) {
+                        try {
+                            const content = fs.readFileSync(fullPath, 'utf-8');
+                            const importPattern = /import\s+.*?\s+from\s+['"](.+?)['"]/g;
+                            let match;
+                            while ((match = importPattern.exec(content)) !== null) {
+                                const imp = match[1].split('/')[0].replace('@', '');
+                                imports.add(imp);
+                            }
+                            filesScanned++;
+                        }
+                        catch {
+                            // Ignore errors
+                        }
+                    }
+                }
+            }
+            catch {
+                // Ignore errors
+            }
+        };
+        scan(this.projectPath);
+        return imports;
+    }
+    countKeywords(keywords) {
+        let count = 0;
+        let filesChecked = 0;
+        const maxFiles = 50;
+        const extensions = new Set(['.py', '.js', '.ts', '.rs', '.go', '.java', '.tsx', '.jsx']);
+        const scan = (dir) => {
+            if (filesChecked >= maxFiles)
+                return;
+            try {
+                const entries = fs.readdirSync(dir, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (filesChecked >= maxFiles)
+                        break;
+                    const fullPath = path.join(dir, entry.name);
+                    if (entry.isDirectory()) {
+                        if (!this.shouldIgnoreDir(entry.name)) {
+                            scan(fullPath);
+                        }
+                    }
+                    else if (extensions.has(path.extname(entry.name))) {
+                        try {
+                            const content = fs.readFileSync(fullPath, 'utf-8').toLowerCase();
+                            for (const keyword of keywords) {
+                                const regex = new RegExp(keyword.toLowerCase(), 'g');
+                                const matches = content.match(regex);
+                                if (matches) {
+                                    count += matches.length;
+                                }
+                            }
+                            filesChecked++;
+                        }
+                        catch {
+                            // Ignore errors
+                        }
+                    }
+                }
+            }
+            catch {
+                // Ignore errors
+            }
+        };
+        scan(this.projectPath);
+        return count;
+    }
+    // ========================================================================
+    // CONTEXT GENERATION
+    // ========================================================================
+    getDomainContext(domains) {
+        const contextMap = {
+            [Domain.AI_ML]: 'AI/ML project detected. Loading PyTorch, TensorFlow, HuggingFace patterns. GPU acceleration available.',
+            [Domain.WEB_FRONTEND]: 'Frontend project detected. Loading React/Vue/Svelte patterns, modern build tools (Vite, Webpack).',
+            [Domain.WEB_BACKEND]: 'Backend project detected. Loading FastAPI/Django/Express patterns, RESTful API best practices.',
+            [Domain.WEB_FULLSTACK]: 'Full-stack project detected. Loading Next.js/Remix/SvelteKit patterns, SSR/SSG capabilities.',
+            [Domain.HVAC_CONTROLS]: 'HVAC controls detected. Loading BACnet/Modbus protocols, ASHRAE standards, PID control logic.',
+            [Domain.RUST_NATIVE]: 'Rust project detected. Loading Rust patterns, cargo ecosystem, systems programming best practices.',
+            [Domain.TAURI_DESKTOP]: 'Tauri desktop app detected. Loading Tauri APIs, IPC patterns, cross-platform development.',
+            [Domain.IOT]: 'IoT project detected. Loading MQTT patterns, sensor protocols, Sequent Microsystems, edge computing.',
+            [Domain.DATABASE]: 'Database project detected. Loading SQL/NoSQL patterns, ORMs, migrations, query optimization.',
+            [Domain.EMBEDDED]: 'Embedded systems detected. Loading microcontroller patterns, real-time constraints, hardware interfaces.',
+            [Domain.DEVOPS]: 'DevOps project detected. Loading Docker, Kubernetes, CI/CD pipelines, infrastructure as code.',
+            [Domain.MOBILE]: 'Mobile app detected. Loading React Native/Flutter patterns, mobile-specific APIs, app deployment.',
+            [Domain.GAME_DEV]: 'Game development detected. Loading game engines, physics, rendering, asset management patterns.',
+            [Domain.DATA_SCIENCE]: 'Data science project detected. Loading pandas, numpy, visualization, statistical analysis patterns.',
+            [Domain.BLOCKCHAIN]: 'Blockchain project detected. Loading smart contracts, Web3, Ethereum/Solidity patterns.',
+            [Domain.SECURITY]: 'Security-focused project detected. Loading authentication, encryption, security best practices.',
+            [Domain.CLOUD]: 'Cloud project detected. Loading AWS/Azure/GCP patterns, serverless, cloud-native architectures.',
+            [Domain.API]: 'API project detected. Loading OpenAPI/GraphQL specifications, API design patterns.',
+            [Domain.CLI]: 'CLI application detected. Loading argument parsing, terminal UI, command patterns.',
+            [Domain.ARC_AGI]: 'ARC-AGI project detected. Loading grid patterns, transformations, abstract reasoning.',
+        };
+        const context = new Map();
+        for (const result of domains) {
+            context.set(result.domain, contextMap[result.domain] || `${result.domain} detected`);
+        }
+        return context;
+    }
+    getDetectionSummary() {
+        if (this.confidenceScores.size === 0) {
+            return 'No domains detected';
+        }
+        const lines = ['Domain Detection Results:\n'];
+        const sortedResults = Array.from(this.confidenceScores.entries())
+            .sort((a, b) => b[1] - a[1]);
+        for (const [domain, score] of sortedResults) {
+            if (score > 0.3) {
+                const confidenceBar = '█'.repeat(Math.floor(score * 10));
+                lines.push(`  ${domain.padEnd(20)} ${confidenceBar.padEnd(10)} ${score.toFixed(2)}`);
+                const domainEvidence = this.evidence.get(domain);
+                if (domainEvidence) {
+                    for (const evidence of domainEvidence.slice(0, 2)) {
+                        lines.push(`    └─ ${evidence}`);
+                    }
+                }
+            }
+        }
+        return lines.join('\n');
+    }
+}
+// ============================================================================
+// UTILITY FUNCTIONS
+// ============================================================================
+let detectorInstance = null;
+export function getDomainDetector() {
+    if (!detectorInstance) {
+        detectorInstance = new DomainDetector();
+    }
+    return detectorInstance;
+}
+export function resetDomainDetector() {
+    detectorInstance = null;
+}
+export function detectProjectDomains(projectPath, minConfidence = 0.3) {
+    const detector = new DomainDetector();
+    return detector.detectDomains(projectPath, minConfidence);
+}
+export function getPrimaryDomain(projectPath) {
+    const results = detectProjectDomains(projectPath);
+    return results.length > 0 ? results[0].domain : null;
+}
+//# sourceMappingURL=domainDetector.js.map