mycontext-cli 1.0.29 → 1.0.35

package/dist/commands/generate.js

@@ -79,7 +79,19 @@ class GenerateCommand {
             let result;
             switch (type) {
                 case "context":
-                    result = await this.generateContext(projectContext, options);
+                    // 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 if (options.filesOnly) {
+                        // Generate only A/B/C/D files (requires existing PRD)
+                        result = await this.generateContextFiles(projectContext, options);
+                    }
+                    else {
+                        // Default: Generate only PRD
+                        result = await this.generateContext(projectContext, options);
+                    }
                     break;
                 case "types":
                     result = await this.generateTypes(projectContext, options);
@@ -3156,6 +3168,543 @@ ${isEcommerce
         }
         return undefined;
     }
+    /**
+     * Generate full context (PRD + A/B/C/D files)
+     */
+    async generateFullContext(projectContext, options) {
+        console.log(chalk_1.default.blue("🚀 Generating Full Context (PRD + A/B/C/D files)"));
+        // First generate the PRD
+        const prdResult = await this.generateContext(projectContext, options);
+        if (!prdResult.success) {
+            return prdResult;
+        }
+        // Then generate the A/B/C/D files
+        const contextFilesResult = await this.generateContextFiles(projectContext, options);
+        if (!contextFilesResult.success) {
+            return contextFilesResult;
+        }
+        return {
+            success: true,
+            content: "Full context generated successfully (PRD + A/B/C/D files)",
+            provider: "hybrid",
+            metadata: { model: "hybrid", tokens: 0, latency: 0 },
+        };
+    }
+    /**
+     * Generate A/B/C/D context files (Features, User Flows, Edge Cases, Technical Specs)
+     */
+    async generateContextFiles(projectContext, options) {
+        const contextDir = path_1.default.join(process.cwd(), ".mycontext");
+        // Ensure .mycontext directory exists
+        await fs.ensureDir(contextDir);
+        // Check if context files already exist
+        const existingFiles = await this.checkExistingContextFiles(contextDir);
+        if (existingFiles.length > 0 && !options.force) {
+            return {
+                success: false,
+                error: `Context files already exist: ${existingFiles.join(", ")}. Use --force to overwrite.`,
+                provider: "system",
+                metadata: { model: "system", tokens: 0, latency: 0 },
+            };
+        }
+        // Get context from PRD if it exists, otherwise use description
+        const contextContent = await this.getContextForGeneration(contextDir, projectContext.description);
+        try {
+            // Generate each context file using the PRD content as context
+            await this.generateFeaturesFile(contextDir, contextContent);
+            await this.generateUserFlowsFile(contextDir, contextContent);
+            await this.generateEdgeCasesFile(contextDir, contextContent);
+            await this.generateTechnicalSpecsFile(contextDir, contextContent);
+            return {
+                success: true,
+                content: "Context files generated successfully",
+                provider: "hybrid",
+                metadata: { model: "hybrid", tokens: 0, latency: 0 },
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `Context file generation failed: ${error instanceof Error ? error.message : String(error)}`,
+                provider: "system",
+                metadata: { model: "system", tokens: 0, latency: 0 },
+            };
+        }
+    }
+    async checkExistingContextFiles(contextDir) {
+        const files = [
+            "01a-features.md",
+            "01b-user-flows.md",
+            "01c-edge-cases.md",
+            "01d-technical-specs.md",
+        ];
+        const existingFiles = [];
+        for (const file of files) {
+            if (await fs.pathExists(path_1.default.join(contextDir, file))) {
+                existingFiles.push(file);
+            }
+        }
+        return existingFiles;
+    }
+    async generateFeaturesFile(contextDir, contextContent) {
+        const prompt = this.buildFeaturesPrompt(contextContent);
+        try {
+            // Add timeout to prevent infinite loops
+            const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error("AI generation timeout")), 30000) // 30 second timeout
+            );
+            const responsePromise = this.ai.generateText(prompt, {
+                temperature: 0.7,
+                maxTokens: 2000,
+            });
+            const response = (await Promise.race([
+                responsePromise,
+                timeoutPromise,
+            ]));
+            // Check if response is valid
+            if (!response || !response.text || response.text.trim().length < 50) {
+                throw new Error("AI response too short or invalid");
+            }
+            const content = this.formatFeaturesContent(response.text);
+            await fs.writeFile(path_1.default.join(contextDir, "01a-features.md"), content);
+        }
+        catch (error) {
+            console.log(chalk_1.default.yellow("⚠️  AI generation failed, using PRD content as fallback"));
+            // Fallback: Extract features from PRD content
+            const fallbackContent = this.extractFeaturesFromPRD(contextContent);
+            await fs.writeFile(path_1.default.join(contextDir, "01a-features.md"), fallbackContent);
+        }
+    }
+    async generateUserFlowsFile(contextDir, contextContent) {
+        const prompt = this.buildUserFlowsPrompt(contextContent);
+        try {
+            const response = await this.ai.generateText(prompt, {
+                temperature: 0.7,
+                maxTokens: 2000,
+            });
+            const content = this.formatUserFlowsContent(response.text);
+            await fs.writeFile(path_1.default.join(contextDir, "01b-user-flows.md"), content);
+        }
+        catch (error) {
+            console.log(chalk_1.default.yellow("⚠️  AI generation failed, using PRD content as fallback"));
+            // Fallback: Extract user flows from PRD content
+            const fallbackContent = this.extractUserFlowsFromPRD(contextContent);
+            await fs.writeFile(path_1.default.join(contextDir, "01b-user-flows.md"), fallbackContent);
+        }
+    }
+    async generateEdgeCasesFile(contextDir, contextContent) {
+        const prompt = this.buildEdgeCasesPrompt(contextContent);
+        try {
+            const response = await this.ai.generateText(prompt, {
+                temperature: 0.7,
+                maxTokens: 2000,
+            });
+            const content = this.formatEdgeCasesContent(response.text);
+            await fs.writeFile(path_1.default.join(contextDir, "01c-edge-cases.md"), content);
+        }
+        catch (error) {
+            console.log(chalk_1.default.yellow("⚠️  AI generation failed, using PRD content as fallback"));
+            // Fallback: Extract edge cases from PRD content
+            const fallbackContent = this.extractEdgeCasesFromPRD(contextContent);
+            await fs.writeFile(path_1.default.join(contextDir, "01c-edge-cases.md"), fallbackContent);
+        }
+    }
+    async generateTechnicalSpecsFile(contextDir, contextContent) {
+        const prompt = this.buildTechnicalSpecsPrompt(contextContent);
+        try {
+            const response = await this.ai.generateText(prompt, {
+                temperature: 0.7,
+                maxTokens: 2000,
+            });
+            const content = this.formatTechnicalSpecsContent(response.text);
+            await fs.writeFile(path_1.default.join(contextDir, "01d-technical-specs.md"), content);
+        }
+        catch (error) {
+            console.log(chalk_1.default.yellow("⚠️  AI generation failed, using PRD content as fallback"));
+            // Fallback: Extract technical specs from PRD content
+            const fallbackContent = this.extractTechnicalSpecsFromPRD(contextContent);
+            await fs.writeFile(path_1.default.join(contextDir, "01d-technical-specs.md"), fallbackContent);
+        }
+    }
+    buildFeaturesPrompt(contextContent) {
+        return `You are a product manager creating a comprehensive features document for a web application.
+
+${contextContent ? `Project Context (from PRD): ${contextContent}` : "Generate features for a modern web application."}
+
+Create a detailed features document that includes:
+
+1. **Core Features** - Primary functionality that defines the product
+2. **User Features** - Features that directly benefit end users
+3. **Admin Features** - Administrative and management capabilities
+4. **Technical Features** - Backend, API, and infrastructure features
+5. **Integration Features** - Third-party integrations and APIs
+6. **Security Features** - Authentication, authorization, and data protection
+7. **Performance Features** - Optimization and scalability features
+8. **Accessibility Features** - WCAG compliance and inclusive design
+
+For each feature, include:
+- Feature name and description
+- User value proposition
+- Acceptance criteria
+- Priority level (High/Medium/Low)
+- Dependencies on other features
+
+Format the output as a well-structured markdown document with clear sections and bullet points.`;
+    }
+    buildUserFlowsPrompt(contextContent) {
+        return `You are a UX designer creating comprehensive user flow documentation for a web application.
+
+${contextContent ? `Project Context (from PRD): ${contextContent}` : "Generate user flows for a modern web application."}
+
+Create detailed user flow documentation that includes:
+
+1. **Primary User Journeys** - Main user paths through the application
+2. **Authentication Flows** - Login, signup, password reset, etc.
+3. **Core Feature Flows** - How users interact with main features
+4. **Error Handling Flows** - What happens when things go wrong
+5. **Admin/Management Flows** - Administrative user journeys
+6. **Mobile vs Desktop Flows** - Responsive design considerations
+7. **Accessibility Flows** - Screen reader and keyboard navigation paths
+
+For each flow, include:
+- Flow name and description
+- Step-by-step user actions
+- System responses and feedback
+- Decision points and branches
+- Error states and recovery
+- Success criteria
+
+Format the output as a well-structured markdown document with clear sections, numbered steps, and flow diagrams in text format.`;
+    }
+    buildEdgeCasesPrompt(contextContent) {
+        return `You are a QA engineer creating comprehensive edge cases and error scenarios documentation for a web application.
+
+${contextContent ? `Project Context (from PRD): ${contextContent}` : "Generate edge cases for a modern web application."}
+
+Create detailed edge cases documentation that includes:
+
+1. **Input Validation Edge Cases** - Invalid, malformed, or extreme input scenarios
+2. **Network Edge Cases** - Offline, slow connections, timeouts, API failures
+3. **Browser Edge Cases** - Different browsers, versions, disabled features
+4. **Device Edge Cases** - Mobile, tablet, desktop, different screen sizes
+5. **Data Edge Cases** - Empty data, large datasets, concurrent modifications
+6. **Security Edge Cases** - Injection attacks, XSS, CSRF, unauthorized access
+7. **Performance Edge Cases** - High load, memory constraints, slow operations
+8. **Accessibility Edge Cases** - Screen readers, keyboard-only navigation, high contrast
+9. **Integration Edge Cases** - Third-party service failures, API changes
+10. **Business Logic Edge Cases** - Boundary conditions, race conditions
+
+For each edge case, include:
+- Scenario description
+- Expected behavior
+- Potential impact
+- Mitigation strategies
+- Testing approach
+
+Format the output as a well-structured markdown document with clear sections and detailed scenarios.`;
+    }
+    buildTechnicalSpecsPrompt(contextContent) {
+        return `You are a technical architect creating comprehensive technical specifications for a web application.
+
+${contextContent ? `Project Context (from PRD): ${contextContent}` : "Generate technical specs for a modern web application."}
+
+Create detailed technical specifications that include:
+
+1. **Architecture Overview** - System design, components, and relationships
+2. **Technology Stack** - Frontend, backend, database, deployment technologies
+3. **API Specifications** - Endpoints, request/response formats, authentication
+4. **Database Design** - Schema, relationships, indexing, data flow
+5. **Security Requirements** - Authentication, authorization, data protection
+6. **Performance Requirements** - Response times, throughput, scalability
+7. **Deployment Architecture** - Infrastructure, CI/CD, monitoring
+8. **Integration Requirements** - Third-party services, APIs, webhooks
+9. **Development Standards** - Code style, testing, documentation
+10. **Monitoring and Logging** - Error tracking, analytics, performance monitoring
+
+For each specification, include:
+- Requirement description
+- Technical approach
+- Implementation details
+- Dependencies
+- Success criteria
+
+Format the output as a well-structured markdown document with clear sections and technical details.`;
+    }
+    formatFeaturesContent(response) {
+        return `# Product Features
+
+${response}
+
+---
+*Generated by MyContext CLI - AI-powered component generation platform*
+*Last updated: ${new Date().toISOString()}*
+`;
+    }
+    formatUserFlowsContent(response) {
+        return `# User Flows
+
+${response}
+
+---
+*Generated by MyContext CLI - AI-powered component generation platform*
+*Last updated: ${new Date().toISOString()}*
+`;
+    }
+    formatEdgeCasesContent(response) {
+        return `# Edge Cases and Error Scenarios
+
+${response}
+
+---
+*Generated by MyContext CLI - AI-powered component generation platform*
+*Last updated: ${new Date().toISOString()}*
+`;
+    }
+    formatTechnicalSpecsContent(response) {
+        return `# Technical Specifications
+
+${response}
+
+---
+*Generated by MyContext CLI - AI-powered component generation platform*
+*Last updated: ${new Date().toISOString()}*
+`;
+    }
+    /**
+     * Get context content for generation - prefer PRD over description
+     */
+    async getContextForGeneration(contextDir, fallbackDescription) {
+        // First, try to read from 01-prd.md
+        const prdPath = path_1.default.join(contextDir, "01-prd.md");
+        if (await fs.pathExists(prdPath)) {
+            try {
+                const prdContent = await fs.readFile(prdPath, "utf8");
+                // Check if PRD is just a template/starter sample
+                if (this.isTemplatePRD(prdContent)) {
+                    console.log(chalk_1.default.yellow("⚠️  PRD appears to be a template, not using as context"));
+                }
+                else {
+                    console.log(chalk_1.default.blue("📖 Using existing PRD as context for context files generation"));
+                    return prdContent;
+                }
+            }
+            catch (error) {
+                console.log(chalk_1.default.yellow("⚠️  Could not read PRD file, falling back to description"));
+            }
+        }
+        // Fallback to description if no PRD exists
+        if (fallbackDescription) {
+            console.log(chalk_1.default.blue("📝 Using project description as context"));
+            return fallbackDescription;
+        }
+        // No context available - ask user
+        console.log(chalk_1.default.red("❌ No PRD or description found!"));
+        console.log(chalk_1.default.yellow("Please provide context by either:"));
+        console.log(chalk_1.default.gray("  1. Run 'mycontext generate context' first to create a PRD"));
+        console.log(chalk_1.default.gray("  2. Use --description flag: mycontext generate-context-files --description 'Your project'"));
+        console.log(chalk_1.default.gray("  3. Create a PRD file manually at .mycontext/01-prd.md"));
+        throw new Error("No context available for generation. Please provide a PRD or description.");
+    }
+    /**
+     * Check if PRD content is just a template/starter sample
+     */
+    isTemplatePRD(content) {
+        const templateIndicators = [
+            "MyContext project",
+            "Replace this with your actual project description",
+            "TODO: Add your project details",
+            "This is a template",
+            "Sample project",
+            "Example project",
+            "Your project description here",
+            "Project Name: [Your Project Name]",
+            "Description: [Your project description]",
+            "## Project Overview\n\n[Add your project overview here]",
+            "## Requirements\n\n[Add your requirements here]",
+            "## Features\n\n[Add your features here]",
+            "## Technical Specifications\n\n[Add your technical specs here]",
+        ];
+        // Check if content contains multiple template indicators
+        const templateMatches = templateIndicators.filter((indicator) => content.toLowerCase().includes(indicator.toLowerCase()));
+        // If more than 2 template indicators are found, it's likely a template
+        if (templateMatches.length >= 2) {
+            return true;
+        }
+        // Check if content is very short (likely a template)
+        if (content.trim().length < 200) {
+            return true;
+        }
+        // Check if content is mostly placeholder text
+        const placeholderRatio = (content.match(/\[.*?\]/g) || []).length /
+            (content.split(" ").length || 1);
+        if (placeholderRatio > 0.1) {
+            // More than 10% placeholders
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Extract features from PRD content as fallback
+     */
+    extractFeaturesFromPRD(prdContent) {
+        if (!prdContent) {
+            return `# Product Features
+
+## Core Features
+
+*No features available - PRD content not found*
+
+---
+*Generated by MyContext CLI - AI-powered component generation platform*
+*Last updated: ${new Date().toISOString()}*
+`;
+        }
+        // Extract features from PRD content
+        const features = this.extractSectionFromPRD(prdContent, [
+            "Core Features",
+            "Features",
+            "Key Features",
+            "Main Features",
+        ]);
+        return `# Product Features
+
+${features || "## Core Features\n\n*Features will be extracted from PRD content*"}
+
+---
+*Generated by MyContext CLI - AI-powered component generation platform*
+*Last updated: ${new Date().toISOString()}*
+`;
+    }
+    /**
+     * Extract user flows from PRD content as fallback
+     */
+    extractUserFlowsFromPRD(prdContent) {
+        if (!prdContent) {
+            return `# User Flows
+
+## User Journey
+
+*No user flows available - PRD content not found*
+
+---
+*Generated by MyContext CLI - AI-powered component generation platform*
+*Last updated: ${new Date().toISOString()}*
+`;
+        }
+        // Extract user flows from PRD content
+        const userFlows = this.extractSectionFromPRD(prdContent, [
+            "User Roles",
+            "User Journey",
+            "User Flows",
+            "Workflow",
+        ]);
+        return `# User Flows
+
+${userFlows || "## User Journey\n\n*User flows will be extracted from PRD content*"}
+
+---
+*Generated by MyContext CLI - AI-powered component generation platform*
+*Last updated: ${new Date().toISOString()}*
+`;
+    }
+    /**
+     * Extract edge cases from PRD content as fallback
+     */
+    extractEdgeCasesFromPRD(prdContent) {
+        if (!prdContent) {
+            return `# Edge Cases and Error Scenarios
+
+## Error Handling
+
+*No edge cases available - PRD content not found*
+
+---
+*Generated by MyContext CLI - AI-powered component generation platform*
+*Last updated: ${new Date().toISOString()}*
+`;
+        }
+        // Extract edge cases from PRD content
+        const edgeCases = this.extractSectionFromPRD(prdContent, [
+            "Risk Mitigation",
+            "Edge Cases",
+            "Error Scenarios",
+            "Troubleshooting",
+        ]);
+        return `# Edge Cases and Error Scenarios
+
+${edgeCases || "## Error Handling\n\n*Edge cases will be extracted from PRD content*"}
+
+---
+*Generated by MyContext CLI - AI-powered component generation platform*
+*Last updated: ${new Date().toISOString()}*
+`;
+    }
+    /**
+     * Extract technical specs from PRD content as fallback
+     */
+    extractTechnicalSpecsFromPRD(prdContent) {
+        if (!prdContent) {
+            return `# Technical Specifications
+
+## Architecture
+
+*No technical specs available - PRD content not found*
+
+---
+*Generated by MyContext CLI - AI-powered component generation platform*
+*Last updated: ${new Date().toISOString()}*
+`;
+        }
+        // Extract technical specs from PRD content
+        const techSpecs = this.extractSectionFromPRD(prdContent, [
+            "Technical Architecture",
+            "Technical Specifications",
+            "Architecture",
+            "Technology Stack",
+        ]);
+        return `# Technical Specifications
+
+${techSpecs || "## Architecture\n\n*Technical specifications will be extracted from PRD content*"}
+
+---
+*Generated by MyContext CLI - AI-powered component generation platform*
+*Last updated: ${new Date().toISOString()}*
+`;
+    }
+    /**
+     * Extract a section from PRD content by looking for common section headers
+     */
+    extractSectionFromPRD(prdContent, sectionHeaders) {
+        const lines = prdContent.split("\n");
+        let inSection = false;
+        let sectionContent = [];
+        let currentSection = "";
+        for (const line of lines) {
+            const trimmedLine = line.trim();
+            // Check if this line starts a section we're looking for
+            if (sectionHeaders.some((header) => trimmedLine.toLowerCase().includes(header.toLowerCase()) &&
+                (trimmedLine.startsWith("#") ||
+                    trimmedLine.startsWith("##") ||
+                    trimmedLine.startsWith("###")))) {
+                if (inSection) {
+                    // We found a new section, stop collecting the previous one
+                    break;
+                }
+                inSection = true;
+                currentSection = trimmedLine;
+                sectionContent.push(line);
+                continue;
+            }
+            if (inSection) {
+                // Check if we hit another major section (starts with # or ##)
+                if (trimmedLine.startsWith("#") &&
+                    !trimmedLine.includes(currentSection)) {
+                    break;
+                }
+                sectionContent.push(line);
+            }
+        }
+        return sectionContent.join("\n").trim();
+    }
 }
 exports.GenerateCommand = GenerateCommand;
 //# sourceMappingURL=generate.js.map