mycontext-cli 0.1.0

package/dist/cli/src/commands/generate.js

@@ -0,0 +1,1984 @@
+"use strict";
+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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenerateCommand = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const prompts_1 = __importDefault(require("prompts"));
+const path_1 = __importDefault(require("path"));
+const spinner_1 = require("../utils/spinner");
+const fileSystem_1 = require("../utils/fileSystem");
+class GenerateCommand {
+    constructor() {
+        this.fs = new fileSystem_1.FileSystemManager();
+    }
+    /**
+     * Sanitizes a group name for use as a directory or route segment.
+     * - Lowercase
+     * - Replace spaces and & with dashes
+     * - Remove all other special characters
+     * - Collapse multiple dashes
+     * - Trim leading/trailing dashes
+     */
+    sanitizeGroupName(name) {
+        return name
+            .toLowerCase()
+            .replace(/\s+/g, "-") // Replace spaces with dash
+            .replace(/\s*&\s*/g, "-") // Replace spaces and & with dash
+            .replace(/[^a-z0-9-]/g, "") // Remove all non-alphanumeric/dash
+            .replace(/-+/g, "-") // Collapse multiple dashes
+            .replace(/^-+|-+$/g, ""); // Trim leading/trailing dashes
+    }
+    async execute(target, options) {
+        const spinner = new spinner_1.EnhancedSpinner("Generating content...");
+        const startTime = Date.now();
+        let success = false;
+        let error;
+        try {
+            console.log(chalk_1.default.blue.bold("🚀 MyContext Generation\n"));
+            // Determine generation type
+            const generationType = options.type || target;
+            switch (generationType) {
+                case "context":
+                    await this.generateContext(options, spinner);
+                    break;
+                case "types":
+                    await this.generateTypes(options, spinner);
+                    break;
+                case "brand":
+                    await this.generateBrand(options, spinner);
+                    break;
+                case "components-list":
+                    await this.generateComponentsList(options, spinner);
+                    break;
+                case "components":
+                    await this.generateComponents(options, spinner);
+                    break;
+                case "app-structure":
+                    await this.generateAppStructure(options, spinner);
+                    break;
+                default:
+                    throw new Error(`Unknown generation type: ${generationType}`);
+            }
+            success = true;
+        }
+        catch (err) {
+            error = err instanceof Error ? err.message : "Unknown error";
+            spinner.error({ text: "Generation failed" });
+            throw err;
+        }
+        finally {
+            // Track CLI generation event
+            const executionTime = Date.now() - startTime;
+            const userId = process.env.DEFAULT_USER_ID || "cli-user";
+            try {
+                // Import usage tracker dynamically to avoid CLI dependency issues
+                const { usageTracker } = await Promise.resolve().then(() => __importStar(require("../../../lib/analytics/usage-tracker")));
+                await usageTracker.trackCLIGeneration(userId, target, "cli", success, executionTime, error);
+            }
+            catch (trackingError) {
+                console.log(chalk_1.default.yellow("⚠️ Analytics tracking failed:", trackingError));
+            }
+        }
+    }
+    async generateContext(options, spinner) {
+        spinner.updateText("Generating project context...");
+        // Get project description
+        let description = "";
+        if (!options.yes) {
+            const response = await (0, prompts_1.default)({
+                type: "text",
+                name: "description",
+                message: "Project description:",
+                validate: (value) => value.length > 10 || "Description must be at least 10 characters",
+            });
+            description = response.description;
+        }
+        else {
+            // For non-interactive mode, use a default description or read from project config
+            try {
+                // Try to read from project config first
+                const configPath = ".mycontext/config.json";
+                const configContent = await this.fs.readFile(configPath);
+                const config = JSON.parse(configContent);
+                description =
+                    config.description ||
+                        "A simple application for testing AI generation flow";
+            }
+            catch {
+                // Fallback to a generic description
+                description = "A simple application for testing AI generation flow";
+            }
+        }
+        // Generate context files using API
+        const contextFiles = await this.callGenerationAPI("context", description, options);
+        // Write files to filesystem
+        await this.writeContextFiles(contextFiles);
+        spinner.success({ text: "Context files generated successfully!" });
+        console.log(chalk_1.default.green("\n✅ Generated Files:"));
+        Object.keys(contextFiles).forEach((filename) => {
+            console.log(chalk_1.default.gray(`  • ${filename}`));
+        });
+    }
+    async generateTypes(options, spinner) {
+        spinner.updateText("Generating TypeScript types...");
+        // Read PRD for context
+        const prdPath = await this.findPRDFile();
+        if (!prdPath) {
+            throw new Error('No PRD found. Run "mycontext generate context" first.');
+        }
+        const prdContent = await this.fs.readFile(prdPath);
+        // Generate types using API
+        const typesContent = await this.callGenerationAPI("types", prdContent, options);
+        // Write types file
+        await this.fs.writeFile("context/types.ts", typesContent);
+        spinner.success({ text: "TypeScript types generated successfully!" });
+    }
+    async generateBrand(options, spinner) {
+        spinner.updateText("Generating branding guidelines...");
+        // Read PRD for context
+        const prdPath = await this.findPRDFile();
+        if (!prdPath) {
+            throw new Error('No PRD found. Run "mycontext generate context" first.');
+        }
+        const prdContent = await this.fs.readFile(prdPath);
+        // Generate branding using API (returns { markdown, json })
+        const branding = await this.callGenerationAPI("brand", prdContent, options);
+        // Write branding files
+        await this.fs.writeFile("context/branding.md", branding.markdown);
+        await this.fs.writeFile("context/branding.json", JSON.stringify(branding.json, null, 2));
+        spinner.success({ text: "Branding guidelines generated successfully!" });
+        console.log(chalk_1.default.green("\n✅ Generated Files:"));
+        console.log(chalk_1.default.gray("  • branding.md"));
+        console.log(chalk_1.default.gray("  • branding.json"));
+    }
+    async generateComponentsList(options, spinner) {
+        spinner.updateText("Generating comprehensive component list...");
+        // Read context files for comprehensive analysis
+        const contextFiles = await this.readContextFiles();
+        const prdContent = contextFiles["context/01_PRD.md"] || "";
+        const userStoriesContent = contextFiles["context/02_user_stories.md"] || "";
+        const typesContent = contextFiles["context/types.ts"] || "";
+        // Combine context for analysis
+        const fullContext = `
+PRD: ${prdContent}
+User Stories: ${userStoriesContent}
+Types: ${typesContent}
+    `.trim();
+        // Use local generation for component list (more reliable than API workflow)
+        const componentListData = await this.generateLocalComponentsList(fullContext);
+        // Write both JSON and Markdown versions
+        await this.fs.writeFile("context/component-list.json", JSON.stringify(componentListData, null, 2));
+        // Generate Markdown version for human review
+        const markdownContent = this.generateComponentListMarkdown(componentListData);
+        await this.fs.writeFile("context/component-list.md", markdownContent);
+        spinner.success({ text: "Component list generated successfully!" });
+        console.log(chalk_1.default.green("\n✅ Generated Files:"));
+        console.log(chalk_1.default.gray("  • component-list.json"));
+        console.log(chalk_1.default.gray("  • component-list.md"));
+        // Show summary
+        if (componentListData.groups) {
+            console.log(chalk_1.default.blue("\n📋 Component Groups:"));
+            componentListData.groups.forEach((group) => {
+                console.log(chalk_1.default.gray(`  • ${group.name} (${group.components?.length || 0} components)`));
+            });
+        }
+    }
+    async generateComponents(options, spinner) {
+        spinner.updateText("Generating components...");
+        // Read component list for context
+        const componentListPath = "context/component-list.json";
+        let componentList;
+        try {
+            const componentListContent = await this.fs.readFile(componentListPath);
+            componentList = JSON.parse(componentListContent);
+        }
+        catch {
+            throw new Error('No component list found. Run "mycontext generate components-list" first.');
+        }
+        // Create components directory
+        const componentsDir = "components/generated";
+        await this.fs.ensureDir(componentsDir);
+        // Generate each component using the sub-agent system
+        const generatedComponents = [];
+        for (const group of componentList.groups || []) {
+            const groupDir = path_1.default.join(componentsDir, this.sanitizeGroupName(group.name));
+            await this.fs.ensureDir(groupDir);
+            for (const component of group.components || []) {
+                try {
+                    // Generate component using CodeGenSubAgent
+                    const componentResult = await this.callGenerationAPI("component", JSON.stringify({ component, group, options }), options);
+                    // Extract the component code from the result
+                    let componentCode;
+                    if (Array.isArray(componentResult) && componentResult.length > 0) {
+                        // Result is an array from generateLocalComponents
+                        componentCode = componentResult[0].code || componentResult[0];
+                    }
+                    else if (typeof componentResult === "object" &&
+                        componentResult.code) {
+                        // Result is an object with code property
+                        componentCode = componentResult.code;
+                    }
+                    else if (typeof componentResult === "string") {
+                        // Result is a string
+                        componentCode = componentResult;
+                    }
+                    else {
+                        throw new Error(`Invalid component result format for ${component.name}`);
+                    }
+                    // Write component file
+                    const componentPath = path_1.default.join(groupDir, `${component.name}.tsx`);
+                    await this.fs.writeFile(componentPath, componentCode);
+                    generatedComponents.push({
+                        name: component.name,
+                        type: component.type,
+                        path: componentPath,
+                    });
+                    console.log(chalk_1.default.gray(`  • ${component.name} (${component.type})`));
+                }
+                catch (error) {
+                    console.log(chalk_1.default.red(`  ❌ Failed to generate ${component.name}: ${error}`));
+                }
+            }
+            // Generate group index file
+            const indexContent = this.generateGroupIndex(group);
+            const indexPath = path_1.default.join(groupDir, "index.ts");
+            await this.fs.writeFile(indexPath, indexContent);
+        }
+        spinner.success({ text: "Components generated successfully!" });
+        console.log(chalk_1.default.green("\n✅ Generated Components:"));
+        generatedComponents.forEach((component) => {
+            console.log(chalk_1.default.gray(`  • ${component.name} (${component.type})`));
+        });
+    }
+    generateGroupIndex(group) {
+        const components = group.components || [];
+        const imports = components
+            .map((comp) => `export { ${comp.name} } from './${comp.name}';`)
+            .join("\n");
+        return `// ${group.name} Components
+${imports}
+
+// Group metadata
+export const groupMetadata = {
+  name: "${group.name}",
+  description: "${group.description || ""}",
+  priority: "${group.priority || "medium"}",
+  componentCount: ${components.length},
+};
+`;
+    }
+    async generateAppStructure(options, spinner) {
+        spinner.updateText("Generating app structure...");
+        // Read context files
+        const contextFiles = await this.readContextFiles();
+        // Generate app structure using API
+        const appStructure = await this.callGenerationAPI("app-structure", JSON.stringify(contextFiles), options);
+        // Write app structure file
+        await this.fs.writeFile("context/app-structure.json", JSON.stringify(appStructure, null, 2));
+        spinner.success({ text: "App structure generated successfully!" });
+    }
+    async callGenerationAPI(type, context, options) {
+        // Try X.AI first if specified, then GitHub Models, then fallback to local API
+        const xaiApiKey = process.env.XAI_API_KEY;
+        const githubToken = process.env.GITHUB_TOKEN;
+        // X.AI Priority (if explicitly requested or available)
+        if (options.useXAI && xaiApiKey) {
+            try {
+                const { XAIClient } = await Promise.resolve().then(() => __importStar(require("../utils/xaiClient")));
+                const xaiClient = new XAIClient({
+                    apiKey: xaiApiKey,
+                    temperature: options.temperature || 0.7,
+                    maxTokens: options.maxTokens || 4000,
+                });
+                // Test connection first
+                const isConnected = await xaiClient.testConnection();
+                if (!isConnected) {
+                    throw new Error("X.AI connection failed");
+                }
+                console.log(chalk_1.default.blue("🤖 Using X.AI (Grok) for generation..."));
+                switch (type) {
+                    case "context":
+                        return await xaiClient.generateContext(context);
+                    case "components-list":
+                        return await xaiClient.generateComponentList(context);
+                    case "component":
+                        // For component generation, we need to parse the context
+                        try {
+                            const componentData = JSON.parse(context);
+                            return await xaiClient.generateComponent(componentData.component, componentData.group?.name || "general");
+                        }
+                        catch {
+                            // If context is not JSON, treat it as a simple component name
+                            return await xaiClient.generateComponent({ name: context, description: context }, "general");
+                        }
+                    default:
+                        // For other types, use the general generate method
+                        return await xaiClient.generate({
+                            prompt: context,
+                            temperature: options.temperature || 0.7,
+                            maxTokens: options.maxTokens || 4000,
+                        });
+                }
+            }
+            catch (error) {
+                console.log(chalk_1.default.yellow("X.AI unavailable, trying GitHub Models..."));
+            }
+        }
+        // GitHub Models fallback
+        if (githubToken) {
+            try {
+                const { GitHubModelsClient } = await Promise.resolve().then(() => __importStar(require("../utils/githubModels")));
+                const githubClient = new GitHubModelsClient({
+                    token: githubToken,
+                    temperature: options.temperature || 0.7,
+                    maxTokens: options.maxTokens || 4000,
+                });
+                // Test connection first
+                const isConnected = await githubClient.testConnection();
+                if (!isConnected) {
+                    throw new Error("GitHub Models connection failed");
+                }
+                console.log(chalk_1.default.blue("🤖 Using GitHub Models for generation..."));
+                switch (type) {
+                    case "component":
+                        // For component generation, we need to parse the context
+                        try {
+                            const componentData = JSON.parse(context);
+                            return await githubClient.generateComponent(componentData.component, componentData.group?.name || "general");
+                        }
+                        catch {
+                            // If context is not JSON, treat it as a simple component name
+                            return await githubClient.generateComponent({ name: context, description: context }, "general");
+                        }
+                    case "context":
+                        return await githubClient.generateComponentList(context);
+                    default:
+                        // For other types, use the general generate method
+                        return await githubClient.generate({
+                            prompt: context,
+                            temperature: options.temperature || 0.7,
+                            maxTokens: options.maxTokens || 4000,
+                        });
+                }
+            }
+            catch (error) {
+                console.log(chalk_1.default.yellow("GitHub Models unavailable, trying local API..."));
+            }
+        }
+        // Fallback to local API
+        const apiUrl = process.env.MYCONTEXT_API_URL || "http://localhost:3000/api/generate";
+        try {
+            const response = await fetch(apiUrl, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    ...(process.env.MYCONTEXT_API_KEY && {
+                        Authorization: `Bearer ${process.env.MYCONTEXT_API_KEY}`,
+                    }),
+                },
+                body: JSON.stringify({
+                    type,
+                    context,
+                    options: {
+                        useClaudeCodeSDK: options.useClaudeCodeSDK,
+                        useGemini: options.useGemini,
+                        temperature: options.temperature || 0.7,
+                        maxTokens: options.maxTokens || 4000,
+                    },
+                }),
+            });
+            if (!response.ok) {
+                throw new Error(`API request failed: ${response.status} ${response.statusText}`);
+            }
+            const result = (await response.json());
+            // Handle API response structure
+            if (result.success && result.result) {
+                // Check if result has a data property (nested structure)
+                if (result.result.data) {
+                    return result.result.data;
+                }
+                return result.result;
+            }
+            else if (result.content) {
+                return result.content;
+            }
+            else {
+                return result;
+            }
+        }
+        catch (error) {
+            // Fallback to local generation if API fails
+            console.log(chalk_1.default.yellow("API unavailable, using local generation..."));
+            return this.generateLocally(type, context, options);
+        }
+    }
+    async generateLocally(type, context, options) {
+        // Local generation fallback
+        switch (type) {
+            case "context":
+                return this.generateLocalContext(context);
+            case "types":
+                return this.generateLocalTypes(context);
+            case "brand":
+                return this.generateLocalBrand(context);
+            case "components-list":
+            case "workflow":
+                return this.generateLocalComponentsList(context);
+            case "components":
+                return this.generateLocalComponents(context);
+            case "app-structure":
+                return this.generateLocalAppStructure(context);
+            default:
+                throw new Error(`Unknown generation type: ${type}`);
+        }
+    }
+    async generateLocalContext(description) {
+        // Detect app type based on description
+        const isTodoApp = description.toLowerCase().includes("todo") ||
+            description.toLowerCase().includes("task") ||
+            description.toLowerCase().includes("checklist");
+        const isEcommerceApp = description.toLowerCase().includes("ecommerce") ||
+            description.toLowerCase().includes("shop") ||
+            description.toLowerCase().includes("store") ||
+            description.toLowerCase().includes("cart") ||
+            description.toLowerCase().includes("checkout") ||
+            description.toLowerCase().includes("payment");
+        if (isTodoApp) {
+            return {
+                "01_PRD.md": `# Product Requirements Document
+
+## Project Overview
+**Project Name:** Todo Application
+**Description:** ${description}
+
+## Core Features
+- **Task Management**: Create, read, update, and delete todo items
+- **Task Status**: Mark tasks as complete/incomplete with visual indicators
+- **Task Categories**: Organize tasks by categories or priorities
+- **Search & Filter**: Find specific tasks quickly
+- **Responsive Design**: Works seamlessly on desktop and mobile devices
+
+## User Stories
+- As a user, I want to create new todo items so that I can track my tasks
+- As a user, I want to mark tasks as complete so that I can track my progress
+- As a user, I want to edit existing tasks so that I can update details
+- As a user, I want to delete tasks so that I can remove completed or irrelevant items
+- As a user, I want to filter tasks by status so that I can focus on pending work
+- As a user, I want to search for specific tasks so that I can find them quickly
+
+## Technical Requirements
+- **Frontend**: Next.js 14 with App Router, TypeScript, Tailwind CSS
+- **UI Components**: shadcn/ui component library
+- **State Management**: React hooks with local storage persistence
+- **Styling**: Responsive design with mobile-first approach
+- **Accessibility**: WCAG 2.1 AA compliance
+
+## Acceptance Criteria
+- [ ] Users can create new todo items with title and optional description
+- [ ] Users can mark tasks as complete/incomplete with visual feedback
+- [ ] Users can edit task details inline
+- [ ] Users can delete tasks with confirmation
+- [ ] Users can filter tasks by status (all, active, completed)
+- [ ] Users can search tasks by title or description
+- [ ] Tasks persist across browser sessions using local storage
+- [ ] Interface is fully responsive and accessible`,
+                "02_user_stories.md": `# User Stories
+
+## Primary User Stories
+
+### 1. Task Creation
+**As a** user  
+**I want to** create new todo items  
+**So that** I can track my tasks and responsibilities
+
+**Acceptance Criteria:**
+- [ ] I can click an "Add Task" button or press Enter in an input field
+- [ ] I can enter a task title (required)
+- [ ] I can optionally add a description
+- [ ] The task appears in my todo list immediately
+- [ ] The input field clears after adding a task
+
+### 2. Task Completion
+**As a** user  
+**I want to** mark tasks as complete  
+**So that** I can track my progress and focus on remaining work
+
+**Acceptance Criteria:**
+- [ ] I can click a checkbox next to each task
+- [ ] Completed tasks show visual indicators (strikethrough, different color)
+- [ ] I can uncheck completed tasks to mark them as incomplete
+- [ ] The completion status persists across sessions
+
+### 3. Task Editing
+**As a** user  
+**I want to** edit existing tasks  
+**So that** I can update details or correct mistakes
+
+**Acceptance Criteria:**
+- [ ] I can click on a task title to edit it inline
+- [ ] I can also edit the task description
+- [ ] Changes are saved automatically or with a save button
+- [ ] I can cancel editing by pressing Escape
+
+### 4. Task Deletion
+**As a** user  
+**I want to** delete tasks  
+**So that** I can remove completed or irrelevant items
+
+**Acceptance Criteria:**
+- [ ] I can click a delete button (trash icon) next to each task
+- [ ] A confirmation dialog appears before deletion
+- [ ] Deleted tasks are removed from the list permanently
+- [ ] I can undo deletion within a short time window
+
+### 5. Task Filtering
+**As a** user  
+**I want to** filter tasks by status  
+**So that** I can focus on specific types of tasks
+
+**Acceptance Criteria:**
+- [ ] I can filter by "All", "Active", or "Completed" tasks
+- [ ] The filter selection is visually indicated
+- [ ] The task count updates based on the current filter
+- [ ] I can clear filters to show all tasks
+
+### 6. Task Search
+**As a** user  
+**I want to** search for specific tasks  
+**So that** I can find them quickly in a long list
+
+**Acceptance Criteria:**
+- [ ] I can type in a search box to filter tasks
+- [ ] Search works on both task titles and descriptions
+- [ ] Search results update in real-time as I type
+- [ ] No results message appears when no matches are found`,
+                "03_technical_specs.md": `# Technical Specifications
+
+## Architecture Overview
+- **Frontend Framework**: Next.js 14 with App Router
+- **Language**: TypeScript for type safety
+- **Styling**: Tailwind CSS with shadcn/ui components
+- **State Management**: React hooks with localStorage persistence
+- **Build Tool**: Vite for fast development and building
+
+## Component Architecture
+
+### Core Components
+1. **TodoApp** - Main application container
+2. **TodoList** - Displays the list of todo items
+3. **TodoItem** - Individual todo item with actions
+4. **TodoForm** - Form for creating new todos
+5. **TodoFilter** - Filter and search controls
+6. **TodoStats** - Shows completion statistics
+
+### Layout Components
+- **Header** - App title and navigation
+- **Main** - Primary content area
+- **Footer** - Additional information and links
+
+## Data Model
+
+### Todo Item Structure
+\`\`\`typescript
+interface Todo {
+  id: string;
+  title: string;
+  description?: string;
+  completed: boolean;
+  createdAt: Date;
+  updatedAt: Date;
+  priority?: 'low' | 'medium' | 'high';
+  category?: string;
+}
+\`\`\`
+
+### Local Storage Schema
+\`\`\`json
+{
+  "todos": [
+    {
+      "id": "uuid",
+      "title": "Task title",
+      "description": "Optional description",
+      "completed": false,
+      "createdAt": "2024-01-01T00:00:00.000Z",
+      "updatedAt": "2024-01-01T00:00:00.000Z"
+    }
+  ],
+  "filters": {
+    "status": "all",
+    "search": ""
+  }
+}
+\`\`\`
+
+## UI/UX Design
+
+### Design System
+- **Color Palette**: Tailwind CSS default with custom accent colors
+- **Typography**: Inter font family for readability
+- **Spacing**: Consistent 4px grid system
+- **Components**: shadcn/ui primitives for consistency
+
+### Responsive Design
+- **Mobile First**: Design for mobile devices first
+- **Breakpoints**: sm (640px), md (768px), lg (1024px), xl (1280px)
+- **Touch Targets**: Minimum 44px for interactive elements
+
+### Accessibility
+- **WCAG 2.1 AA**: Full compliance with accessibility standards
+- **Keyboard Navigation**: All features accessible via keyboard
+- **Screen Readers**: Proper ARIA labels and semantic HTML
+- **Color Contrast**: Minimum 4.5:1 ratio for text
+
+## Performance Considerations
+- **Lazy Loading**: Components load only when needed
+- **Debounced Search**: Search input debounced to prevent excessive filtering
+- **Optimistic Updates**: UI updates immediately, then syncs with storage
+- **Virtual Scrolling**: For large lists (future enhancement)
+
+## Security & Data
+- **Client-Side Only**: No server-side storage required
+- **Input Sanitization**: All user inputs are sanitized
+- **XSS Prevention**: React's built-in XSS protection
+- **Local Storage**: Data persists in browser localStorage`,
+            };
+        }
+        else if (isEcommerceApp) {
+            return {
+                "01_PRD.md": `# Product Requirements Document
+
+## Project Overview
+**Project Name:** Ecommerce Platform
+**Description:** ${description}
+
+## Core Features
+- **Product Catalog**: Browse and search products with filtering and sorting
+- **Shopping Cart**: Add, remove, and manage items in cart
+- **Checkout Process**: Multi-step checkout with payment processing
+- **User Accounts**: Registration, login, and order history
+- **Payment Integration**: Secure payment processing with multiple options
+- **Order Management**: Track orders and receive notifications
+
+## User Stories
+- As a customer, I want to browse products so that I can find items to purchase
+- As a customer, I want to add items to cart so that I can purchase multiple items
+- As a customer, I want to complete checkout so that I can receive my order
+- As a customer, I want to track my orders so that I know when they'll arrive
+- As a customer, I want to save payment methods so that checkout is faster
+- As an admin, I want to manage products so that inventory is accurate
+
+## Technical Requirements
+- **Frontend**: Next.js 14 with App Router, TypeScript, Tailwind CSS
+- **UI Components**: shadcn/ui component library
+- **State Management**: React hooks with cart persistence
+- **Payment**: Stripe integration for secure payments
+- **Authentication**: NextAuth.js for user management
+- **Database**: PostgreSQL for product and order data
+
+## Acceptance Criteria
+- [ ] Users can browse products with search and filtering
+- [ ] Users can add/remove items from shopping cart
+- [ ] Users can complete checkout with payment processing
+- [ ] Users can track order status and history
+- [ ] Admin can manage product inventory
+- [ ] Payment processing is secure and reliable`,
+                "02_user_stories.md": `# User Stories
+
+## Primary User Stories
+
+### 1. Product Browsing
+**As a** customer  
+**I want to** browse products  
+**So that** I can find items to purchase
+
+**Acceptance Criteria:**
+- [ ] I can view a grid/list of products with images and prices
+- [ ] I can search for specific products by name or category
+- [ ] I can filter products by price, category, or rating
+- [ ] I can sort products by price, popularity, or newest
+- [ ] I can view detailed product information
+
+### 2. Shopping Cart Management
+**As a** customer  
+**I want to** manage my shopping cart  
+**So that** I can purchase multiple items efficiently
+
+**Acceptance Criteria:**
+- [ ] I can add products to my cart from product pages
+- [ ] I can view my cart contents and total
+- [ ] I can update quantities or remove items
+- [ ] My cart persists across browser sessions
+- [ ] I can save items for later purchase
+
+### 3. Checkout Process
+**As a** customer  
+**I want to** complete my purchase  
+**So that** I can receive my order
+
+**Acceptance Criteria:**
+- [ ] I can enter shipping and billing information
+- [ ] I can select from multiple payment options
+- [ ] I can review my order before confirmation
+- [ ] I receive confirmation of my purchase
+- [ ] I can track my order status
+
+### 4. Order Tracking
+**As a** customer  
+**I want to** track my orders  
+**So that** I know when they'll arrive
+
+**Acceptance Criteria:**
+- [ ] I can view my order history
+- [ ] I can see current order status
+- [ ] I receive email notifications for updates
+- [ ] I can cancel orders within allowed timeframe
+- [ ] I can request refunds or returns`,
+                "03_technical_specs.md": `# Technical Specifications
+
+## Architecture Overview
+- **Frontend Framework**: Next.js 14 with App Router
+- **Language**: TypeScript for type safety
+- **Styling**: Tailwind CSS with shadcn/ui components
+- **State Management**: React hooks with cart persistence
+- **Payment Processing**: Stripe integration
+- **Authentication**: NextAuth.js
+- **Database**: PostgreSQL with Prisma ORM
+
+## Component Architecture
+
+### Core Components
+1. **ProductCatalog** - Product browsing and search
+2. **ProductCard** - Individual product display
+3. **ShoppingCart** - Cart management and display
+4. **CheckoutForm** - Multi-step checkout process
+5. **PaymentForm** - Payment method selection
+6. **OrderTracking** - Order status and history
+
+### Layout Components
+- **Header** - Navigation and cart icon
+- **ProductGrid** - Product listing layout
+- **CheckoutWizard** - Multi-step checkout flow
+- **Footer** - Additional information and links
+
+## Data Model
+
+### Product Structure
+\`\`\`typescript
+interface Product {
+  id: string;
+  name: string;
+  description: string;
+  price: number;
+  images: string[];
+  category: string;
+  inventory: number;
+  rating: number;
+  reviews: Review[];
+}
+\`\`\`
+
+### Cart Structure
+\`\`\`typescript
+interface CartItem {
+  productId: string;
+  quantity: number;
+  price: number;
+}
+
+interface Cart {
+  items: CartItem[];
+  total: number;
+  itemCount: number;
+}
+\`\`\`
+
+## UI/UX Design
+
+### Design System
+- **Color Palette**: Professional ecommerce colors
+- **Typography**: Clear, readable fonts for product information
+- **Spacing**: Consistent spacing for product grids
+- **Components**: shadcn/ui primitives with ecommerce patterns
+
+### Responsive Design
+- **Mobile First**: Optimized for mobile shopping
+- **Product Grid**: Responsive grid layout
+- **Checkout**: Mobile-friendly form design
+- **Touch Targets**: Large enough for mobile interaction
+
+### Accessibility
+- **WCAG 2.1 AA**: Full compliance for all users
+- **Screen Readers**: Proper product descriptions
+- **Keyboard Navigation**: Full keyboard accessibility
+- **Color Contrast**: High contrast for product information
+
+## Performance Considerations
+- **Image Optimization**: Lazy loading and WebP format
+- **Product Search**: Fast search with debouncing
+- **Cart Updates**: Optimistic updates for better UX
+- **Payment Processing**: Secure and fast payment flow
+
+## Security & Data
+- **Payment Security**: PCI compliance with Stripe
+- **User Data**: Secure storage and transmission
+- **Input Validation**: All user inputs validated
+- **CSRF Protection**: Protection against cross-site attacks`,
+            };
+        }
+        else {
+            // Fallback: generic context with instructions
+            const instructions = `<!--\nThis is a generic context file.\nTo regenerate with your project details, run:\n\n    mycontext generate context --yes\n\nEdit your PRD or provide a detailed description for better results.\n-->\n`;
+            return {
+                "01_PRD.md": `${instructions}
+# Product Requirements Document
+
+## Project Overview
+Describe your project here.
+
+## Core Features
+- Feature 1: Description
+- Feature 2: Description
+- Feature 3: Description
+
+## Technical Requirements
+- Technology Stack: [List technologies]
+- Database: [Database choice]
+- Authentication: [Auth method]
+
+## User Stories
+- As a user, I want to [action] so that [benefit]
+- As an admin, I need to [action] so that [benefit]
+
+## Acceptance Criteria
+- [ ] Feature 1 works correctly
+- [ ] Feature 2 is responsive
+- [ ] Feature 3 is accessible
+`,
+                "02_user_stories.md": `${instructions}
+# User Stories
+
+Add user stories for your project here.
+
+## Example User Stories
+- As a user, I want to [do something] so that [benefit].
+- As an admin, I want to [manage something] so that [benefit].
+
+## Acceptance Criteria
+- [ ] User can complete the primary action
+- [ ] System provides appropriate feedback
+- [ ] Error handling is implemented
+`,
+                "03_technical_specs.md": `${instructions}
+# Technical Specifications
+
+## Architecture
+- Frontend: [Framework, e.g., Next.js, React]
+- Styling: [CSS framework, e.g., Tailwind CSS]
+- State Management: [e.g., Zustand, Redux]
+- Database: [e.g., PostgreSQL, MongoDB]
+- Authentication: [e.g., NextAuth.js, Auth0]
+
+## Component Structure
+- Layout components
+- Form components
+- Display components
+- Interactive components
+
+## API Design
+- RESTful endpoints
+- TypeScript interfaces
+- Error handling
+- Rate limiting
+`,
+            };
+        }
+    }
+    async generateLocalTypes(context) {
+        return `// Generated TypeScript types based on: ${context}
+
+export interface User {
+  id: string;
+  email: string;
+  name: string;
+  role: 'user' | 'admin';
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export interface Project {
+  id: string;
+  name: string;
+  description: string;
+  userId: string;
+  status: 'active' | 'inactive' | 'archived';
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export interface ApiResponse<T = any> {
+  success: boolean;
+  data?: T;
+  error?: string;
+  message?: string;
+}
+
+// Add more types based on your project requirements
+`;
+    }
+    // Update local brand generation to return both markdown and JSON
+    async generateLocalBrand(context) {
+        // Extract project name from context
+        const projectName = context.includes("Project Name:")
+            ? context.split("Project Name:")[1]?.split("\n")[0]?.trim() ||
+                "MyContext Project"
+            : "MyContext Project";
+        const theme = "rose";
+        const colors = {
+            primary: "oklch(0.645 0.246 16.439)",
+            secondary: "oklch(0.967 0.001 286.375)",
+            accent: "oklch(0.967 0.001 286.375)",
+            background: "oklch(1 0 0)",
+            foreground: "oklch(0.141 0.005 285.823)",
+            border: "oklch(0.92 0.004 286.32)",
+            card: "oklch(1 0 0)",
+            cardForeground: "oklch(0.141 0.005 285.823)",
+            // ... add more as needed
+        };
+        const cssVariables = {
+            "--radius": "0.65rem",
+            "--background": colors.background,
+            "--foreground": colors.foreground,
+            "--primary": colors.primary,
+            "--secondary": colors.secondary,
+            "--accent": colors.accent,
+            "--border": colors.border,
+            "--card": colors.card,
+            "--card-foreground": colors.cardForeground,
+            // ... add more as needed
+        };
+        const typography = {
+            fontFamily: "Inter, system-ui, sans-serif",
+            fontSizes: {
+                xs: "0.75rem",
+                sm: "0.875rem",
+                base: "1rem",
+                lg: "1.125rem",
+                xl: "1.25rem",
+                "2xl": "1.5rem",
+                "3xl": "1.875rem",
+                "4xl": "2.25rem",
+                "5xl": "3rem",
+            },
+            fontWeights: {
+                light: 300,
+                regular: 400,
+                medium: 500,
+                semibold: 600,
+                bold: 700,
+                extrabold: 800,
+            },
+            lineHeights: {
+                tight: 1.25,
+                normal: 1.5,
+                relaxed: 1.75,
+            },
+        };
+        const spacing = {
+            base: "4px",
+            scale: [0, 4, 8, 12, 16, 20, 24, 32, 40, 48, 64, 80, 96],
+        };
+        const markdown = `# Branding Guidelines
+
+## Project Overview
+**Project Name:** ${projectName}
+**Theme:** ${theme} (shadcn/ui)
+**Generated:** ${new Date().toISOString().split("T")[0]}
+
+### Color Palette
+- Primary: ${colors.primary}
+- Secondary: ${colors.secondary}
+- Accent: ${colors.accent}
+- Background: ${colors.background}
+- Foreground: ${colors.foreground}
+- Border: ${colors.border}
+
+### CSS Variables
+\`\`\`css
+:root {
+${Object.entries(cssVariables)
+            .map(([k, v]) => `  ${k}: ${v};`)
+            .join("\n")}
+}
+\`\`\`
+
+### Typography
+- Font Family: ${typography.fontFamily}
+- Font Sizes: ${Object.entries(typography.fontSizes)
+            .map(([k, v]) => `${k}: ${v}`)
+            .join(", ")}
+- Font Weights: ${Object.entries(typography.fontWeights)
+            .map(([k, v]) => `${k}: ${v}`)
+            .join(", ")}
+- Line Heights: ${Object.entries(typography.lineHeights)
+            .map(([k, v]) => `${k}: ${v}`)
+            .join(", ")}
+
+### Spacing System
+- Base: ${spacing.base}
+- Scale: ${spacing.scale.join(", ")}
+
+---
+
+*This branding guide ensures consistency across all components and maintains the professional, accessible, and user-friendly design principles of the ${projectName} project.*
+`;
+        const json = {
+            projectName,
+            theme,
+            colors,
+            cssVariables,
+            typography,
+            spacing,
+            generated: new Date().toISOString(),
+        };
+        return { markdown, json };
+    }
+    async generateLocalComponents(context) {
+        // Parse the context to extract component information
+        let componentData;
+        try {
+            componentData = JSON.parse(context);
+        }
+        catch {
+            // If context is not JSON, return empty array
+            return [];
+        }
+        const { component, group, options } = componentData;
+        // Use the CodeGenSubAgent to generate actual component code
+        const { CodeGenSubAgent } = await Promise.resolve().then(() => __importStar(require("../agents/implementations/CodeGenSubAgent")));
+        const codeGenAgent = new CodeGenSubAgent();
+        const result = await codeGenAgent.run({
+            component,
+            group,
+            options,
+            context,
+        });
+        return [result];
+    }
+    async generateLocalComponentsList(context) {
+        // Dynamic AI-driven component list generation
+        // Instead of hardcoded patterns, we use intelligent analysis
+        // Step 1: Analyze the context to determine app type and intent
+        const appAnalysis = this.analyzeAppContext(context);
+        // Step 2: Generate component list based on analysis
+        return this.generateComponentListFromAnalysis(appAnalysis, context);
+    }
+    /**
+     * Analyzes app context to determine type, intent, and requirements
+     */
+    analyzeAppContext(context) {
+        const analysis = {
+            appType: this.detectAppType(context),
+            primaryIntent: this.detectPrimaryIntent(context),
+            complexity: this.assessComplexity(context),
+            keyFeatures: this.extractKeyFeatures(context),
+            userTypes: this.identifyUserTypes(context),
+            dataEntities: this.identifyDataEntities(context),
+            technicalRequirements: this.extractTechnicalRequirements(context),
+            uiPatterns: this.suggestUIPatterns(context),
+            componentGroups: [],
+            priorityMatrix: this.createPriorityMatrix(context),
+        };
+        // Generate component groups based on analysis
+        analysis.componentGroups = this.suggestComponentGroups(analysis);
+        return analysis;
+    }
+    /**
+     * Detects the type of application based on context
+     */
+    detectAppType(context) {
+        const lowerContext = context.toLowerCase();
+        // Define app type patterns with confidence scores
+        const typePatterns = [
+            {
+                type: "ecommerce",
+                patterns: [
+                    "shop",
+                    "store",
+                    "cart",
+                    "checkout",
+                    "product",
+                    "order",
+                    "payment",
+                ],
+                score: 0.9,
+            },
+            {
+                type: "dashboard",
+                patterns: [
+                    "dashboard",
+                    "analytics",
+                    "metrics",
+                    "report",
+                    "chart",
+                    "graph",
+                ],
+                score: 0.85,
+            },
+            {
+                type: "social",
+                patterns: [
+                    "social",
+                    "network",
+                    "profile",
+                    "friend",
+                    "post",
+                    "comment",
+                    "share",
+                ],
+                score: 0.8,
+            },
+            {
+                type: "productivity",
+                patterns: ["todo", "task", "project", "calendar", "note", "document"],
+                score: 0.85,
+            },
+            {
+                type: "communication",
+                patterns: ["chat", "message", "email", "notification", "contact"],
+                score: 0.8,
+            },
+            {
+                type: "content",
+                patterns: ["blog", "article", "news", "media", "gallery", "video"],
+                score: 0.75,
+            },
+            {
+                type: "utility",
+                patterns: ["tool", "calculator", "converter", "generator", "utility"],
+                score: 0.7,
+            },
+            {
+                type: "game",
+                patterns: ["game", "play", "score", "level", "player", "board"],
+                score: 0.9,
+            },
+            {
+                type: "weather",
+                patterns: ["weather", "forecast", "temperature", "climate"],
+                score: 0.85,
+            },
+            {
+                type: "finance",
+                patterns: ["finance", "banking", "budget", "expense", "investment"],
+                score: 0.8,
+            },
+        ];
+        let bestMatch = "general";
+        let highestScore = 0;
+        for (const pattern of typePatterns) {
+            const matchCount = pattern.patterns.filter((p) => lowerContext.includes(p)).length;
+            const score = (matchCount / pattern.patterns.length) * pattern.score;
+            if (score > highestScore) {
+                highestScore = score;
+                bestMatch = pattern.type;
+            }
+        }
+        return bestMatch;
+    }
+    /**
+     * Detects the primary intent of the application
+     */
+    detectPrimaryIntent(context) {
+        const lowerContext = context.toLowerCase();
+        const intentPatterns = [
+            {
+                intent: "create",
+                patterns: ["create", "add", "new", "generate", "build"],
+                score: 0.8,
+            },
+            {
+                intent: "view",
+                patterns: ["view", "display", "show", "browse", "list"],
+                score: 0.8,
+            },
+            {
+                intent: "manage",
+                patterns: ["manage", "organize", "control", "admin", "dashboard"],
+                score: 0.8,
+            },
+            {
+                intent: "connect",
+                patterns: ["connect", "social", "network", "share", "collaborate"],
+                score: 0.8,
+            },
+            {
+                intent: "analyze",
+                patterns: ["analyze", "track", "monitor", "report", "insights"],
+                score: 0.8,
+            },
+            {
+                intent: "entertain",
+                patterns: ["game", "play", "entertain", "fun", "leisure"],
+                score: 0.8,
+            },
+        ];
+        let bestIntent = "view";
+        let highestScore = 0;
+        for (const pattern of intentPatterns) {
+            const matchCount = pattern.patterns.filter((p) => lowerContext.includes(p)).length;
+            const score = (matchCount / pattern.patterns.length) * pattern.score;
+            if (score > highestScore) {
+                highestScore = score;
+                bestIntent = pattern.intent;
+            }
+        }
+        return bestIntent;
+    }
+    /**
+     * Assesses the complexity of the application
+     */
+    assessComplexity(context) {
+        const wordCount = context.split(" ").length;
+        const featureKeywords = [
+            "authentication",
+            "payment",
+            "real-time",
+            "api",
+            "database",
+            "search",
+            "filter",
+            "chart",
+            "notification",
+        ];
+        const featureCount = featureKeywords.filter((keyword) => context.toLowerCase().includes(keyword)).length;
+        if (wordCount > 100 || featureCount > 5)
+            return "high";
+        if (wordCount > 50 || featureCount > 3)
+            return "medium";
+        return "low";
+    }
+    /**
+     * Extracts key features from the context
+     */
+    extractKeyFeatures(context) {
+        const featurePatterns = [
+            /authentication|login|signup|auth/gi,
+            /payment|checkout|billing|subscription/gi,
+            /search|filter|sort/gi,
+            /real.?time|live|instant/gi,
+            /notification|alert|reminder/gi,
+            /chart|graph|analytics|metrics/gi,
+            /upload|file|media/gi,
+            /location|map|geolocation/gi,
+            /chat|message|communication/gi,
+            /calendar|schedule|booking/gi,
+        ];
+        const features = [];
+        featurePatterns.forEach((pattern) => {
+            const matches = context.match(pattern);
+            if (matches) {
+                features.push(...matches.map((m) => m.toLowerCase()));
+            }
+        });
+        return [...new Set(features)]; // Remove duplicates
+    }
+    /**
+     * Identifies user types from context
+     */
+    identifyUserTypes(context) {
+        const userTypes = [];
+        const lowerContext = context.toLowerCase();
+        if (lowerContext.includes("admin") || lowerContext.includes("management"))
+            userTypes.push("admin");
+        if (lowerContext.includes("user") || lowerContext.includes("customer"))
+            userTypes.push("user");
+        if (lowerContext.includes("guest") || lowerContext.includes("public"))
+            userTypes.push("guest");
+        if (lowerContext.includes("moderator") || lowerContext.includes("editor"))
+            userTypes.push("moderator");
+        return userTypes.length > 0 ? userTypes : ["user"];
+    }
+    /**
+     * Identifies data entities from context
+     */
+    identifyDataEntities(context) {
+        const entityPatterns = [
+            /user|profile|account/gi,
+            /product|item|goods/gi,
+            /order|transaction|purchase/gi,
+            /post|article|content/gi,
+            /comment|review|feedback/gi,
+            /category|tag|label/gi,
+            /file|document|media/gi,
+            /event|activity|log/gi,
+        ];
+        const entities = [];
+        entityPatterns.forEach((pattern) => {
+            const matches = context.match(pattern);
+            if (matches) {
+                entities.push(...matches.map((m) => m.toLowerCase()));
+            }
+        });
+        return [...new Set(entities)];
+    }
+    /**
+     * Extracts technical requirements
+     */
+    extractTechnicalRequirements(context) {
+        const requirements = [];
+        const lowerContext = context.toLowerCase();
+        if (lowerContext.includes("mobile") || lowerContext.includes("responsive"))
+            requirements.push("responsive");
+        if (lowerContext.includes("real-time") || lowerContext.includes("live"))
+            requirements.push("realtime");
+        if (lowerContext.includes("offline") || lowerContext.includes("pwa"))
+            requirements.push("offline");
+        if (lowerContext.includes("accessibility") || lowerContext.includes("a11y"))
+            requirements.push("accessible");
+        if (lowerContext.includes("performance") || lowerContext.includes("fast"))
+            requirements.push("performant");
+        return requirements;
+    }
+    /**
+     * Suggests UI patterns based on app type and intent
+     */
+    suggestUIPatterns(context) {
+        const appType = this.detectAppType(context);
+        const patterns = [];
+        switch (appType) {
+            case "ecommerce":
+                patterns.push("product-grid", "shopping-cart", "checkout-flow", "product-detail");
+                break;
+            case "dashboard":
+                patterns.push("data-table", "chart-dashboard", "metric-cards", "sidebar-navigation");
+                break;
+            case "social":
+                patterns.push("feed", "profile-card", "comment-thread", "social-actions");
+                break;
+            case "productivity":
+                patterns.push("list-view", "form-wizard", "calendar-view", "kanban-board");
+                break;
+            case "weather":
+                patterns.push("dashboard", "card-layout", "metric-cards", "chart-dashboard");
+                break;
+            default:
+                patterns.push("list-view", "form", "card-layout", "navigation");
+        }
+        return patterns;
+    }
+    /**
+     * Suggests component groups based on analysis
+     */
+    suggestComponentGroups(analysis) {
+        const groups = [];
+        // Core functionality group
+        groups.push({
+            name: "Core Functionality",
+            description: "Primary application features and main user workflows",
+            priority: "high",
+            components: this.generateCoreComponents(analysis),
+        });
+        // Data management group
+        if (analysis.complexity !== "low") {
+            groups.push({
+                name: "Data Management",
+                description: "Data input, display, and manipulation components",
+                priority: "high",
+                components: this.generateDataComponents(analysis),
+            });
+        }
+        // Navigation and layout group
+        groups.push({
+            name: "Navigation & Layout",
+            description: "Layout components and navigation elements",
+            priority: "medium",
+            components: this.generateLayoutComponents(analysis),
+        });
+        // User interaction group
+        if (analysis.primaryIntent === "create" ||
+            analysis.primaryIntent === "manage") {
+            groups.push({
+                name: "User Interaction",
+                description: "Forms, controls, and interactive elements",
+                priority: "medium",
+                components: this.generateInteractionComponents(analysis),
+            });
+        }
+        // Analytics and feedback group
+        if (analysis.appType === "dashboard" ||
+            analysis.primaryIntent === "analyze") {
+            groups.push({
+                name: "Analytics & Feedback",
+                description: "Charts, metrics, and user feedback components",
+                priority: "medium",
+                components: this.generateAnalyticsComponents(analysis),
+            });
+        }
+        return groups;
+    }
+    /**
+     * Creates a priority matrix for components
+     */
+    createPriorityMatrix(context) {
+        const complexity = this.assessComplexity(context);
+        return {
+            critical: complexity === "high" ? 0.3 : 0.2,
+            high: 0.4,
+            medium: 0.2,
+            low: 0.1,
+        };
+    }
+    /**
+     * Generates component list from analysis
+     */
+    generateComponentListFromAnalysis(analysis, context) {
+        const projectName = this.extractProjectName(context);
+        return {
+            project: {
+                name: projectName,
+                description: context,
+                version: "0.1.0",
+                generated: new Date().toISOString(),
+                analysis: {
+                    appType: analysis.appType,
+                    primaryIntent: analysis.primaryIntent,
+                    complexity: analysis.complexity,
+                    keyFeatures: analysis.keyFeatures,
+                    userTypes: analysis.userTypes,
+                    dataEntities: analysis.dataEntities,
+                    technicalRequirements: analysis.technicalRequirements,
+                    uiPatterns: analysis.uiPatterns,
+                },
+            },
+            groups: analysis.componentGroups,
+            metadata: {
+                totalComponents: analysis.componentGroups.reduce((acc, group) => acc + group.components.length, 0),
+                totalGroups: analysis.componentGroups.length,
+                generatedAt: new Date().toISOString(),
+                version: "1.0.0",
+                analysisScore: this.calculateAnalysisScore(analysis),
+            },
+        };
+    }
+    /**
+     * Extracts project description from context
+     */
+    extractProjectDescription(context) {
+        // Try to extract from PRD content
+        const prdMatch = context.match(/## Project Overview[\s\S]*?\*\*Description:\*\*\s*([^\n]+)/i);
+        if (prdMatch && prdMatch[1]) {
+            return prdMatch[1].trim();
+        }
+        // Try to extract from common patterns
+        const patterns = [
+            /(?:project|app|application)\s+(?:name|called|titled?)\s+["']?([^"'\n]+)["']?/i,
+            /(?:create|build|develop)\s+(?:a|an)\s+([a-z\s]+?)\s+(?:app|application)/i,
+            /^([A-Z][a-z\s]+?)\s+(?:app|application|platform|system)/i,
+        ];
+        for (const pattern of patterns) {
+            const match = context.match(pattern);
+            if (match && match[1]) {
+                return match[1].trim();
+            }
+        }
+        // Fallback: use first meaningful phrase
+        const words = context.split(" ").slice(0, 3);
+        return (words
+            .join(" ")
+            .replace(/[^\w\s]/g, "")
+            .trim() || "MyContext Project");
+    }
+    /**
+     * Extracts project name from context
+     */
+    extractProjectName(context) {
+        // First try to get from the config file
+        try {
+            const configPath = ".mycontext/config.json";
+            // Note: This is a synchronous context, so we'll use a fallback approach
+            // The config reading will be handled in the calling method
+        }
+        catch {
+            // Config file doesn't exist or can't be read, continue with other methods
+        }
+        // Try to extract from PRD content
+        const prdMatch = context.match(/## Project Overview[\s\S]*?\*\*Project Name:\*\*\s*([^\n]+)/i);
+        if (prdMatch && prdMatch[1]) {
+            return prdMatch[1].trim();
+        }
+        // Try to extract from common patterns
+        const patterns = [
+            /(?:project|app|application)\s+(?:name|called|titled?)\s+["']?([^"'\n]+)["']?/i,
+            /(?:create|build|develop)\s+(?:a|an)\s+([a-z\s]+?)\s+(?:app|application)/i,
+            /^([A-Z][a-z\s]+?)\s+(?:app|application|platform|system)/i,
+        ];
+        for (const pattern of patterns) {
+            const match = context.match(pattern);
+            if (match && match[1]) {
+                return match[1].trim();
+            }
+        }
+        // Fallback: use first meaningful phrase
+        const words = context.split(" ").slice(0, 3);
+        return (words
+            .join(" ")
+            .replace(/[^\w\s]/g, "")
+            .trim() || "MyContext Project");
+    }
+    /**
+     * Calculates analysis confidence score
+     */
+    calculateAnalysisScore(analysis) {
+        let score = 0;
+        // App type detection score
+        score += analysis.appType !== "general" ? 20 : 10;
+        // Intent detection score
+        score += analysis.primaryIntent !== "view" ? 15 : 10;
+        // Feature extraction score
+        score += Math.min(analysis.keyFeatures.length * 5, 25);
+        // User types score
+        score += analysis.userTypes.length * 5;
+        // Data entities score
+        score += Math.min(analysis.dataEntities.length * 3, 15);
+        // Technical requirements score
+        score += analysis.technicalRequirements.length * 5;
+        return Math.min(score, 100);
+    }
+    // Helper methods for generating specific component types
+    generateCoreComponents(analysis) {
+        // This would generate components based on app type and intent
+        // For now, return a basic set
+        return [
+            {
+                name: `${analysis.appType.charAt(0).toUpperCase() + analysis.appType.slice(1)}App`,
+                description: `Main application container for ${analysis.appType} functionality`,
+                type: "layout",
+                priority: "high",
+                userStories: [
+                    `As a user, I want to access ${analysis.appType} features in a single application`,
+                ],
+                actionFunctions: ["initializeApp", "handleNavigation", "manageState"],
+                dependencies: ["layout", "state", "navigation"],
+                tags: [analysis.appType, "app", "container"],
+            },
+        ];
+    }
+    generateDataComponents(analysis) {
+        const appType = analysis.appType;
+        const dataEntities = analysis.dataEntities;
+        const components = [];
+        if (appType === "ecommerce") {
+            components.push({
+                name: "ProductList",
+                description: "Display and manage product catalog",
+                type: "display",
+                priority: "high",
+                userStories: [
+                    "As a user, I want to browse products to find items to purchase",
+                ],
+                actionFunctions: ["loadProducts", "filterProducts", "sortProducts"],
+                dependencies: ["list", "card", "button"],
+                tags: ["product", "list", "catalog"],
+            });
+            components.push({
+                name: "ProductDetail",
+                description: "Show detailed information about a specific product",
+                type: "display",
+                priority: "medium",
+                userStories: ["As a user, I want to view detailed product information"],
+                actionFunctions: ["loadProductDetails", "addToCart"],
+                dependencies: ["card", "button", "image"],
+                tags: ["product", "detail", "information"],
+            });
+            components.push({
+                name: "ShoppingCart",
+                description: "Manage items added to the shopping cart",
+                type: "interactive",
+                priority: "high",
+                userStories: [
+                    "As a user, I want to add items to my cart so that I can purchase multiple items",
+                ],
+                actionFunctions: [
+                    "addItemToCart",
+                    "removeItemFromCart",
+                    "updateQuantity",
+                ],
+                dependencies: ["cart", "button", "input"],
+                tags: ["cart", "shopping", "checkout"],
+            });
+            components.push({
+                name: "CheckoutForm",
+                description: "Multi-step checkout process with payment",
+                type: "form",
+                priority: "high",
+                userStories: ["As a user, I want to complete my purchase securely"],
+                actionFunctions: ["validateCheckout", "processPayment", "confirmOrder"],
+                dependencies: ["form", "payment-gateway", "validation"],
+                tags: ["checkout", "payment", "form"],
+            });
+            components.push({
+                name: "OrderHistory",
+                description: "Display user's order history and status",
+                type: "display",
+                priority: "medium",
+                userStories: [
+                    "As a user, I want to view my order history and track orders",
+                ],
+                actionFunctions: ["loadOrderHistory", "trackOrder", "cancelOrder"],
+                dependencies: ["list", "order-item", "status-indicator"],
+                tags: ["order", "history", "tracking"],
+            });
+            components.push({
+                name: "UserProfile",
+                description: "Manage user account and preferences",
+                type: "form",
+                priority: "medium",
+                userStories: ["As a user, I want to manage my account and preferences"],
+                actionFunctions: ["loadUserProfile", "updateProfile", "changePassword"],
+                dependencies: ["form", "avatar", "settings"],
+                tags: ["user", "profile", "account"],
+            });
+        }
+        else if (appType === "dashboard") {
+            components.push({
+                name: "DashboardOverview",
+                description: "Display key metrics and quick actions",
+                type: "display",
+                priority: "high",
+                userStories: [
+                    "As a user, I want to see analytics and performance metrics",
+                ],
+                actionFunctions: ["loadOverviewData", "updateCharts"],
+                dependencies: ["card", "chart", "metric-cards"],
+                tags: ["dashboard", "overview", "metrics"],
+            });
+            components.push({
+                name: "DataGrid",
+                description: "Display and manage tabular data",
+                type: "display",
+                priority: "medium",
+                userStories: [
+                    "As a user, I want to view and manage data in a table format",
+                ],
+                actionFunctions: ["loadData", "filterData", "sortData"],
+                dependencies: ["table", "input", "button"],
+                tags: ["data", "grid", "table"],
+            });
+        }
+        else if (appType === "productivity") {
+            components.push({
+                name: "TodoList",
+                description: "Display and manage todo items",
+                type: "display",
+                priority: "high",
+                userStories: ["As a user, I want to view and manage todo items"],
+                actionFunctions: ["loadTodos", "addTodo", "completeTodo", "deleteTodo"],
+                dependencies: ["list", "item", "button"],
+                tags: ["todo", "list", "task"],
+            });
+            components.push({
+                name: "TaskDetail",
+                description: "Show detailed information about a specific task",
+                type: "display",
+                priority: "medium",
+                userStories: ["As a user, I want to view detailed task information"],
+                actionFunctions: ["loadTaskDetails", "updateTaskStatus"],
+                dependencies: ["card", "button", "checkbox"],
+                tags: ["task", "detail", "information"],
+            });
+        }
+        else if (appType === "weather") {
+            components.push({
+                name: "WeatherForecast",
+                description: "Display weather forecast for a specific location",
+                type: "display",
+                priority: "high",
+                userStories: ["As a user, I want to see weather forecast"],
+                actionFunctions: ["loadWeatherForecast", "changeLocation"],
+                dependencies: ["card", "chart", "location-picker"],
+                tags: ["weather", "forecast", "temperature"],
+            });
+            components.push({
+                name: "WeatherHistory",
+                description: "Display historical weather data",
+                type: "display",
+                priority: "medium",
+                userStories: ["As a user, I want to view historical weather data"],
+                actionFunctions: ["loadWeatherHistory", "selectDateRange"],
+                dependencies: ["chart", "date-picker"],
+                tags: ["weather", "history", "temperature"],
+            });
+        }
+        else if (appType === "finance") {
+            components.push({
+                name: "TransactionList",
+                description: "Display and manage financial transactions",
+                type: "display",
+                priority: "high",
+                userStories: [
+                    "As a user, I want to view and manage financial transactions",
+                ],
+                actionFunctions: [
+                    "loadTransactions",
+                    "filterTransactions",
+                    "sortTransactions",
+                ],
+                dependencies: ["list", "transaction-item", "button"],
+                tags: ["transaction", "list", "finance"],
+            });
+            components.push({
+                name: "BudgetOverview",
+                description: "Display budget overview and spending trends",
+                type: "display",
+                priority: "medium",
+                userStories: [
+                    "As a user, I want to see budget overview and spending trends",
+                ],
+                actionFunctions: ["loadBudgetOverview", "updateBudget"],
+                dependencies: ["card", "chart", "budget-form"],
+                tags: ["budget", "overview", "spending"],
+            });
+        }
+        // Add more specific components for other app types if needed
+        return components;
+    }
+    generateLayoutComponents(analysis) {
+        return [
+            {
+                name: "AppLayout",
+                description: "Main application layout with navigation",
+                type: "layout",
+                priority: "high",
+                userStories: [
+                    "As a user, I want to navigate between different sections easily",
+                ],
+                actionFunctions: [
+                    "handleNavigation",
+                    "toggleSidebar",
+                    "updateBreadcrumbs",
+                ],
+                dependencies: ["header", "sidebar", "main"],
+                tags: ["layout", "navigation", "structure"],
+            },
+        ];
+    }
+    generateInteractionComponents(analysis) {
+        return [
+            {
+                name: "ActionForm",
+                description: "Form for user interactions and data input",
+                type: "form",
+                priority: "medium",
+                userStories: ["As a user, I want to input data and perform actions"],
+                actionFunctions: ["handleSubmit", "validateInput", "clearForm"],
+                dependencies: ["input", "button", "form"],
+                tags: ["form", "interaction", "input"],
+            },
+        ];
+    }
+    generateAnalyticsComponents(analysis) {
+        return [
+            {
+                name: "AnalyticsDashboard",
+                description: "Display analytics and metrics",
+                type: "display",
+                priority: "medium",
+                userStories: [
+                    "As a user, I want to see analytics and performance metrics",
+                ],
+                actionFunctions: ["loadMetrics", "updateCharts", "exportData"],
+                dependencies: ["chart", "card", "table"],
+                tags: ["analytics", "metrics", "dashboard"],
+            },
+        ];
+    }
+    generateComponentListMarkdown(data) {
+        const { project, groups, metadata } = data;
+        let markdown = `# Component List
+
+## Project Overview
+**Project Name:** ${project?.name || "MyContext Project"}
+**Description:** ${project?.description || "AI-powered component generation platform"}
+**Generated:** ${project?.generated || new Date().toISOString().split("T")[0]}
+
+## Summary
+- **Total Components:** ${metadata?.totalComponents ||
+            groups?.reduce((acc, g) => acc + (g.components?.length || 0), 0) ||
+            0}
+- **Total Groups:** ${metadata?.totalGroups || groups?.length || 0}
+- **Version:** ${metadata?.version || "1.0.0"}
+
+---
+
+`;
+        if (groups && Array.isArray(groups)) {
+            groups.forEach((group) => {
+                markdown += `## ${group.name}
+
+**Description:** ${group.description}
+**Priority:** ${group.priority}
+**Components:** ${group.components?.length || 0}
+
+`;
+                if (group.components && Array.isArray(group.components)) {
+                    group.components.forEach((component) => {
+                        markdown += `### ${component.name}
+
+**Type:** ${component.type}
+**Priority:** ${component.priority}
+**Description:** ${component.description}
+
+**User Stories:**
+${component.userStories?.map((story) => `- ${story}`).join("\n") ||
+                            "- No user stories defined"}
+
+**Action Functions:**
+${component.actionFunctions
+                            ?.map((func) => `- \`${func}\``)
+                            .join("\n") || "- No action functions defined"}
+
+**Dependencies:** ${component.dependencies?.join(", ") || "None"}
+**Tags:** ${component.tags?.join(", ") || "None"}
+
+---
+`;
+                    });
+                }
+            });
+        }
+        markdown += `
+## Implementation Notes
+
+### Building Blocks Philosophy
+Each component is designed as a reusable building block that can:
+- Work across different projects
+- Include specific action functions for user workflows
+- Be easily customized and extended
+- Follow consistent design patterns
+
+### User Story Integration
+Components are mapped to specific user stories to ensure they serve real user needs and provide actionable functionality.
+
+### Action Functions
+Every component includes action functions that handle the business logic and user interactions, making them truly useful rather than just visual elements.
+
+---
+
+*This component list serves as the blueprint for generating production-ready UI components that fulfill specific user workflows and can be reused across projects.*
+`;
+        return markdown;
+    }
+    async generateLocalAppStructure(context) {
+        return {
+            directoryStructure: `
+app/
+├── layout.tsx
+├── page.tsx
+├── globals.css
+├── (auth)/
+│   ├── login/
+│   └── register/
+├── (dashboard)/
+│   ├── projects/
+│   └── settings/
+components/
+├── ui/
+└── custom/
+lib/
+├── utils.ts
+└── types.ts
+`,
+            fileTemplates: {
+                "app/layout.tsx": "// Root layout component",
+                "app/page.tsx": "// Home page component",
+                "components/ui/button.tsx": "// Button component",
+            },
+            componentUsage: {
+                UserProfile: "Display user information with avatar and settings",
+                ProjectCard: "Show project details in a card format",
+            },
+        };
+    }
+    async writeContextFiles(files) {
+        for (const [filename, content] of Object.entries(files)) {
+            await this.fs.writeFile(`context/${filename}`, content);
+        }
+    }
+    async findPRDFile() {
+        const possiblePaths = [
+            "context/prd.md",
+            "context/PRD.md",
+            "context/01_PRD.md",
+            ".mycontext/context/prd.md",
+            "prd.md",
+            "PRD.md",
+        ];
+        for (const path of possiblePaths) {
+            try {
+                await this.fs.readFile(path);
+                return path;
+            }
+            catch {
+                continue;
+            }
+        }
+        return null;
+    }
+    async readContextFiles() {
+        const files = {};
+        const filePaths = [
+            "context/01_PRD.md",
+            "context/02_user_stories.md",
+            "context/03_technical_specs.md",
+            "context/types.ts",
+            "context/branding.md",
+        ];
+        for (const filePath of filePaths) {
+            try {
+                files[filePath] = await this.fs.readFile(filePath);
+            }
+            catch {
+                // File doesn't exist, skip
+            }
+        }
+        return files;
+    }
+}
+exports.GenerateCommand = GenerateCommand;
+//# sourceMappingURL=generate.js.map