faf-mcp 1.0.0

package/dist/src/faf-core/fix-once/yaml.js

@@ -0,0 +1,172 @@
+"use strict";
+/**
+ * 🔥 YAML FIX-ONCE ABSTRACTION
+ *
+ * ROCK SOLID YAML PARSING - FIX ONCE, DONE FOREVER
+ *
+ * This module handles ALL YAML edge cases:
+ * ✅ Empty files
+ * ✅ Null/undefined content
+ * ✅ Invalid YAML syntax
+ * ✅ Type validation
+ * ✅ Corrupted files
+ * ✅ Clear error messages
+ * ✅ Primitive vs Object validation
+ *
+ * NEVER touch raw YAML parsing outside this file.
+ */
+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.YAML = exports.Document = exports.parseDocument = void 0;
+exports.parse = parse;
+exports.stringify = stringify;
+const yaml = __importStar(require("yaml"));
+const colors_1 = require("./colors");
+/**
+ * Safe YAML parse - handles ALL edge cases
+ * ROCK SOLID - FIX ONCE, DONE FOREVER
+ */
+function parse(content, options) {
+    const filepath = options?.filepath || 'unknown file';
+    // Edge case 1: Null/undefined (CHECK FIRST before any operations)
+    if (content === null || content === undefined) {
+        throw new Error(`${colors_1.chalk.red('Empty content passed to YAML parser')}\n` +
+            `File: ${filepath}\n` +
+            `Fix: Ensure file exists and has content before parsing`);
+    }
+    // Edge case 2: Not a string (CHECK BEFORE calling string methods)
+    if (typeof content !== 'string') {
+        throw new Error(`${colors_1.chalk.red('Invalid content type passed to YAML parser')}\n` +
+            `Expected: string\n` +
+            `Got: ${typeof content}\n` +
+            `File: ${filepath}`);
+    }
+    // Edge case 3: Empty string or whitespace only
+    if (content.trim() === '') {
+        throw new Error(`${colors_1.chalk.red('Empty .faf file detected')}\n` +
+            `File: ${filepath}\n` +
+            `Fix: Run ${colors_1.chalk.cyan('faf init')} to recreate the file`);
+    }
+    // Edge case 4: Parse YAML and handle syntax errors
+    let result;
+    try {
+        result = yaml.parse(content);
+    }
+    catch (error) {
+        // Wrap yaml parsing errors with helpful context
+        throw new Error(`${colors_1.chalk.red('Invalid YAML syntax')}\n` +
+            `File: ${filepath}\n` +
+            `Error: ${error.message}\n` +
+            `Fix: Check file syntax or run ${colors_1.chalk.cyan('faf init --force')} to recreate`);
+    }
+    // Edge case 5: Parsed successfully but result is null/undefined
+    // (valid YAML like "null" or "~" or empty documents)
+    if (result === null || result === undefined) {
+        throw new Error(`${colors_1.chalk.red('YAML file parsed but contains no data')}\n` +
+            `File: ${filepath}\n` +
+            `Fix: Ensure file has valid YAML content or run ${colors_1.chalk.cyan('faf init')}`);
+    }
+    // Edge case 6: Parsed to primitive (not an object)
+    // .faf files must be YAML objects, not scalars
+    if (typeof result !== 'object' || Array.isArray(result)) {
+        throw new Error(`${colors_1.chalk.red('Invalid .faf structure - must be a YAML object')}\n` +
+            `File: ${filepath}\n` +
+            `Got: ${Array.isArray(result) ? 'array' : typeof result}\n` +
+            `Fix: .faf files must contain key-value pairs, not ${Array.isArray(result) ? 'lists' : 'simple values'}`);
+    }
+    return result;
+}
+/**
+ * Safe YAML stringify - handles edge cases
+ * ROCK SOLID - FIX ONCE, DONE FOREVER
+ */
+function stringify(data, options) {
+    // Edge case 1: Null/undefined data
+    if (data === null || data === undefined) {
+        throw new Error(`${colors_1.chalk.red('Cannot stringify null/undefined data to YAML')}\n` +
+            `Fix: Provide valid data object`);
+    }
+    // Edge case 2: Not an object (primitives should not be stringified for .faf)
+    if (typeof data !== 'object' || Array.isArray(data)) {
+        throw new Error(`${colors_1.chalk.red('Invalid data for .faf stringify')}\n` +
+            `Expected: object\n` +
+            `Got: ${Array.isArray(data) ? 'array' : typeof data}\n` +
+            `Fix: .faf files must be objects with key-value pairs`);
+    }
+    // Edge case 3: Stringify and catch any errors
+    try {
+        const result = yaml.stringify(data, options);
+        // Edge case 4: Empty result
+        if (!result || result.trim() === '') {
+            throw new Error('Stringify produced empty output');
+        }
+        return result;
+    }
+    catch (error) {
+        throw new Error(`${colors_1.chalk.red('Failed to convert data to YAML')}\n` +
+            `Error: ${error.message}`);
+    }
+}
+// Export raw versions for advanced usage (use with caution)
+exports.parseDocument = yaml.parseDocument;
+exports.Document = yaml.Document;
+// Re-export as default for compatibility
+exports.default = {
+    parse,
+    stringify,
+    Document: exports.Document,
+    parseDocument: exports.parseDocument
+};
+// Also export as YAML for compatibility
+exports.YAML = {
+    parse,
+    stringify,
+    Document: exports.Document,
+    parseDocument: exports.parseDocument
+};
+/**
+ * 🔥 ROCK SOLID STATUS: ACHIEVED
+ *
+ * All edge cases handled:
+ * ✅ Null/undefined → Clear error
+ * ✅ Empty files → Clear error
+ * ✅ Wrong types → Clear error
+ * ✅ Invalid YAML → Wrapped error with context
+ * ✅ Primitives → Clear error (.faf must be objects)
+ * ✅ Arrays → Clear error (.faf must be objects)
+ *
+ * FIX ONCE, DONE FOREVER
+ */
+//# sourceMappingURL=yaml.js.map

package/dist/src/faf-core/fix-once/yaml.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"yaml.js","sourceRoot":"","sources":["../../../../src/faf-core/fix-once/yaml.ts"],"names":[],"mappings":"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"}

package/dist/src/faf-core/generators/faf-generator-championship.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 🏎️ Championship .faf Generator
+ * Uses FAB-FORMATS Power Unit for 86%+ context extraction
+ */
+export interface GenerateOptions {
+    projectType?: string;
+    outputPath: string;
+    projectRoot: string;
+    projectName?: string;
+    projectGoal?: string;
+    mainLanguage?: string;
+    framework?: string;
+    hosting?: string;
+    [key: string]: any;
+}
+export declare function generateFafFromProject(options: GenerateOptions): Promise<string>;

package/dist/src/faf-core/generators/faf-generator-championship.js

@@ -0,0 +1,462 @@
+"use strict";
+/**
+ * 🏎️ Championship .faf Generator
+ * Uses FAB-FORMATS Power Unit for 86%+ context extraction
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateFafFromProject = generateFafFromProject;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const file_utils_1 = require("../utils/file-utils");
+const yaml_generator_1 = require("../utils/yaml-generator");
+const fab_formats_processor_1 = require("../engines/fab-formats-processor");
+const relentless_context_extractor_1 = require("../engines/relentless-context-extractor");
+async function generateFafFromProject(options) {
+    const { projectType, projectRoot } = options;
+    // Validate projectRoot
+    if (!projectRoot || typeof projectRoot !== 'string') {
+        throw new Error(`Invalid projectRoot: ${projectRoot}. Expected a valid directory path.`);
+    }
+    // Read README.md if available (HUMAN CONTEXT SOURCE)
+    let readmeData = {};
+    const readmePath = path_1.default.join(projectRoot, "README.md");
+    try {
+        const readmeContent = await fs_1.promises.readFile(readmePath, "utf-8");
+        readmeData = extractReadmeContext(readmeContent);
+    }
+    catch {
+        // Continue without README data
+    }
+    // Read package.json if available (JavaScript projects)
+    const packageJsonPath = await (0, file_utils_1.findPackageJson)(projectRoot);
+    let packageData = {};
+    if (packageJsonPath) {
+        try {
+            const content = await fs_1.promises.readFile(packageJsonPath, "utf-8");
+            packageData = JSON.parse(content);
+        }
+        catch {
+            // Continue without package.json data
+        }
+    }
+    // Read pyproject.toml if available (Python projects)
+    const pyprojectPath = await (0, file_utils_1.findPyprojectToml)(projectRoot);
+    let pyprojectData = {};
+    if (pyprojectPath) {
+        try {
+            const content = await fs_1.promises.readFile(pyprojectPath, "utf-8");
+            // Basic parsing for Python projects
+            if (content.includes('[tool.poetry]')) {
+                pyprojectData.packageManager = 'Poetry';
+            }
+            const nameMatch = content.match(/name\s*=\s*"([^"]+)"/);
+            if (nameMatch) {
+                pyprojectData.name = nameMatch[1];
+            }
+            const descMatch = content.match(/description\s*=\s*"([^"]+)"/);
+            if (descMatch) {
+                pyprojectData.description = descMatch[1];
+            }
+        }
+        catch {
+            // Continue without pyproject.toml data
+        }
+    }
+    // Read requirements.txt if available (Python projects)
+    const requirementsPath = await (0, file_utils_1.findRequirementsTxt)(projectRoot);
+    let requirementsData = {};
+    if (requirementsPath) {
+        try {
+            const content = await fs_1.promises.readFile(requirementsPath, "utf-8");
+            const lines = content.split('\n').filter(line => line && !line.startsWith('#'));
+            requirementsData.dependencies = lines;
+        }
+        catch {
+            // Continue without requirements.txt data
+        }
+    }
+    // 🏎️ CHAMPIONSHIP ENGINE - FAB-FORMATS Power Unit with 150+ handlers!
+    const fabProcessor = new fab_formats_processor_1.FabFormatsProcessor();
+    let fabAnalysis;
+    try {
+        fabAnalysis = await fabProcessor.processFiles(projectRoot);
+    }
+    catch {
+        // Fallback to empty analysis if discovery fails
+        fabAnalysis = {
+            results: [],
+            totalBonus: 0,
+            context: {},
+            qualityMetrics: {
+                highestGrade: 'MINIMAL',
+                averageScore: 0,
+                filesCovered: 0,
+                intelligenceDepth: 0
+            }
+        };
+    }
+    // 🏎️ AERO PACKAGE - RelentlessContextExtractor for human context!
+    let humanContext;
+    try {
+        humanContext = await relentless_context_extractor_1.relentlessExtractor.extractFromProject(projectRoot);
+    }
+    catch {
+        // Fallback to empty context
+        humanContext = null;
+    }
+    // TypeScript configuration analysis
+    const tsConfigPath = await (0, file_utils_1.findTsConfig)(projectRoot);
+    let tsContext = null;
+    if (tsConfigPath) {
+        const result = await (0, file_utils_1.analyzeTsConfig)(tsConfigPath);
+        if (result) {
+            tsContext = result;
+        }
+    }
+    // START ENHANCED SCORING - Championship grade with FAB-FORMATS!
+    let enhancedScore = 10; // Base score for having a project
+    // Map all discovered slots (21-slot system)
+    const contextSlotsFilled = {};
+    // IF: Quick mode data takes priority (user explicitly provided it)
+    if (options.projectGoal) {
+        contextSlotsFilled['project_goal'] = options.projectGoal;
+    }
+    if (options.projectName) {
+        contextSlotsFilled['project_name'] = options.projectName;
+    }
+    if (options.mainLanguage) {
+        contextSlotsFilled['main_language'] = options.mainLanguage;
+    }
+    if (options.framework && options.framework !== 'none') {
+        contextSlotsFilled['framework'] = options.framework;
+    }
+    if (options.hosting && options.hosting !== 'cloud') {
+        contextSlotsFilled['hosting'] = options.hosting;
+    }
+    // Apply championship context extraction
+    if (fabAnalysis.context) {
+        const ctx = fabAnalysis.context;
+        // Technical slots (15) - only fill if not already set by quick mode
+        if (ctx.projectName && !contextSlotsFilled['project_name'])
+            contextSlotsFilled['project_name'] = ctx.projectName;
+        if (ctx.projectGoal && !contextSlotsFilled['project_goal'])
+            contextSlotsFilled['project_goal'] = ctx.projectGoal;
+        if (ctx.mainLanguage)
+            contextSlotsFilled['main_language'] = ctx.mainLanguage;
+        if (ctx.framework)
+            contextSlotsFilled['framework'] = ctx.framework;
+        if (ctx.backend)
+            contextSlotsFilled['backend'] = ctx.backend;
+        if (ctx.server)
+            contextSlotsFilled['server'] = ctx.server;
+        if (ctx.apiType)
+            contextSlotsFilled['api_type'] = ctx.apiType;
+        if (ctx.database)
+            contextSlotsFilled['database'] = ctx.database;
+        if (ctx.hosting)
+            contextSlotsFilled['hosting'] = ctx.hosting;
+        if (ctx.cicd)
+            contextSlotsFilled['cicd'] = ctx.cicd;
+        if (ctx.buildTool)
+            contextSlotsFilled['build_tool'] = ctx.buildTool;
+        if (ctx.packageManager)
+            contextSlotsFilled['package_manager'] = ctx.packageManager;
+        if (ctx.testFramework)
+            contextSlotsFilled['test_framework'] = ctx.testFramework;
+        if (ctx.linter)
+            contextSlotsFilled['linter'] = ctx.linter;
+        // Human context slots (6 W's)
+        if (ctx.targetUser)
+            contextSlotsFilled['who'] = ctx.targetUser;
+        if (ctx.coreProblem)
+            contextSlotsFilled['what'] = ctx.coreProblem;
+        if (ctx.missionPurpose)
+            contextSlotsFilled['why'] = ctx.missionPurpose;
+        if (ctx.deploymentMarket)
+            contextSlotsFilled['where'] = ctx.deploymentMarket;
+        if (ctx.timeline)
+            contextSlotsFilled['when'] = ctx.timeline;
+        if (ctx.approach)
+            contextSlotsFilled['how'] = ctx.approach;
+    }
+    // Apply RELENTLESS human context extraction (overrides if higher confidence)
+    if (humanContext) {
+        if (humanContext.who.confidence === 'CERTAIN' || !contextSlotsFilled['who']) {
+            contextSlotsFilled['who'] = humanContext.who.value;
+        }
+        if (humanContext.what.confidence === 'CERTAIN' || !contextSlotsFilled['what']) {
+            contextSlotsFilled['what'] = humanContext.what.value;
+        }
+        if (humanContext.why.confidence === 'CERTAIN' || !contextSlotsFilled['why']) {
+            contextSlotsFilled['why'] = humanContext.why.value;
+        }
+        if (humanContext.where.confidence === 'CERTAIN' || !contextSlotsFilled['where']) {
+            contextSlotsFilled['where'] = humanContext.where.value;
+        }
+        if (humanContext.when.confidence === 'CERTAIN' || !contextSlotsFilled['when']) {
+            contextSlotsFilled['when'] = humanContext.when.value;
+        }
+        if (humanContext.how.confidence === 'CERTAIN' || !contextSlotsFilled['how']) {
+            contextSlotsFilled['how'] = humanContext.how.value;
+        }
+    }
+    // CLI-specific detection and smart slot reuse
+    const deps = {
+        ...packageData.dependencies,
+        ...packageData.devDependencies
+    };
+    const isCLI = packageData.bin ||
+        packageData.name?.includes('cli') ||
+        packageData.keywords?.includes('cli') ||
+        packageData.keywords?.includes('command-line') ||
+        deps?.commander ||
+        deps?.yargs ||
+        deps?.oclif ||
+        deps?.inquirer;
+    if (isCLI) {
+        // Smart slot reuse for CLI projects
+        contextSlotsFilled['framework'] = 'CLI'; // frontend = CLI
+        contextSlotsFilled['api_type'] = 'CLI';
+        contextSlotsFilled['hosting'] = 'npm registry';
+        contextSlotsFilled['backend'] = 'Node.js';
+        // Detect terminal UI framework
+        if (deps?.chalk)
+            contextSlotsFilled['css_framework'] = 'chalk (terminal colors)';
+        else if (deps?.colors)
+            contextSlotsFilled['css_framework'] = 'colors';
+        else if (deps?.ora)
+            contextSlotsFilled['css_framework'] = 'ora';
+        // Detect interactive framework
+        if (deps?.inquirer)
+            contextSlotsFilled['ui_library'] = 'inquirer (interactive prompts)';
+        else if (deps?.prompts)
+            contextSlotsFilled['ui_library'] = 'prompts';
+        else if (deps?.enquirer)
+            contextSlotsFilled['ui_library'] = 'enquirer';
+        // Detect CLI framework
+        if (deps?.commander)
+            contextSlotsFilled['cli_framework'] = 'commander';
+        else if (deps?.yargs)
+            contextSlotsFilled['cli_framework'] = 'yargs';
+        else if (deps?.oclif)
+            contextSlotsFilled['cli_framework'] = 'oclif';
+        // Detect runtime
+        if (packageData.engines?.node) {
+            contextSlotsFilled['runtime'] = `Node.js ${packageData.engines.node}`;
+        }
+        else {
+            contextSlotsFilled['runtime'] = 'Node.js v16+';
+        }
+        // Detect build system
+        if (deps?.typescript || deps?.['@types/node']) {
+            contextSlotsFilled['build_tool'] = 'TypeScript (tsc)';
+        }
+        // Detect testing
+        if (deps?.jest)
+            contextSlotsFilled['test_framework'] = 'Jest';
+        else if (deps?.mocha)
+            contextSlotsFilled['test_framework'] = 'Mocha';
+        else if (deps?.vitest)
+            contextSlotsFilled['test_framework'] = 'Vitest';
+        // Detect CI/CD - check for .github/workflows directory
+        try {
+            const githubWorkflowsPath = path_1.default.join(projectRoot, '.github', 'workflows');
+            const githubWorkflowsExists = await fs_1.promises.access(githubWorkflowsPath).then(() => true).catch(() => false);
+            if (githubWorkflowsExists) {
+                contextSlotsFilled['cicd'] = 'GitHub Actions';
+            }
+        }
+        catch {
+            // Continue without CI/CD detection
+        }
+    }
+    // Override with package.json if more specific
+    if (packageData.name && !contextSlotsFilled['project_name']) {
+        contextSlotsFilled['project_name'] = packageData.name;
+    }
+    if (packageData.description && !contextSlotsFilled['project_goal']) {
+        contextSlotsFilled['project_goal'] = packageData.description;
+    }
+    // Override with pyproject.toml for Python projects
+    if (pyprojectData.name && !contextSlotsFilled['project_name']) {
+        contextSlotsFilled['project_name'] = pyprojectData.name;
+    }
+    if (pyprojectData.description && !contextSlotsFilled['project_goal']) {
+        contextSlotsFilled['project_goal'] = pyprojectData.description;
+    }
+    // Apply README data (human context priority)
+    if (readmeData.projectName && !contextSlotsFilled['project_name']) {
+        contextSlotsFilled['project_name'] = readmeData.projectName;
+    }
+    if (readmeData.description && !contextSlotsFilled['project_goal']) {
+        contextSlotsFilled['project_goal'] = readmeData.description;
+    }
+    if (readmeData.targetUser && !contextSlotsFilled['who']) {
+        contextSlotsFilled['who'] = readmeData.targetUser;
+    }
+    // Calculate slot-based score
+    const technicalSlots = [
+        'project_name', 'project_goal', 'main_language', 'framework',
+        'backend', 'server', 'api_type', 'database', 'hosting',
+        'cicd', 'build_tool', 'package_manager', 'test_framework', 'linter'
+    ];
+    const humanSlots = ['who', 'what', 'why', 'where', 'when', 'how'];
+    let technicalFilled = 0;
+    let humanFilled = 0;
+    technicalSlots.forEach(slot => {
+        if (contextSlotsFilled[slot]) {
+            technicalFilled++;
+            enhancedScore += 4; // Each technical slot = 4%
+        }
+    });
+    humanSlots.forEach(slot => {
+        if (contextSlotsFilled[slot]) {
+            humanFilled++;
+            enhancedScore += 5; // Each human slot = 5%
+        }
+    });
+    // Quality bonuses from FAB-FORMATS
+    if (fabAnalysis.qualityMetrics) {
+        const grade = fabAnalysis.qualityMetrics.highestGrade;
+        if (grade === 'EXCEPTIONAL') {
+            enhancedScore += 20;
+        }
+        else if (grade === 'PROFESSIONAL') {
+            enhancedScore += 15;
+        }
+        else if (grade === 'GOOD') {
+            enhancedScore += 10;
+        }
+        else if (grade === 'BASIC') {
+            enhancedScore += 5;
+        }
+    }
+    // Intelligence depth bonus
+    if (fabAnalysis.qualityMetrics.intelligenceDepth > 80) {
+        enhancedScore += 15;
+    }
+    else if (fabAnalysis.qualityMetrics.intelligenceDepth > 60) {
+        enhancedScore += 10;
+    }
+    else if (fabAnalysis.qualityMetrics.intelligenceDepth > 40) {
+        enhancedScore += 5;
+    }
+    // TypeScript bonus
+    if (tsContext) {
+        enhancedScore += 5;
+        if (tsContext.strictMode) {
+            enhancedScore += 5;
+        }
+    }
+    // Cap at 99% (100% requires human verification)
+    const fafScore = Math.min(Math.round(enhancedScore), 99);
+    // Build confidence level
+    let confidence = 'LOW';
+    if (fafScore >= 85)
+        confidence = 'HIGH';
+    else if (fafScore >= 70)
+        confidence = 'GOOD';
+    else if (fafScore >= 50)
+        confidence = 'MODERATE';
+    // Build quality indicators
+    const qualityIndicators = [];
+    if (fabAnalysis.qualityMetrics.highestGrade === 'EXCEPTIONAL') {
+        qualityIndicators.push('Exceptional project structure');
+    }
+    if (fabAnalysis.qualityMetrics.filesCovered > 10) {
+        qualityIndicators.push('Comprehensive file coverage');
+    }
+    if (technicalFilled >= 10) {
+        qualityIndicators.push('Rich technical context');
+    }
+    if (humanFilled >= 3) {
+        qualityIndicators.push('Strong human context');
+    }
+    if (tsContext?.strictMode) {
+        qualityIndicators.push('TypeScript strict mode');
+    }
+    // Extract the stack for display
+    const stack = {
+        frontend: contextSlotsFilled['framework'] || packageData.dependencies?.react ? 'React' : undefined,
+        backend: contextSlotsFilled['backend'],
+        database: contextSlotsFilled['database'],
+        build: contextSlotsFilled['build_tool'],
+        package_manager: contextSlotsFilled['package_manager'] || 'npm',
+        hosting: contextSlotsFilled['hosting'],
+    };
+    // Build the data structure for generateFafContent
+    const fafData = {
+        projectName: contextSlotsFilled['project_name'] || path_1.default.basename(projectRoot),
+        projectGoal: contextSlotsFilled['project_goal'] || 'Build amazing software',
+        mainLanguage: contextSlotsFilled['main_language'] || 'JavaScript',
+        framework: contextSlotsFilled['framework'] || 'None',
+        cssFramework: contextSlotsFilled['css_framework'] || undefined,
+        uiLibrary: contextSlotsFilled['ui_library'] || undefined,
+        stateManagement: undefined,
+        backend: contextSlotsFilled['backend'] || 'None',
+        apiType: contextSlotsFilled['api_type'] || 'REST',
+        server: contextSlotsFilled['runtime'] || contextSlotsFilled['server'] || 'None',
+        database: contextSlotsFilled['database'] || 'None',
+        connection: 'None',
+        hosting: contextSlotsFilled['hosting'] || 'None',
+        buildTool: contextSlotsFilled['build_tool'] || 'None',
+        packageManager: contextSlotsFilled['package_manager'] || 'npm',
+        cicd: contextSlotsFilled['cicd'] || 'None',
+        fafScore,
+        slotBasedPercentage: Math.round(((technicalFilled + humanFilled) / 21) * 100),
+        projectType, // Pass project type for compiler slot-filling patterns
+        // Human Context (Project Details)
+        targetUser: contextSlotsFilled['who'],
+        coreProblem: contextSlotsFilled['what'],
+        missionPurpose: contextSlotsFilled['why'],
+        deploymentMarket: contextSlotsFilled['where'],
+        timeline: contextSlotsFilled['when'],
+        approach: contextSlotsFilled['how'],
+        // Quality indicators
+        qualityIndicators,
+        fabFormatsIntelligence: {
+            filesAnalyzed: fabAnalysis.results.length,
+            totalIntelligence: fabAnalysis.totalBonus,
+            highestGrade: fabAnalysis.qualityMetrics.highestGrade,
+            depth: fabAnalysis.qualityMetrics.intelligenceDepth
+        }
+    };
+    // Generate YAML content
+    const content = (0, yaml_generator_1.generateFafContent)(fafData);
+    return content;
+}
+/**
+ * Extract context from README.md
+ */
+function extractReadmeContext(content) {
+    const context = {};
+    // Extract project name from title
+    const titleMatch = content.match(/^#\s+(.+)$/m);
+    if (titleMatch) {
+        context.projectName = titleMatch[1].trim();
+    }
+    // Extract description from first paragraph or description section
+    const descMatch = content.match(/^#+\s+(?:description|about|overview|introduction)\s*\n+(.+?)(?:\n#|\n\n#|$)/ims);
+    if (descMatch) {
+        context.description = descMatch[1].trim().substring(0, 200);
+    }
+    else {
+        // Try to get first paragraph after title
+        const firstParaMatch = content.match(/^#\s+.+\n+(.+?)(?:\n#|\n\n#|$)/ms);
+        if (firstParaMatch) {
+            context.description = firstParaMatch[1].trim().substring(0, 200);
+        }
+    }
+    // Look for target users
+    if (content.match(/##\s+(?:for\s+)?(?:developers|engineers|teams)/i)) {
+        context.targetUser = 'Developers';
+    }
+    else if (content.match(/##\s+(?:for\s+)?(?:users|customers|clients)/i)) {
+        context.targetUser = 'End users';
+    }
+    return context;
+}
+//# sourceMappingURL=faf-generator-championship.js.map