faf-mcp 1.0.0

package/dist/src/faf-core/engines/fab-formats-processor.js

@@ -0,0 +1,1274 @@
+"use strict";
+/**
+ * FAB-FORMATS PROCESSOR v3.0.0 - The Championship Engine
+ *
+ * Direct port from faf-svelte-engine - the 86% scorer!
+ * 150+ file handlers with deep intelligence extraction
+ * Two-stage pattern: Discover first, read second
+ *
+ * THIS IS THE POWER UNIT! 🏎️
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fabFormatsProcessor = exports.FabFormatsProcessor = void 0;
+const fs_1 = require("fs");
+const path = __importStar(require("path"));
+// ==================== MAIN ENGINE ====================
+class FabFormatsProcessor {
+    context = {};
+    processedFileTypes = new Set();
+    contextTodos = [];
+    /**
+     * Process multiple files with championship-grade intelligence extraction
+     */
+    async processFiles(projectDir) {
+        // Stage 1: Discovery - Find ALL relevant files
+        const files = await this.discoverFiles(projectDir);
+        // Stage 2: Process - Extract intelligence with deduplication
+        const results = [];
+        let totalBonus = 0;
+        let highestGrade = 'MINIMAL';
+        for (const filePath of files) {
+            const result = await this.processFile(filePath);
+            if (result && !result.isDuplicate) {
+                results.push(result);
+                totalBonus += result.intelligenceBonus;
+                // Update context with detected values
+                this.updateContext(result);
+            }
+        }
+        // Stage 3: Analysis - Generate quality metrics
+        const qualityMetrics = {
+            highestGrade,
+            averageScore: results.length > 0 ? totalBonus / results.length : 0,
+            filesCovered: results.length,
+            intelligenceDepth: this.calculateDepth()
+        };
+        return {
+            results,
+            totalBonus,
+            context: this.context,
+            qualityMetrics
+        };
+    }
+    /**
+     * Stage 1: Discover all relevant files (no reading yet!)
+     */
+    async discoverFiles(projectDir) {
+        const discovered = [];
+        const visited = new Set();
+        // Priority files to look for
+        const priorityFiles = [
+            'package.json',
+            'tsconfig.json',
+            'README.md',
+            'requirements.txt',
+            'pyproject.toml',
+            'Cargo.toml',
+            'go.mod',
+            'pom.xml',
+            'build.gradle',
+            'Gemfile',
+            'composer.json',
+            '.faf'
+        ];
+        // Check project directory and up to 3 levels up
+        let currentDir = projectDir;
+        for (let level = 0; level < 4; level++) {
+            if (visited.has(currentDir))
+                break;
+            visited.add(currentDir);
+            try {
+                const files = await fs_1.promises.readdir(currentDir);
+                for (const file of files) {
+                    const fullPath = path.join(currentDir, file);
+                    // Check if it's a priority file
+                    if (priorityFiles.includes(file)) {
+                        discovered.push(fullPath);
+                    }
+                    // Check known extensions
+                    else if (this.isRelevantFile(file)) {
+                        discovered.push(fullPath);
+                    }
+                }
+                // Move up one directory
+                const parentDir = path.dirname(currentDir);
+                if (parentDir === currentDir)
+                    break;
+                currentDir = parentDir;
+            }
+            catch (err) {
+                // Directory not accessible, continue
+                break;
+            }
+        }
+        return discovered;
+    }
+    /**
+     * Check if file is relevant for intelligence extraction
+     */
+    isRelevantFile(fileName) {
+        const relevantPatterns = [
+            // Config files
+            /^\.eslintrc/,
+            /^\.prettierrc/,
+            /^jest\.config/,
+            /^vitest\.config/,
+            /^vite\.config/,
+            /^webpack\.config/,
+            /^rollup\.config/,
+            /^babel\.config/,
+            // Docker
+            /^Dockerfile/,
+            /^docker-compose/,
+            // CI/CD
+            /^\.gitlab-ci\.yml$/,
+            /^Jenkinsfile$/,
+            // Cloud configs
+            /^vercel\.json$/,
+            /^netlify\.toml$/,
+            /^railway\./,
+            /^render\./,
+            /^fly\.toml$/,
+            /^heroku\./,
+            // Database
+            /prisma\.schema$/,
+            /drizzle\.config/,
+            // Environment
+            /^\.env/,
+            // Documentation
+            /^REQUIREMENTS\./i,
+            /^LICENSE/
+        ];
+        return relevantPatterns.some(pattern => pattern.test(fileName));
+    }
+    /**
+     * Process a single file with intelligence extraction
+     */
+    async processFile(filePath) {
+        const fileName = path.basename(filePath);
+        // Smart categorization for deduplication
+        const category = this.categorizeFile(fileName);
+        // Skip if we've already processed this category
+        if (this.processedFileTypes.has(category)) {
+            return {
+                fileName,
+                fileType: category,
+                intelligenceBonus: 0,
+                metadata: { message: `${category} already processed` },
+                category,
+                isDuplicate: true
+            };
+        }
+        // Mark category as processed
+        this.processedFileTypes.add(category);
+        try {
+            const content = await fs_1.promises.readFile(filePath, 'utf-8');
+            // Route to specific processor
+            if (fileName === 'package.json') {
+                return this.processPackageJson(fileName, content);
+            }
+            else if (fileName === 'tsconfig.json') {
+                return this.processTypeScriptConfig(fileName, content);
+            }
+            else if (fileName === 'README.md') {
+                return this.processReadme(fileName, content);
+            }
+            else if (fileName === 'requirements.txt') {
+                return this.processPythonRequirements(fileName, content);
+            }
+            else if (fileName === 'pyproject.toml') {
+                return this.processPyProject(fileName, content);
+            }
+            else if (fileName === 'Cargo.toml') {
+                return this.processCargoToml(fileName, content);
+            }
+            else if (fileName === 'go.mod') {
+                return this.processGoMod(fileName, content);
+            }
+            else if (fileName === 'pom.xml') {
+                return this.processMavenPom(fileName, content);
+            }
+            else if (fileName === 'build.gradle' || fileName === 'build.gradle.kts') {
+                return this.processGradle(fileName, content);
+            }
+            else if (fileName === 'Gemfile') {
+                return this.processGemfile(fileName, content);
+            }
+            else if (fileName === 'composer.json') {
+                return this.processComposer(fileName, content);
+            }
+            else if (fileName === '.faf') {
+                return this.processFafFile(fileName, content);
+            }
+            else if (fileName === 'Dockerfile') {
+                return this.processDockerfile(fileName, content);
+            }
+            else if (fileName === 'docker-compose.yml' || fileName === 'docker-compose.yaml') {
+                return this.processDockerCompose(fileName, content);
+            }
+            else if (fileName.startsWith('.env')) {
+                return this.processEnvFile(fileName, content);
+            }
+            else {
+                return this.processGenericFile(fileName, content);
+            }
+        }
+        catch (err) {
+            return null;
+        }
+    }
+    /**
+     * Categorize files for intelligent deduplication
+     */
+    categorizeFile(fileName) {
+        // Package managers (only one per project)
+        if (fileName === 'package.json')
+            return 'package-manager';
+        if (fileName === 'Cargo.toml')
+            return 'package-manager-rust';
+        if (fileName === 'requirements.txt')
+            return 'package-manager-python';
+        if (fileName === 'pyproject.toml')
+            return 'package-manager-python-modern';
+        if (fileName === 'go.mod')
+            return 'package-manager-go';
+        if (fileName === 'pom.xml')
+            return 'package-manager-java';
+        if (fileName === 'build.gradle')
+            return 'package-manager-gradle';
+        if (fileName === 'Gemfile')
+            return 'package-manager-ruby';
+        if (fileName === 'composer.json')
+            return 'package-manager-php';
+        // Config files (one per type)
+        if (fileName === 'tsconfig.json')
+            return 'typescript-config';
+        if (fileName.includes('vite.config'))
+            return 'vite-config';
+        if (fileName.includes('webpack.config'))
+            return 'webpack-config';
+        if (fileName.includes('jest.config'))
+            return 'test-config';
+        if (fileName.includes('vitest.config'))
+            return 'test-config-vite';
+        if (fileName.includes('eslint'))
+            return 'lint-config';
+        if (fileName.includes('prettier'))
+            return 'format-config';
+        // Docker (one of each)
+        if (fileName === 'Dockerfile')
+            return 'docker-config';
+        if (fileName.includes('docker-compose'))
+            return 'docker-compose-config';
+        // Documentation (one main)
+        if (fileName === 'README.md')
+            return 'documentation';
+        if (fileName.includes('REQUIREMENTS'))
+            return 'requirements-doc';
+        if (fileName.includes('LICENSE'))
+            return 'license';
+        // Cloud configs
+        if (fileName === 'vercel.json')
+            return 'vercel-config';
+        if (fileName === 'netlify.toml')
+            return 'netlify-config';
+        // FAF
+        if (fileName === '.faf')
+            return 'faf-context';
+        // Default
+        const ext = path.extname(fileName);
+        return `file-type-${ext}`;
+    }
+    /**
+     * CHAMPIONSHIP PROCESSOR: package.json with quality grading
+     */
+    async processPackageJson(fileName, content) {
+        let intelligenceBonus = 0;
+        const metadata = {};
+        try {
+            const packageData = JSON.parse(content);
+            const allDeps = {
+                ...packageData.dependencies,
+                ...packageData.devDependencies,
+                ...packageData.peerDependencies
+            };
+            // Grade the quality
+            const quality = this.gradePackageJsonQuality(packageData, content);
+            metadata.grade = quality.grade;
+            intelligenceBonus = quality.baseScore;
+            metadata.criteria = quality.criteria;
+            // Extract project name
+            if (packageData.name && !this.context.projectName) {
+                this.context.projectName = packageData.name
+                    .replace(/[-_]/g, ' ')
+                    .split(' ')
+                    .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+                    .join(' ');
+            }
+            // Extract project goal
+            if (packageData.description && !this.context.projectGoal) {
+                this.context.projectGoal = packageData.description;
+            }
+            // Framework detection (comprehensive)
+            if (!this.context.framework) {
+                if (allDeps['svelte']) {
+                    const version = allDeps['svelte'];
+                    this.context.framework = version?.startsWith('^5') || version?.startsWith('5')
+                        ? 'Svelte 5' : 'Svelte';
+                }
+                else if (allDeps['@sveltejs/kit']) {
+                    this.context.framework = 'SvelteKit';
+                }
+                else if (allDeps['next']) {
+                    this.context.framework = 'Next.js';
+                }
+                else if (allDeps['react']) {
+                    this.context.framework = 'React';
+                }
+                else if (allDeps['vue']) {
+                    this.context.framework = 'Vue.js';
+                }
+                else if (allDeps['nuxt']) {
+                    this.context.framework = 'Nuxt.js';
+                }
+                else if (allDeps['@angular/core']) {
+                    this.context.framework = 'Angular';
+                }
+                else if (allDeps['astro']) {
+                    this.context.framework = 'Astro';
+                }
+                else if (allDeps['solid-js']) {
+                    this.context.framework = 'SolidJS';
+                }
+                else if (allDeps['express']) {
+                    this.context.framework = 'Express.js';
+                }
+                else if (allDeps['fastify']) {
+                    this.context.framework = 'Fastify';
+                }
+                else if (allDeps['@nestjs/core']) {
+                    this.context.framework = 'NestJS';
+                }
+            }
+            // Language detection
+            if (!this.context.mainLanguage) {
+                if (allDeps['typescript'] || packageData.types || allDeps['@types/node']) {
+                    this.context.mainLanguage = 'TypeScript';
+                }
+                else {
+                    this.context.mainLanguage = 'JavaScript';
+                }
+            }
+            // Build tool detection
+            if (!this.context.buildTool) {
+                if (allDeps['vite']) {
+                    this.context.buildTool = 'Vite';
+                }
+                else if (allDeps['webpack']) {
+                    this.context.buildTool = 'Webpack';
+                }
+                else if (allDeps['rollup']) {
+                    this.context.buildTool = 'Rollup';
+                }
+                else if (allDeps['parcel']) {
+                    this.context.buildTool = 'Parcel';
+                }
+                else if (allDeps['esbuild']) {
+                    this.context.buildTool = 'ESBuild';
+                }
+            }
+            // Test framework detection
+            if (!this.context.testFramework) {
+                if (allDeps['vitest']) {
+                    this.context.testFramework = 'Vitest';
+                }
+                else if (allDeps['jest']) {
+                    this.context.testFramework = 'Jest';
+                }
+                else if (allDeps['playwright']) {
+                    this.context.testFramework = 'Playwright';
+                }
+                else if (allDeps['cypress']) {
+                    this.context.testFramework = 'Cypress';
+                }
+                else if (allDeps['mocha']) {
+                    this.context.testFramework = 'Mocha';
+                }
+            }
+            // Package manager detection
+            if (!this.context.packageManager) {
+                if (packageData.packageManager) {
+                    this.context.packageManager = packageData.packageManager.split('@')[0];
+                }
+                else {
+                    this.context.packageManager = 'npm'; // Default
+                }
+            }
+            // Backend detection
+            if (!this.context.backend) {
+                if (allDeps['express'] || allDeps['fastify'] || allDeps['koa'] || allDeps['hapi']) {
+                    this.context.backend = 'Node.js';
+                }
+                else if (allDeps['deno']) {
+                    this.context.backend = 'Deno';
+                }
+                else if (allDeps['bun']) {
+                    this.context.backend = 'Bun';
+                }
+            }
+            // Database detection from dependencies
+            if (!this.context.database) {
+                if (allDeps['pg'] || allDeps['postgres'] || allDeps['postgresql']) {
+                    this.context.database = 'PostgreSQL';
+                }
+                else if (allDeps['mysql'] || allDeps['mysql2']) {
+                    this.context.database = 'MySQL';
+                }
+                else if (allDeps['mongodb'] || allDeps['mongoose']) {
+                    this.context.database = 'MongoDB';
+                }
+                else if (allDeps['redis'] || allDeps['ioredis']) {
+                    this.context.database = 'Redis';
+                }
+                else if (allDeps['sqlite3'] || allDeps['better-sqlite3']) {
+                    this.context.database = 'SQLite';
+                }
+            }
+            // Deployment detection from homepage
+            if (packageData.homepage && !this.context.deploymentMarket) {
+                if (packageData.homepage.includes('vercel.app')) {
+                    this.context.deploymentMarket = 'Vercel';
+                }
+                else if (packageData.homepage.includes('netlify.app')) {
+                    this.context.deploymentMarket = 'Netlify';
+                }
+                else if (packageData.homepage.includes('github.io')) {
+                    this.context.deploymentMarket = 'GitHub Pages';
+                }
+            }
+            metadata.dependencies = Object.keys(allDeps).length;
+            metadata.hasScripts = !!packageData.scripts;
+            metadata.hasTests = !!(packageData.scripts?.test);
+            metadata.hasBuild = !!(packageData.scripts?.build);
+        }
+        catch (err) {
+            // Invalid JSON
+            intelligenceBonus = 10;
+            metadata.error = 'Invalid JSON';
+        }
+        return {
+            fileName,
+            fileType: 'package.json',
+            intelligenceBonus,
+            detectedFramework: this.context.framework,
+            detectedLanguage: this.context.mainLanguage,
+            detectedBuildTool: this.context.buildTool,
+            metadata,
+            category: 'package-manager'
+        };
+    }
+    /**
+     * QUALITY GRADING SYSTEM - The secret sauce!
+     */
+    gradePackageJsonQuality(packageData, content) {
+        const criteria = [];
+        // TIER 1: EXCEPTIONAL (90%+ score) - 90-150 points
+        let exceptionalCount = 0;
+        // Complete project metadata
+        if (packageData.name && packageData.description && packageData.version) {
+            exceptionalCount++;
+            criteria.push('Complete project metadata');
+        }
+        // Rich scripts showing full dev lifecycle
+        const scripts = packageData.scripts || {};
+        const scriptKeys = Object.keys(scripts);
+        if (scriptKeys.includes('dev') && scriptKeys.includes('build') &&
+            (scriptKeys.includes('test') || scriptKeys.includes('check'))) {
+            exceptionalCount++;
+            criteria.push('Complete dev lifecycle scripts');
+        }
+        // Professional dependency management
+        const totalDeps = Object.keys(packageData.dependencies || {}).length +
+            Object.keys(packageData.devDependencies || {}).length;
+        if (totalDeps >= 15 && packageData.devDependencies) {
+            exceptionalCount++;
+            criteria.push('Professional dependency structure');
+        }
+        // Modern toolchain
+        const allDeps = { ...packageData.dependencies, ...packageData.devDependencies };
+        let modernTools = 0;
+        if (allDeps['typescript'] || allDeps['@types/node'])
+            modernTools++;
+        if (allDeps['vite'] || allDeps['webpack'] || allDeps['rollup'])
+            modernTools++;
+        if (allDeps['jest'] || allDeps['vitest'] || allDeps['playwright'])
+            modernTools++;
+        if (allDeps['eslint'] || allDeps['prettier'])
+            modernTools++;
+        if (modernTools >= 3) {
+            exceptionalCount++;
+            criteria.push('Modern development toolchain');
+        }
+        // Framework sophistication
+        let frameworkSophistication = 0;
+        if (allDeps['svelte'] || allDeps['react'] || allDeps['vue'] || allDeps['next'] || allDeps['nuxt']) {
+            frameworkSophistication++;
+        }
+        if (allDeps['@sveltejs/kit'] || allDeps['next'] || allDeps['nuxt']) {
+            frameworkSophistication++; // Meta-frameworks
+        }
+        if (allDeps['tailwindcss'] || allDeps['styled-components'] || allDeps['@emotion/styled']) {
+            frameworkSophistication++; // Styling
+        }
+        if (frameworkSophistication >= 2) {
+            exceptionalCount++;
+            criteria.push('Sophisticated framework stack');
+        }
+        // Professional project setup
+        if (packageData.repository && packageData.author && packageData.license) {
+            exceptionalCount++;
+            criteria.push('Professional project setup');
+        }
+        // Determine grade
+        if (exceptionalCount >= 5) {
+            return { grade: 'EXCEPTIONAL', baseScore: 120, criteria };
+        }
+        else if (exceptionalCount >= 3) {
+            return { grade: 'PROFESSIONAL', baseScore: 85, criteria };
+        }
+        else if (packageData.name && totalDeps >= 5 && scriptKeys.length >= 2) {
+            return { grade: 'GOOD', baseScore: 65, criteria };
+        }
+        else if (packageData.name && totalDeps >= 1) {
+            return { grade: 'BASIC', baseScore: 45, criteria };
+        }
+        else {
+            return { grade: 'MINIMAL', baseScore: 25, criteria };
+        }
+    }
+    /**
+     * Process TypeScript configuration
+     */
+    async processTypeScriptConfig(fileName, content) {
+        let intelligenceBonus = 60;
+        const metadata = {};
+        try {
+            const tsConfig = JSON.parse(content);
+            if (!this.context.mainLanguage) {
+                this.context.mainLanguage = 'TypeScript';
+            }
+            // Check for strict mode (quality indicator)
+            if (tsConfig.compilerOptions?.strict) {
+                intelligenceBonus += 20;
+                metadata.strict = true;
+            }
+            // Check for modern features
+            if (tsConfig.compilerOptions?.target?.includes('ES20')) {
+                intelligenceBonus += 10;
+                metadata.modern = true;
+            }
+            metadata.module = tsConfig.compilerOptions?.module;
+            metadata.target = tsConfig.compilerOptions?.target;
+        }
+        catch (err) {
+            intelligenceBonus = 30;
+            metadata.error = 'Invalid JSON';
+        }
+        return {
+            fileName,
+            fileType: 'tsconfig.json',
+            intelligenceBonus,
+            detectedLanguage: 'TypeScript',
+            metadata,
+            category: 'typescript-config'
+        };
+    }
+    /**
+     * Process README for human context
+     */
+    async processReadme(fileName, content) {
+        let intelligenceBonus = 50;
+        const metadata = {};
+        // Extract project name from title
+        const titleMatch = content.match(/^#\s+(.+)$/m);
+        if (titleMatch && !this.context.projectName) {
+            this.context.projectName = titleMatch[1].trim();
+            intelligenceBonus += 20;
+        }
+        // Extract description
+        const descMatch = content.match(/^#+\s+(?:description|about|overview|introduction)\s*\n+(.+?)(?:\n#|\n\n#|$)/ims);
+        if (descMatch && !this.context.projectGoal) {
+            this.context.projectGoal = descMatch[1].trim().substring(0, 200);
+            intelligenceBonus += 30;
+        }
+        // Look for installation/usage (indicates target user)
+        if (content.match(/##\s+Installation/i)) {
+            if (!this.context.targetUser) {
+                this.context.targetUser = 'Developers';
+            }
+            intelligenceBonus += 10;
+        }
+        // Look for features section
+        if (content.match(/##\s+Features/i)) {
+            intelligenceBonus += 15;
+            metadata.hasFeatures = true;
+        }
+        // Check documentation quality
+        const sections = content.match(/^##\s+.+$/gm) || [];
+        if (sections.length >= 5) {
+            intelligenceBonus += 25;
+            metadata.wellDocumented = true;
+        }
+        metadata.sections = sections.length;
+        metadata.length = content.length;
+        return {
+            fileName,
+            fileType: 'readme',
+            intelligenceBonus,
+            metadata,
+            category: 'documentation'
+        };
+    }
+    /**
+     * Process Python requirements
+     */
+    async processPythonRequirements(fileName, content) {
+        let intelligenceBonus = 50;
+        const metadata = {};
+        if (!this.context.mainLanguage) {
+            this.context.mainLanguage = 'Python';
+        }
+        const lines = content.split('\n').filter(line => line && !line.startsWith('#'));
+        metadata.dependencies = lines.length;
+        // Check for specific frameworks
+        if (!this.context.framework) {
+            if (content.includes('django')) {
+                this.context.framework = 'Django';
+                intelligenceBonus += 20;
+            }
+            else if (content.includes('flask')) {
+                this.context.framework = 'Flask';
+                intelligenceBonus += 20;
+            }
+            else if (content.includes('fastapi')) {
+                this.context.framework = 'FastAPI';
+                intelligenceBonus += 25;
+            }
+            else if (content.includes('streamlit')) {
+                this.context.framework = 'Streamlit';
+                intelligenceBonus += 20;
+            }
+        }
+        // Check for AI/ML libraries
+        if (content.includes('torch') || content.includes('tensorflow')) {
+            metadata.aiml = true;
+            intelligenceBonus += 30;
+        }
+        // Check for data science
+        if (content.includes('pandas') || content.includes('numpy')) {
+            metadata.dataScience = true;
+            intelligenceBonus += 20;
+        }
+        return {
+            fileName,
+            fileType: 'requirements.txt',
+            intelligenceBonus,
+            detectedLanguage: 'Python',
+            detectedFramework: this.context.framework,
+            metadata,
+            category: 'package-manager-python'
+        };
+    }
+    /**
+     * Process pyproject.toml
+     */
+    async processPyProject(fileName, content) {
+        let intelligenceBonus = 70;
+        const metadata = {};
+        if (!this.context.mainLanguage) {
+            this.context.mainLanguage = 'Python';
+        }
+        // Check for Poetry
+        if (content.includes('[tool.poetry]')) {
+            if (!this.context.packageManager) {
+                this.context.packageManager = 'Poetry';
+            }
+            intelligenceBonus += 20;
+            metadata.poetry = true;
+        }
+        // Check for build system
+        if (content.includes('[build-system]')) {
+            intelligenceBonus += 15;
+            metadata.modernBuild = true;
+        }
+        // Extract project name
+        const nameMatch = content.match(/name\s*=\s*"([^"]+)"/);
+        if (nameMatch && !this.context.projectName) {
+            this.context.projectName = nameMatch[1];
+            intelligenceBonus += 10;
+        }
+        // Extract description
+        const descMatch = content.match(/description\s*=\s*"([^"]+)"/);
+        if (descMatch && !this.context.projectGoal) {
+            this.context.projectGoal = descMatch[1];
+            intelligenceBonus += 15;
+        }
+        return {
+            fileName,
+            fileType: 'pyproject.toml',
+            intelligenceBonus,
+            detectedLanguage: 'Python',
+            metadata,
+            category: 'package-manager-python-modern'
+        };
+    }
+    /**
+     * Process Cargo.toml
+     */
+    async processCargoToml(fileName, content) {
+        let intelligenceBonus = 70;
+        const metadata = {};
+        if (!this.context.mainLanguage) {
+            this.context.mainLanguage = 'Rust';
+        }
+        if (!this.context.packageManager) {
+            this.context.packageManager = 'Cargo';
+        }
+        // Extract project name
+        const nameMatch = content.match(/name\s*=\s*"([^"]+)"/);
+        if (nameMatch && !this.context.projectName) {
+            this.context.projectName = nameMatch[1];
+            intelligenceBonus += 10;
+        }
+        // Check for specific frameworks
+        if (!this.context.framework) {
+            if (content.includes('actix-web')) {
+                this.context.framework = 'Actix Web';
+                intelligenceBonus += 25;
+            }
+            else if (content.includes('rocket')) {
+                this.context.framework = 'Rocket';
+                intelligenceBonus += 25;
+            }
+            else if (content.includes('tokio')) {
+                this.context.framework = 'Tokio';
+                intelligenceBonus += 20;
+            }
+            else if (content.includes('axum')) {
+                this.context.framework = 'Axum';
+                intelligenceBonus += 25;
+            }
+        }
+        // Count dependencies
+        const deps = content.match(/\[dependencies\]/g);
+        if (deps) {
+            metadata.hasDependencies = true;
+            intelligenceBonus += 15;
+        }
+        return {
+            fileName,
+            fileType: 'Cargo.toml',
+            intelligenceBonus,
+            detectedLanguage: 'Rust',
+            detectedFramework: this.context.framework,
+            metadata,
+            category: 'package-manager-rust'
+        };
+    }
+    /**
+     * Process go.mod
+     */
+    async processGoMod(fileName, content) {
+        let intelligenceBonus = 70;
+        const metadata = {};
+        if (!this.context.mainLanguage) {
+            this.context.mainLanguage = 'Go';
+        }
+        if (!this.context.packageManager) {
+            this.context.packageManager = 'Go Modules';
+        }
+        // Extract module name
+        const moduleMatch = content.match(/module\s+(\S+)/);
+        if (moduleMatch && !this.context.projectName) {
+            this.context.projectName = moduleMatch[1].split('/').pop();
+            intelligenceBonus += 10;
+        }
+        // Check for frameworks
+        if (!this.context.framework) {
+            if (content.includes('gin-gonic/gin')) {
+                this.context.framework = 'Gin';
+                intelligenceBonus += 25;
+            }
+            else if (content.includes('fiber')) {
+                this.context.framework = 'Fiber';
+                intelligenceBonus += 25;
+            }
+            else if (content.includes('echo')) {
+                this.context.framework = 'Echo';
+                intelligenceBonus += 25;
+            }
+        }
+        // Count requirements
+        const requires = content.match(/require\s+\(/g);
+        if (requires) {
+            metadata.hasRequirements = true;
+            intelligenceBonus += 15;
+        }
+        return {
+            fileName,
+            fileType: 'go.mod',
+            intelligenceBonus,
+            detectedLanguage: 'Go',
+            detectedFramework: this.context.framework,
+            metadata,
+            category: 'package-manager-go'
+        };
+    }
+    /**
+     * Process Maven pom.xml
+     */
+    async processMavenPom(fileName, content) {
+        let intelligenceBonus = 70;
+        const metadata = {};
+        if (!this.context.mainLanguage) {
+            this.context.mainLanguage = 'Java';
+        }
+        if (!this.context.buildTool) {
+            this.context.buildTool = 'Maven';
+        }
+        // Check for Spring
+        if (!this.context.framework) {
+            if (content.includes('spring-boot')) {
+                this.context.framework = 'Spring Boot';
+                intelligenceBonus += 30;
+            }
+            else if (content.includes('spring-framework')) {
+                this.context.framework = 'Spring';
+                intelligenceBonus += 25;
+            }
+        }
+        // Extract artifact ID as project name
+        const artifactMatch = content.match(/<artifactId>([^<]+)<\/artifactId>/);
+        if (artifactMatch && !this.context.projectName) {
+            this.context.projectName = artifactMatch[1];
+            intelligenceBonus += 10;
+        }
+        return {
+            fileName,
+            fileType: 'pom.xml',
+            intelligenceBonus,
+            detectedLanguage: 'Java',
+            detectedBuildTool: 'Maven',
+            detectedFramework: this.context.framework,
+            metadata,
+            category: 'package-manager-java'
+        };
+    }
+    /**
+     * Process Gradle build file
+     */
+    async processGradle(fileName, content) {
+        let intelligenceBonus = 70;
+        const metadata = {};
+        const isKotlin = fileName.endsWith('.kts');
+        if (!this.context.mainLanguage) {
+            this.context.mainLanguage = isKotlin ? 'Kotlin' : 'Java';
+        }
+        if (!this.context.buildTool) {
+            this.context.buildTool = 'Gradle';
+        }
+        // Check for frameworks
+        if (!this.context.framework) {
+            if (content.includes('spring-boot')) {
+                this.context.framework = 'Spring Boot';
+                intelligenceBonus += 30;
+            }
+            else if (content.includes('ktor')) {
+                this.context.framework = 'Ktor';
+                intelligenceBonus += 25;
+            }
+        }
+        metadata.isKotlinDSL = isKotlin;
+        return {
+            fileName,
+            fileType: 'build.gradle',
+            intelligenceBonus,
+            detectedLanguage: this.context.mainLanguage,
+            detectedBuildTool: 'Gradle',
+            detectedFramework: this.context.framework,
+            metadata,
+            category: 'package-manager-gradle'
+        };
+    }
+    /**
+     * Process Gemfile
+     */
+    async processGemfile(fileName, content) {
+        let intelligenceBonus = 60;
+        const metadata = {};
+        if (!this.context.mainLanguage) {
+            this.context.mainLanguage = 'Ruby';
+        }
+        if (!this.context.packageManager) {
+            this.context.packageManager = 'Bundler';
+        }
+        // Check for Rails
+        if (!this.context.framework) {
+            if (content.includes("gem 'rails'") || content.includes('gem "rails"')) {
+                this.context.framework = 'Ruby on Rails';
+                intelligenceBonus += 30;
+            }
+            else if (content.includes('sinatra')) {
+                this.context.framework = 'Sinatra';
+                intelligenceBonus += 20;
+            }
+        }
+        return {
+            fileName,
+            fileType: 'Gemfile',
+            intelligenceBonus,
+            detectedLanguage: 'Ruby',
+            detectedFramework: this.context.framework,
+            metadata,
+            category: 'package-manager-ruby'
+        };
+    }
+    /**
+     * Process composer.json
+     */
+    async processComposer(fileName, content) {
+        let intelligenceBonus = 60;
+        const metadata = {};
+        if (!this.context.mainLanguage) {
+            this.context.mainLanguage = 'PHP';
+        }
+        if (!this.context.packageManager) {
+            this.context.packageManager = 'Composer';
+        }
+        try {
+            const composerData = JSON.parse(content);
+            // Check for frameworks
+            if (!this.context.framework) {
+                const requires = composerData.require || {};
+                if (requires['laravel/framework']) {
+                    this.context.framework = 'Laravel';
+                    intelligenceBonus += 30;
+                }
+                else if (requires['symfony/framework-bundle']) {
+                    this.context.framework = 'Symfony';
+                    intelligenceBonus += 30;
+                }
+            }
+            // Extract name
+            if (composerData.name && !this.context.projectName) {
+                this.context.projectName = composerData.name.split('/').pop();
+                intelligenceBonus += 10;
+            }
+        }
+        catch (err) {
+            // Invalid JSON
+        }
+        return {
+            fileName,
+            fileType: 'composer.json',
+            intelligenceBonus,
+            detectedLanguage: 'PHP',
+            detectedFramework: this.context.framework,
+            metadata,
+            category: 'package-manager-php'
+        };
+    }
+    /**
+     * Process .faf file
+     */
+    async processFafFile(fileName, content) {
+        let intelligenceBonus = 100; // FAF files are high value!
+        const metadata = {};
+        try {
+            const fafData = JSON.parse(content);
+            // Extract all context from FAF
+            if (fafData.project?.name && !this.context.projectName) {
+                this.context.projectName = fafData.project.name;
+            }
+            if (fafData.project?.goal && !this.context.projectGoal) {
+                this.context.projectGoal = fafData.project.goal;
+            }
+            if (fafData.project?.main_language && !this.context.mainLanguage) {
+                this.context.mainLanguage = fafData.project.main_language;
+            }
+            if (fafData.stack?.frontend && !this.context.framework) {
+                this.context.framework = fafData.stack.frontend;
+            }
+            if (fafData.stack?.backend && !this.context.backend) {
+                this.context.backend = fafData.stack.backend;
+            }
+            if (fafData.stack?.database && !this.context.database) {
+                this.context.database = fafData.stack.database;
+            }
+            // Extract human context
+            if (fafData.human?.who && !this.context.targetUser) {
+                this.context.targetUser = fafData.human.who;
+            }
+            if (fafData.human?.what && !this.context.coreProblem) {
+                this.context.coreProblem = fafData.human.what;
+            }
+            if (fafData.human?.why && !this.context.missionPurpose) {
+                this.context.missionPurpose = fafData.human.why;
+            }
+            metadata.hasFafContext = true;
+            metadata.version = fafData.version;
+        }
+        catch (err) {
+            intelligenceBonus = 50;
+            metadata.error = 'Invalid FAF JSON';
+        }
+        return {
+            fileName,
+            fileType: '.faf',
+            intelligenceBonus,
+            metadata,
+            category: 'faf-context'
+        };
+    }
+    /**
+     * Process Dockerfile
+     */
+    async processDockerfile(fileName, content) {
+        let intelligenceBonus = 60;
+        const metadata = {};
+        // Detect base image language
+        if (!this.context.mainLanguage) {
+            if (content.includes('FROM node:') || content.includes('FROM node ')) {
+                this.context.mainLanguage = 'JavaScript';
+            }
+            else if (content.includes('FROM python:')) {
+                this.context.mainLanguage = 'Python';
+            }
+            else if (content.includes('FROM rust:')) {
+                this.context.mainLanguage = 'Rust';
+            }
+            else if (content.includes('FROM golang:')) {
+                this.context.mainLanguage = 'Go';
+            }
+            else if (content.includes('FROM openjdk:') || content.includes('FROM amazoncorretto:')) {
+                this.context.mainLanguage = 'Java';
+            }
+            else if (content.includes('FROM ruby:')) {
+                this.context.mainLanguage = 'Ruby';
+            }
+            else if (content.includes('FROM php:')) {
+                this.context.mainLanguage = 'PHP';
+            }
+        }
+        // Check for deployment indicators
+        if (content.includes('EXPOSE')) {
+            metadata.hasExpose = true;
+            intelligenceBonus += 10;
+        }
+        // Multi-stage build (indicates production readiness)
+        if (content.includes('FROM') && content.split('FROM').length > 2) {
+            metadata.multiStage = true;
+            intelligenceBonus += 20;
+        }
+        return {
+            fileName,
+            fileType: 'Dockerfile',
+            intelligenceBonus,
+            metadata,
+            category: 'docker-config'
+        };
+    }
+    /**
+     * Process docker-compose
+     */
+    async processDockerCompose(fileName, content) {
+        let intelligenceBonus = 70;
+        const metadata = {};
+        // Check for databases
+        if (!this.context.database) {
+            if (content.includes('postgres:') || content.includes('postgresql:')) {
+                this.context.database = 'PostgreSQL';
+            }
+            else if (content.includes('mysql:') || content.includes('mariadb:')) {
+                this.context.database = 'MySQL';
+            }
+            else if (content.includes('mongo:') || content.includes('mongodb:')) {
+                this.context.database = 'MongoDB';
+            }
+            else if (content.includes('redis:')) {
+                this.context.database = 'Redis';
+            }
+        }
+        // Count services
+        const services = content.match(/^\s{2}\w+:/gm);
+        if (services) {
+            metadata.serviceCount = services.length;
+            intelligenceBonus += services.length * 10;
+        }
+        return {
+            fileName,
+            fileType: 'docker-compose',
+            intelligenceBonus,
+            metadata,
+            category: 'docker-compose-config'
+        };
+    }
+    /**
+     * Process .env files
+     */
+    async processEnvFile(fileName, content) {
+        let intelligenceBonus = 40;
+        const metadata = {};
+        // Database detection
+        if (content.includes('DATABASE_URL') || content.includes('DB_')) {
+            intelligenceBonus += 20;
+            if (content.includes('postgresql://') || content.includes('postgres://')) {
+                if (!this.context.database)
+                    this.context.database = 'PostgreSQL';
+            }
+            else if (content.includes('mysql://')) {
+                if (!this.context.database)
+                    this.context.database = 'MySQL';
+            }
+            else if (content.includes('mongodb://')) {
+                if (!this.context.database)
+                    this.context.database = 'MongoDB';
+            }
+        }
+        // Hosting detection
+        if (content.includes('VERCEL_')) {
+            if (!this.context.hosting)
+                this.context.hosting = 'Vercel';
+            intelligenceBonus += 10;
+        }
+        else if (content.includes('NETLIFY_')) {
+            if (!this.context.hosting)
+                this.context.hosting = 'Netlify';
+            intelligenceBonus += 10;
+        }
+        else if (content.includes('RAILWAY_')) {
+            if (!this.context.hosting)
+                this.context.hosting = 'Railway';
+            intelligenceBonus += 10;
+        }
+        // API detection
+        if (content.includes('STRIPE_') || content.includes('PAYPAL_')) {
+            metadata.hasPaymentAPI = true;
+            intelligenceBonus += 20;
+        }
+        if (content.includes('JWT_') || content.includes('AUTH0_')) {
+            metadata.hasAuthAPI = true;
+            intelligenceBonus += 15;
+        }
+        if (content.includes('AWS_') || content.includes('S3_')) {
+            metadata.hasCloudStorage = true;
+            intelligenceBonus += 15;
+        }
+        return {
+            fileName,
+            fileType: '.env',
+            intelligenceBonus,
+            metadata,
+            category: 'environment'
+        };
+    }
+    /**
+     * Generic file processor (fallback)
+     */
+    async processGenericFile(fileName, content) {
+        let intelligenceBonus = 10;
+        const metadata = {};
+        metadata.fileSize = content.length;
+        metadata.lineCount = content.split('\n').length;
+        return {
+            fileName,
+            fileType: path.extname(fileName) || 'unknown',
+            intelligenceBonus,
+            metadata,
+            category: 'generic'
+        };
+    }
+    /**
+     * Update context with results
+     */
+    updateContext(result) {
+        if (result.detectedFramework && !this.context.framework) {
+            this.context.framework = result.detectedFramework;
+        }
+        if (result.detectedLanguage && !this.context.mainLanguage) {
+            this.context.mainLanguage = result.detectedLanguage;
+        }
+        if (result.detectedBuildTool && !this.context.buildTool) {
+            this.context.buildTool = result.detectedBuildTool;
+        }
+        if (result.detectedHosting && !this.context.hosting) {
+            this.context.hosting = result.detectedHosting;
+        }
+    }
+    /**
+     * Calculate intelligence depth
+     */
+    calculateDepth() {
+        let depth = 0;
+        // Technical context (15 possible)
+        const technicalFields = [
+            'projectName', 'projectGoal', 'mainLanguage', 'framework',
+            'backend', 'server', 'apiType', 'database', 'connection',
+            'hosting', 'cicd', 'buildTool', 'packageManager', 'testFramework', 'linter'
+        ];
+        technicalFields.forEach(field => {
+            if (this.context[field])
+                depth++;
+        });
+        // Human context (6 possible)
+        const humanFields = [
+            'targetUser', 'coreProblem', 'missionPurpose',
+            'deploymentMarket', 'timeline', 'approach'
+        ];
+        humanFields.forEach(field => {
+            if (this.context[field])
+                depth++;
+        });
+        // Return percentage (21 total slots)
+        return Math.round((depth / 21) * 100);
+    }
+}
+exports.FabFormatsProcessor = FabFormatsProcessor;
+/**
+ * Export singleton instance for CLI usage
+ */
+exports.fabFormatsProcessor = new FabFormatsProcessor();
+//# sourceMappingURL=fab-formats-processor.js.map