mycontext-cli 4.2.15 → 4.2.17

package/dist/commands/generate.js

@@ -90,29 +90,16 @@ class GenerateCommand {
                 case "context":
                 case "prd":
                 case "requirements":
+                    // Check if user wants full context generation (PRD + A/B/C/D files)
                     // Check if user wants full context generation (PRD + A/B/C/D files)
                     if (options.full) {
                         // Generate both PRD and A/B/C/D files
                         result = await this.generateFullContext(projectContext, options);
                     }
                     else {
-                        // Default: Generate A/B/C/D files (requires existing PRD)
-                        // This is the expected behavior for 'mycontext generate context'
-                        // Use the dedicated GenerateContextFilesCommand for proper handling
-                        const { GenerateContextFilesCommand } = await Promise.resolve().then(() => __importStar(require("./generate-context-files")));
-                        const contextFilesCommand = new GenerateContextFilesCommand();
-                        await contextFilesCommand.execute({
-                            description: projectContext.description,
-                            projectPath: this.getProjectRoot(),
-                            verbose: options.verbose,
-                            force: options.force,
-                        });
-                        result = {
-                            success: true,
-                            content: "Context files generated successfully",
-                            provider: "hybrid",
-                            metadata: { model: "hybrid", tokens: 0, latency: 0 },
-                        };
+                        // Default: Direct to full generation as the new standard
+                        console.log(chalk_1.default.blue("ℹ️  Note: 'generate context' now defaults to full brain synchronization."));
+                        result = await this.generateFullContext(projectContext, options);
                     }
                     break;
                 case "types":
@@ -658,9 +645,11 @@ Use the business entities from the context above, not generic types.`;
             const hasLocalKeys = this.hasLocalAIKeys();
             if (hasLocalKeys) {
                 // Use local AI first (user's own keys)
-                this.spinner.updateText(`🔧 Generating TypeScript types with ${await this.ai.getActiveProviderName()}...`);
+                // DEFAULT to gpt-4o-mini for planning tasks to avoid 8k token limits
+                const model = options.model || process.env.MYCONTEXT_MODEL || "gpt-4o-mini";
+                this.spinner.updateText(`🔧 Generating TypeScript types with ${await this.ai.getActiveProviderName()} (${model})...`);
                 const { text, provider } = await this.ai.generateText(prompt, {
-                    model: options.model || process.env.MYCONTEXT_MODEL,
+                    model,
                     modelCandidates: this.getModelCandidates(options),
                     spinnerCallback: (text, resetTimer = false) => {
                         this.spinner.updateText(text);
@@ -671,6 +660,13 @@ Use the business entities from the context above, not generic types.`;
                 });
                 // Parse the generated content and create structured files
                 const structuredContent = this.parseAndStructureTypes(text);
+                // Update SSOT (Brain)
+                await this.updateLivingContext({
+                    metadata: {
+                        lastUpdatedAt: new Date().toISOString(),
+                        status: "types-generated"
+                    }
+                });
                 // Check if AI generated generic types (fallback detection)
                 if ((0, typeTemplateGenerator_1.isGenericTypes)(structuredContent)) {
                     console.log("⚠️  AI generated generic types, using template fallback...");
@@ -923,11 +919,27 @@ Use the business entities from the context above, not generic types.`;
         }
         return contextContent;
     }
+    truncateContext(text, maxChars = 4000) {
+        if (!text || text.length <= maxChars)
+            return text;
+        return text.substring(0, maxChars) + "\n\n... [TRUNCATED FOR TOKENS] ...";
+    }
     /**
      * Unified method to load all context files for consistent discovery
      */
     async loadAllContextFiles() {
         const projectRoot = this.getProjectRoot();
+        const livingBrain = await this.loadLivingContext();
+        if (livingBrain) {
+            return {
+                prd: livingBrain.prd.title + "\n" + livingBrain.prd.problemStatement,
+                features: livingBrain.features.map(f => `${f.name}: ${f.description}`).join("\n"),
+                userFlows: livingBrain.flows.map(f => `${f.name}: ${f.steps.join(", ")}`).join("\n"),
+                edgeCases: livingBrain.edgeCases.map(e => `${e.category}: ${e.description}`).join("\n"),
+                technicalSpecs: livingBrain.specs.architecture,
+                hasContext: true,
+            };
+        }
         const contextDir = path_1.default.join(projectRoot, ".mycontext");
         const readOrEmpty = async (filePath) => {
             if (await fs.pathExists(filePath)) {
@@ -1774,9 +1786,11 @@ Make the CSS immediately usable - no placeholders, actual working values!`;
             const hasLocalKeys = this.hasLocalAIKeys();
             if (hasLocalKeys) {
                 // Use local AI first (user's own keys)
-                this.spinner.updateText(`🎨 Generating brand system with ${await this.ai.getActiveProviderName()}...`);
+                // DEFAULT to gpt-4o-mini for planning tasks to avoid 8k token limits
+                const model = options.model || process.env.MYCONTEXT_MODEL || "gpt-4o-mini";
+                this.spinner.updateText(`🎨 Generating brand system with ${await this.ai.getActiveProviderName()} (${model})...`);
                 const { text, provider } = await this.ai.generateText(prompt, {
-                    model: options.model || process.env.MYCONTEXT_MODEL,
+                    model,
                     modelCandidates: this.getModelCandidates(options),
                     spinnerCallback: (text, resetTimer = false) => {
                         this.spinner.updateText(text);
@@ -1787,6 +1801,13 @@ Make the CSS immediately usable - no placeholders, actual working values!`;
                 });
                 // Parse and create the brand system files
                 const brandFiles = this.parseAndCreateBrandSystem(text);
+                // Update SSOT (Brain)
+                await this.updateLivingContext({
+                    metadata: {
+                        lastUpdatedAt: new Date().toISOString(),
+                        status: "brand-generated"
+                    }
+                });
                 return {
                     success: true,
                     content: brandFiles.guide,
@@ -1891,23 +1912,37 @@ Make the CSS immediately usable - no placeholders, actual working values!`;
         }
     }
     async generateComponentList(projectContext, options) {
+        // 1. Try to load from Living Brain first
+        const livingContext = await this.loadLivingContext();
+        if (livingContext && livingContext.components && livingContext.components.length > 0 && !options.force) {
+            this.spinner.updateText("📋 Using component architecture from Living Brain...");
+            return {
+                success: true,
+                content: JSON.stringify(livingContext.components, null, 2),
+                provider: "local",
+                metadata: {
+                    model: "static",
+                    tokens: 0,
+                    latency: 0,
+                },
+            };
+        }
+        // 2. Fallback to AI generation if brain is empty or force is used
+        this.spinner.updateText("📋 Discovering component architecture via AI...");
         // Load comprehensive context for better component generation
         const allContext = await this.loadAllContextFiles();
         const ctx = await this.readContextArtifacts();
-        // Note: No core readiness check here - components-list generation should happen
-        // before any core component is selected and refined
         const coreExcerpt = await this.readCoreExcerpt();
+        // DEFAULT to gpt-4o-mini for planning tasks to avoid 8k token limits
+        const model = options.model || process.env.MYCONTEXT_MODEL || "gpt-4o-mini";
         const prompt = [
-            `[mycontext] Plan: plan → generate → QA → docs → preview (→ checks)`,
-            `Create a detailed, business-specific component list for: ${projectContext.description || "MyContext project"}`,
+            `[mycontext] Planning: Identify and decompose components for: ${projectContext.description || "MyContext project"}`,
             "",
-            "IMPORTANT: Use the detailed business context below to create components that directly implement the specific features, user stories, and acceptance criteria described. Extract exact feature names, user roles, and business requirements to generate precise, domain-specific components.",
-            "",
-            "Example: If the context mentions 'Mobile Order Entry' with specific acceptance criteria like 'Given a front office user is logged in, When they enter an order via a mobile device, Then the order should be saved and synced to the backend', create a component like 'MobileOrderEntry' with a description that references these specific requirements.",
+            "IMPORTANT: Use the detailed business context below to create components that directly implement the specific features described. Group components by domain (e.g., Auth, Dashboard, Billing).",
             "",
             ...(coreExcerpt
                 ? [
-                    "Core component excerpt (use for visual/style consistency):",
+                    "Core component style (use for reference):",
                     coreExcerpt,
                     "",
                 ]
@@ -1915,90 +1950,38 @@ Make the CSS immediately usable - no placeholders, actual working values!`;
             "Business Context:",
             allContext.hasContext
                 ? [
-                    allContext.prd ? `## PRD\n${allContext.prd}` : "",
-                    allContext.features ? `## Features\n${allContext.features}` : "",
-                    allContext.userFlows
-                        ? `## User Flows\n${allContext.userFlows}`
-                        : "",
-                    allContext.edgeCases
-                        ? `## Edge Cases\n${allContext.edgeCases}`
-                        : "",
-                    allContext.technicalSpecs
-                        ? `## Technical Specs\n${allContext.technicalSpecs}`
-                        : "",
+                    allContext.prd ? `## PRD\n${this.truncateContext(allContext.prd)}` : "",
+                    allContext.features ? `## Features\n${this.truncateContext(allContext.features)}` : "",
+                    allContext.userFlows ? `## User Flows\n${this.truncateContext(allContext.userFlows)}` : "",
+                    allContext.technicalSpecs ? `## Technical Specs\n${this.truncateContext(allContext.technicalSpecs)}` : "",
                 ]
                     .filter(Boolean)
                     .join("\n\n")
-                : ctx.prd.split("\n").slice(0, 60).join("\n"),
+                : this.truncateContext(ctx.prd, 2000),
             "",
-            "Types excerpt:",
-            ctx.types.split("\n").slice(0, 80).join("\n"),
+            "Types Summary:",
+            this.truncateContext(ctx.types, 3000),
             "",
-            "Branding excerpt:",
-            ctx.brand.split("\n").slice(0, 40).join("\n"),
+            "Branding Summary:",
+            this.truncateContext(ctx.brand, 1500),
             "",
-            "Available shadcn/ui primitives (import from '@/components/ui/<component>'):",
+            "Available shadcn/ui primitives:",
             (ctx.shadcn.length ? ctx.shadcn : this.getCanonicalShadcnList())
                 .slice(0, 60)
                 .join(", "),
             "",
-            "Return strictly valid JSON ONLY with this HIERARCHICAL structure:",
+            "Return strictly valid JSON with this structure:",
             "{",
-            '  "ApplicationName": {',
-            '    "description": "Main application component",',
-            '    "progress": { "completed": 0, "total": 0 },',
-            '    "children": {',
-            '      "Header": {',
-            '        "description": "Application header section",',
-            '        "progress": { "completed": 0, "total": 0 },',
-            '        "children": {',
-            '          "Logo": { "description": "Company logo", "type": "display" },',
-            '          "Navigation": { "description": "Main navigation", "type": "interactive" }',
-            "        }",
-            "      },",
-            '      "Main": {',
-            '        "description": "Main content area",',
-            '        "progress": { "completed": 0, "total": 0 },',
-            '        "children": {',
-            '          "BusinessSection1": {',
-            '            "description": "First business domain section",',
-            '            "progress": { "completed": 0, "total": 0 },',
-            '            "children": {',
-            '              "SubComponent1": { "description": "Specific business component", "type": "form" },',
-            '              "SubComponent2": { "description": "Another business component", "type": "display" }',
-            "            }",
-            "          }",
-            "        }",
-            "      }",
-            "    }",
-            "  },",
-            '  "metadata": {',
-            '    "coreCandidates": [',
-            '      { "name": string, "path": string, "reason": string },',
-            '      { "name": string, "path": string, "reason": string }',
-            "    ],",
-            '    "totalComponents": 0,',
-            '    "completedComponents": 0',
-            "  }",
+            '  "components": [',
+            '    { "name": "ComponentName", "description": "Specific purpose", "type": "form|layout|display|interactive", "group": "GroupName", "status": "planned" }',
+            "  ],",
+            '  "metadata": { "totalComponents": 0 }',
             "}",
             "",
             "Rules:",
-            "- Create a HIERARCHICAL component structure that mirrors React component composition",
-            "- Start with the main application component as the root",
-            "- Nest components from largest to smallest (App -> Sections -> SubComponents -> Atomic Components)",
-            "- Each component should have: description, progress tracking, and children (if any)",
-            "- Progress tracking: { completed: 0, total: 0 } - total counts all nested components",
-            "- CRITICAL: Use the SPECIFIC business context above to generate detailed, domain-specific components",
-            "- Extract specific feature names, user stories, and acceptance criteria from the context",
-            "- Create components that directly implement the features described in the context",
-            "- Use the exact terminology and business language from the context",
-            "- Group by business domain in the hierarchy (e.g., 'OrderManagement', 'InventoryManagement')",
-            "- Each leaf component should have a 'type' field: 'layout', 'display', 'interactive', 'form'",
-            "- Component descriptions should reference specific business requirements from the context",
-            "- No code fences, no comments, no trailing commas.",
-            "- Use only the fields above.",
-            "- Ensure arrays/objects have no extra commas.",
-            "- Provide 2-3 'coreCandidates' with their full path in the hierarchy.",
+            "- Logical React composition starting from root",
+            "- Extract specific feature terminology from context",
+            "- Return ONLY JSON - no markdown fences.",
         ].join("\n");
         try {
             // Check if user has local AI keys configured
@@ -2007,10 +1990,9 @@ Make the CSS immediately usable - no placeholders, actual working values!`;
             let provider;
             if (hasLocalKeys) {
                 // Use local AI first (user's own keys)
-                this.spinner.updateText(`📋 Generating component list with ${await this.ai.getActiveProviderName()}...`);
                 try {
                     const r = await this.ai.generateText(prompt, {
-                        model: options.model || process.env.MYCONTEXT_MODEL,
+                        model,
                         modelCandidates: this.getModelCandidates(options),
                         spinnerCallback: (text, resetTimer = false) => {
                             this.spinner.updateText(text);
@@ -2023,12 +2005,12 @@ Make the CSS immediately usable - no placeholders, actual working values!`;
                     provider = r.provider;
                 }
                 catch (e) {
-                    // Handle transient network issues like unexpected EOF with a single retry
+                    // Retry logic (existing)
                     const msg = String(e?.message || e);
                     if (/unexpected EOF|ECONNRESET|EPIPE/i.test(msg)) {
-                        this.spinner.updateText("Retrying component list generation after transient error...");
+                        this.spinner.updateText("Retrying component list generation...");
                         const r2 = await this.ai.generateText(prompt, {
-                            model: options.model || process.env.MYCONTEXT_MODEL,
+                            model,
                             modelCandidates: this.getModelCandidates(options),
                             spinnerCallback: (text, resetTimer = false) => {
                                 this.spinner.updateText(text);
@@ -2047,7 +2029,6 @@ Make the CSS immediately usable - no placeholders, actual working values!`;
             }
             else {
                 // No local keys - use hosted API (requires authentication)
-                this.spinner.updateText("📋 Generating component list with MyContext AI (hosted)...");
                 const hostedResult = await this.hostedApi.generateContext("components-list", prompt, {
                     model: options.model || "mycontext",
                     context: projectContext,
@@ -2063,6 +2044,21 @@ Make the CSS immediately usable - no placeholders, actual working values!`;
             // Attempt to repair and extract valid JSON
             const repaired = this.repairJson(text);
             const cleanedContent = this.extractJson(repaired);
+            // Update SSOT (Brain)
+            try {
+                const obj = JSON.parse(cleanedContent);
+                await this.updateLivingContext({
+                    metadata: {
+                        lastUpdatedAt: new Date().toISOString(),
+                        status: "components-planned"
+                    }
+                    // Note: Full component hierarchy is heavy, keep in 04-component-list.json for now
+                    // or we could flatten and store in context.json.components
+                });
+            }
+            catch (e) {
+                // ignore parse errors for SSOT update; saveGeneratedContent will handle it later
+            }
             // Attach rich context so JSON alone is enough for component generation
             try {
                 console.log(`[GenerateCommand] Attempting to parse cleaned content (first 200 chars): ${cleanedContent.slice(0, 200)}...`);
@@ -3529,35 +3525,128 @@ export function Typography({ variant, children, className }: TypographyProps) {
         // 5) Fallback: wrap into minimal valid envelope
         return JSON.stringify({ error: "Invalid JSON from AI", raw: raw.slice(0, 500) }, null, 2);
     }
+    async loadLivingContext() {
+        try {
+            const contextPath = path_1.default.join(this.getProjectRoot(), ".mycontext", "context.json");
+            if (await fs.pathExists(contextPath)) {
+                return await fs.readJson(contextPath);
+            }
+        }
+        catch (e) {
+            // ignore
+        }
+        return null;
+    }
+    async updateLivingContext(update) {
+        try {
+            const projectRoot = this.getProjectRoot();
+            const contextPath = path_1.default.join(projectRoot, ".mycontext", "context.json");
+            let current = await this.loadLivingContext();
+            if (!current) {
+                // Fallback to empty context if it doesn't exist
+                current = {
+                    metadata: {
+                        version: "1.0.0",
+                        generatedAt: new Date().toISOString(),
+                        lastUpdatedAt: new Date().toISOString(),
+                        projectConfig: {
+                            id: require("crypto").randomUUID(),
+                            name: "MyContext Project",
+                            description: "",
+                            createdAt: new Date().toISOString(),
+                            updatedAt: new Date().toISOString(),
+                            contextPath: ".mycontext",
+                            version: "0.1.0",
+                            status: "initialized"
+                        }
+                    },
+                    prd: { title: "", problemStatement: "", goals: [], targetAudience: "", successMetrics: [] },
+                    features: [],
+                    flows: [],
+                    edgeCases: [],
+                    specs: {
+                        architecture: "",
+                        techStack: { frontend: [], backend: [], database: [], other: [] },
+                        apiEndpoints: [],
+                        databaseSchema: { tables: [] }
+                    },
+                    components: [],
+                    actions: [],
+                    routes: [],
+                    brain: { memory: {}, logs: [] }
+                };
+            }
+            const { deepMerge } = await Promise.resolve().then(() => __importStar(require("../utils/deepMerge")));
+            const merged = deepMerge(current, update);
+            merged.metadata.lastUpdatedAt = new Date().toISOString();
+            await fs.writeJson(contextPath, merged, { spaces: 2 });
+        }
+        catch (e) {
+            console.log(chalk_1.default.yellow(`⚠️  Failed to update context.json: ${e instanceof Error ? e.message : String(e)}`));
+        }
+    }
     async readContextArtifacts() {
         try {
-            const cwd = process.cwd();
-            const readOrEmpty = async (rel) => (await fs.pathExists(path_1.default.join(cwd, rel)))
-                ? await fs.readFile(path_1.default.join(cwd, rel), "utf8")
-                : "";
-            // Prefer split files if present
+            const cwd = this.getProjectRoot();
+            const livingBrain = await this.loadLivingContext();
             let prd = "";
-            const brief = (await readOrEmpty(".mycontext/01a-brief.md")) ||
-                (await readOrEmpty(".mycontext/01-brief.md"));
-            const reqs = (await readOrEmpty(".mycontext/01b-requirements.md")) ||
-                (await readOrEmpty(".mycontext/02-requirements.md"));
-            const flows = (await readOrEmpty(".mycontext/01c-flows.md")) ||
-                (await readOrEmpty(".mycontext/03-flows.md"));
-            if (brief || reqs || flows) {
+            let types = "";
+            let brand = "";
+            if (livingBrain) {
+                // Build PRD string from JSON
                 prd = [
-                    brief ? "## Brief\n\n" + brief : "",
-                    reqs ? "\n\n## Requirements\n\n" + reqs : "",
-                    flows ? "\n\n## Flows\n\n" + flows : "",
-                ]
-                    .filter(Boolean)
-                    .join("");
+                    `# ${livingBrain.prd.title}`,
+                    `## Problem Statement\n${livingBrain.prd.problemStatement}`,
+                    `## Goals\n${livingBrain.prd.goals.map(g => `- ${g}`).join("\n")}`,
+                    livingBrain.features.length ? `## Features\n${livingBrain.features.map(f => `### ${f.name} (${f.priority})\n${f.description}`).join("\n\n")}` : "",
+                    livingBrain.flows.length ? `## Flows\n${livingBrain.flows.map(f => `### ${f.name}\n${f.steps.join("\n")}`).join("\n\n")}` : ""
+                ].filter(Boolean).join("\n\n");
             }
+            const readOrEmpty = async (rel) => (await fs.pathExists(path_1.default.join(cwd, rel)))
+                ? await fs.readFile(path_1.default.join(cwd, rel), "utf8")
+                : "";
+            // Fallback/Augment PRD from files if JSON is sparse
             if (!prd) {
-                prd = await readOrEmpty(".mycontext/01-prd.md");
+                const brief = (await readOrEmpty(".mycontext/01a-brief.md")) || (await readOrEmpty(".mycontext/01-brief.md"));
+                const reqs = (await readOrEmpty(".mycontext/01b-requirements.md")) || (await readOrEmpty(".mycontext/02-requirements.md"));
+                const flows = (await readOrEmpty(".mycontext/01c-flows.md")) || (await readOrEmpty(".mycontext/03-flows.md"));
+                if (brief || reqs || flows) {
+                    prd = [
+                        brief ? "## Brief\n\n" + brief : "",
+                        reqs ? "\n\n## Requirements\n\n" + reqs : "",
+                        flows ? "\n\n## Flows\n\n" + flows : "",
+                    ].filter(Boolean).join("");
+                }
+                if (!prd) {
+                    prd = await readOrEmpty(".mycontext/01-prd.md");
+                }
+            }
+            // Discover Types (Modern Multi-file)
+            const typesDir = path_1.default.join(cwd, ".mycontext", "types");
+            if (await fs.pathExists(typesDir)) {
+                const files = await fs.readdir(typesDir);
+                const typeFiles = files.filter(f => f.endsWith(".ts"));
+                for (const file of typeFiles) {
+                    const content = await fs.readFile(path_1.default.join(typesDir, file), "utf8");
+                    types += `\n// --- ${file} ---\n${content}\n`;
+                }
+            }
+            if (!types) {
+                types = (await readOrEmpty(".mycontext/02-types.ts")) || (await readOrEmpty(".mycontext/02-types-guide.md"));
+            }
+            // Discover Brand (Modern Multi-file)
+            const brandDir = path_1.default.join(cwd, ".mycontext", "brand");
+            if (await fs.pathExists(brandDir)) {
+                brand = await readOrEmpty(".mycontext/brand/globals.css");
+                const brandFiles = await fs.readdir(brandDir);
+                for (const file of brandFiles.filter(f => f.endsWith(".md"))) {
+                    const content = await fs.readFile(path_1.default.join(brandDir, file), "utf8");
+                    brand += `\n\n### ${file}\n${content}`;
+                }
+            }
+            if (!brand) {
+                brand = (await readOrEmpty(".mycontext/03-branding.md")) || (await readOrEmpty(".mycontext/03-branding-guide.md"));
             }
-            const types = await readOrEmpty(".mycontext/02-types.ts");
-            const brand = (await readOrEmpty(".mycontext/brand/globals.css")) ||
-                (await readOrEmpty(".mycontext/03-branding.md"));
             // discover shadcn/ui primitives from components/ui
             const uiDir = path_1.default.join(cwd, "components", "ui");
             let shadcn = [];
@@ -3836,35 +3925,7 @@ ${isEcommerce
         return aliases[type] || type;
     }
     hasLocalAIKeys() {
-        // Check for any local AI provider keys
-        const keys = {
-            github: !!process.env.MYCONTEXT_GITHUB_TOKEN,
-            qwen: !!process.env.MYCONTEXT_QWEN_API_KEY,
-            gemini: !!(process.env.GEMINI_API_KEY ||
-                process.env.GOOGLE_API_KEY ||
-                process.env.MYCONTEXT_GEMINI_API_KEY),
-            xai: !!(process.env.MYCONTEXT_XAI_API_KEY || process.env.XAI_API_KEY),
-            claude: !!process.env.MYCONTEXT_CLAUDE_API_KEY,
-            openai: !!process.env.OPENAI_API_KEY,
-            anthropic: !!process.env.ANTHROPIC_API_KEY,
-            huggingface: !!process.env.HUGGINGFACE_API_KEY,
-            openrouter: !!(process.env.MYCONTEXT_OPENROUTER_API_KEY ||
-                process.env.OPENROUTER_API_KEY),
-        };
-        console.log(`[GenerateCommand] API Keys detected:`, keys);
-        return !!(process.env.MYCONTEXT_GITHUB_TOKEN ||
-            process.env.MYCONTEXT_QWEN_API_KEY ||
-            process.env.GEMINI_API_KEY ||
-            process.env.GOOGLE_API_KEY ||
-            process.env.MYCONTEXT_GEMINI_API_KEY ||
-            process.env.MYCONTEXT_XAI_API_KEY ||
-            process.env.XAI_API_KEY ||
-            process.env.MYCONTEXT_CLAUDE_API_KEY ||
-            process.env.OPENAI_API_KEY ||
-            process.env.ANTHROPIC_API_KEY ||
-            process.env.HUGGINGFACE_API_KEY ||
-            process.env.MYCONTEXT_OPENROUTER_API_KEY ||
-            process.env.OPENROUTER_API_KEY);
+        return AICore_1.AICore.getInstance().hasAnyProvider();
     }
     getModelCandidates(options) {
         const raw = options.modelCandidates ||
@@ -3956,7 +4017,8 @@ INSTRUCTIONS:
 1. Analyze the project details provided above (which may include file structure, tech stack, and README summary).
 2. Extract functional requirements, user flows, and technical limits.
 3. If the description includes a file tree, infer the project architecture from it.
-4. Generate a complete PRD and Technical Spec that reflects this ACTUAL existing project.
+4. Identify all necessary UI components and group them logically (e.g. Auth, Sidebar, Dashboard).
+5. Generate a complete PRD, Technical Spec, and Component Architecture that reflects this ACTUAL existing project.
 `;
         }
         // The schema for LivingContext (simplified version for the LLM)
@@ -3966,12 +4028,31 @@ INSTRUCTIONS:
   "features": [{ "id": "...", "name": "...", "description": "...", "priority": "high|medium|low", "userValue": "...", "acceptanceCriteria": [], "dependencies": [] }],
   "flows": [{ "id": "...", "name": "...", "description": "...", "steps": [], "actors": [] }],
   "edgeCases": [{ "id": "...", "category": "...", "description": "...", "mitigation": "..." }],
+  "brand": {
+    "theme": "light|dark",
+    "colors": { "primary": "#...", "background": "#...", "text": "#...", "accent": "#..." },
+    "typography": { "fontFamily": "...", "headingScale": "..." },
+    "designPrinciples": []
+  },
+  "types": {
+    "entities": [{ "name": "...", "description": "...", "schema": "export interface ... { ... }" }],
+    "shared": [{ "name": "...", "description": "...", "schema": "export interface ... { ... }" }]
+  },
   "specs": {
     "architecture": "...",
     "techStack": { "frontend": [], "backend": [], "database": [], "other": [] },
     "apiEndpoints": [{ "path": "...", "method": "...", "description": "...", "authRequired": true }],
     "databaseSchema": { "tables": [{ "name": "...", "columns": [{ "name": "...", "type": "...", "constraints": [] }] }] }
-  }
+  },
+  "components": [
+    {
+       "name": "ComponentName",
+       "description": "...",
+       "type": "form|layout|display|interactive",
+       "group": "Auth|Dashboard|etc",
+       "status": "planned"
+    }
+  ]
 }
 `;
         const livingContextData = await aiCore.generateStructuredText(prompt, schema);
@@ -4019,6 +4100,9 @@ INSTRUCTIONS:
                 { name: "01b-user-flows.md", content: contextRenderer_1.ContextRenderer.renderUserFlows(livingContext) },
                 { name: "01c-edge-cases.md", content: contextRenderer_1.ContextRenderer.renderEdgeCases(livingContext) },
                 { name: "01d-technical-specs.md", content: contextRenderer_1.ContextRenderer.renderTechnicalSpecs(livingContext) },
+                { name: "02-types-guide.md", content: contextRenderer_1.ContextRenderer.renderTypesGuide(livingContext) },
+                { name: "03-brand-guide.md", content: contextRenderer_1.ContextRenderer.renderBrandGuide(livingContext) },
+                { name: "04-component-list.md", content: contextRenderer_1.ContextRenderer.renderComponentList(livingContext) },
             ];
             for (const render of renders) {
                 const filePath = path_1.default.join(mycontextDir, render.name);