mycontext-cli 0.4.19 → 1.0.1

package/dist/commands/generate.js

@@ -44,16 +44,18 @@ const spinner_1 = require("../utils/spinner");
 const fileSystem_1 = require("../utils/fileSystem");
 const hybridAIClient_1 = require("../utils/hybridAIClient");
 const githubModelsClient_1 = require("../utils/githubModelsClient");
+const hostedApiClient_1 = require("../utils/hostedApiClient");
 const fs = __importStar(require("fs-extra"));
 class GenerateCommand {
     constructor() {
         this.fs = new fileSystem_1.FileSystemManager();
         this.spinner = new spinner_1.EnhancedSpinner("Processing...");
         this.ai = new hybridAIClient_1.HybridAIClient();
+        this.hostedApi = new hostedApiClient_1.HostedApiClient();
     }
     async execute(options) {
         try {
-            this.spinner.start();
+            this.spinner.start().updateText("Analyzing project context...");
             const projectContext = await this.resolveInputContext(options);
             if (!projectContext) {
                 throw new Error("No project context found. Run 'mycontext init' or pass --description/--context-file.");
@@ -146,14 +148,16 @@ class GenerateCommand {
                     else {
                         console.log(chalk_1.default.yellow(`⚠️ Project structure generation skipped or failed: ${structureRes.error || "unknown"}`));
                     }
-                    this.spinner.success({ text: "All artifacts generated" });
+                    this.spinner.success({
+                        text: "🎉 All artifacts generated successfully!",
+                    });
                     return;
                 }
                 default:
                     throw new Error(`Unknown generation type: ${type}`);
             }
             if (result.success && result.content) {
-                this.spinner.success({ text: "Generation completed successfully!" });
+                this.spinner.success({ text: `✅ ${type} generated successfully!` });
                 // Save the generated content
                 const outputPath = await this.saveGeneratedContent(type, result.content, options);
                 console.log(chalk_1.default.green(`✅ Generated ${type} saved to: ${outputPath}`));
@@ -245,15 +249,24 @@ class GenerateCommand {
             // Friendlier handling for missing providers
             const message = error instanceof Error ? error.message : String(error);
             if (/No AI providers available/i.test(message)) {
-                console.log(chalk_1.default.yellow("⚠️  No AI providers configured. You can rename .mycontext/.env.example to .env and add your MYCONTEXT_GITHUB_TOKEN (models:read), or start Ollama."));
-                console.log(chalk_1.default.gray("Example: mv .mycontext/.env.example .mycontext/.env && echo 'MYCONTEXT_GITHUB_TOKEN=ghp_xxx' >> .mycontext/.env"));
+                console.log(chalk_1.default.yellow("\n⚠️  No AI providers configured. Choose your option:"));
+                console.log(chalk_1.default.blue("\n🔑 Option 1: Use your own AI keys (recommended)"));
+                console.log(chalk_1.default.gray("   1. Copy: .mycontext/.env.example → .mycontext/.env"));
+                console.log(chalk_1.default.gray("   2. Add: MYCONTEXT_GITHUB_TOKEN=ghp_xxx"));
+                console.log(chalk_1.default.gray("   3. Or: MYCONTEXT_QWEN_API_KEY=sk-or-xxx (free via OpenRouter)"));
+                console.log(chalk_1.default.blue("\n🌐 Option 2: Use hosted MyContext AI"));
+                console.log(chalk_1.default.gray("   1. Run: mycontext auth login"));
+                console.log(chalk_1.default.gray("   2. Sign up for free at: https://mycontext.fbien.com"));
+                console.log(chalk_1.default.gray("   3. Get $5/month unlimited plan"));
                 // Fallback: write a minimal, valid skeleton so users can proceed
                 try {
                     const fallbackType = options?.type || "context";
                     const fallbackProjectContext = (await this.getProjectContext()) || {};
                     const skeleton = this.buildSkeleton(String(fallbackType), fallbackProjectContext);
                     const outputPath = await this.saveGeneratedContent(String(fallbackType), skeleton, options);
-                    this.spinner.success({ text: `Wrote skeleton → ${outputPath}` });
+                    this.spinner.success({
+                        text: `✨ Generated basic template → ${outputPath}`,
+                    });
                     return;
                 }
                 catch (e) {
@@ -277,6 +290,18 @@ class GenerateCommand {
             return null;
         }
     }
+    async getActivePlaybook() {
+        try {
+            const playbookPath = path_1.default.join(process.cwd(), ".mycontext", "active-playbook.json");
+            if (await fs.pathExists(playbookPath)) {
+                return await fs.readJson(playbookPath);
+            }
+        }
+        catch (error) {
+            // Ignore errors
+        }
+        return null;
+    }
     async resolveInputContext(options) {
         // 1) Explicit description wins
         if (options.description && options.description.trim()) {
@@ -336,35 +361,31 @@ class GenerateCommand {
         catch { }
         // 5) Interactive prompt to capture description (when not in --yes)
         if (!options.yes) {
-            const answer = await (0, prompts_1.default)({
-                type: "toggle",
-                name: "paste",
-                message: "Provide a project description/PRD now? (Paste multi-line, finish with Ctrl-D)",
-                initial: true,
-                active: "yes",
-                inactive: "no",
-            });
-            if (answer && answer.paste) {
-                console.log(chalk_1.default.blue("\nPaste your description/PRD below. When done, press Ctrl-D (Linux/macOS) or Ctrl-Z then Enter (Windows).\n"));
-                const pasted = await this.readStdinBlockUntilEOF();
-                if (pasted && pasted.trim().length > 0) {
-                    const desc = pasted.trim();
-                    // Truncate long descriptions for terminal display
-                    const truncatedDesc = desc.length > 100 ? desc.substring(0, 100) + "..." : desc;
-                    console.log(chalk_1.default.gray(`📝 Interactive description: ${truncatedDesc}`));
-                    return { description: desc };
-                }
+            this.spinner.stop();
+            console.log(chalk_1.default.blue("\n📝 Project Description"));
+            console.log(chalk_1.default.gray("Enter your project description or PRD. Press Ctrl-D when finished."));
+            const pasted = await this.readStdinBlockUntilEOF();
+            if (pasted && pasted.trim().length > 0) {
+                const desc = pasted.trim();
+                // Truncate long descriptions for terminal display
+                const truncatedDesc = desc.length > 100 ? desc.substring(0, 100) + "..." : desc;
+                console.log(chalk_1.default.gray(`📝 Description: ${truncatedDesc}`));
+                this.spinner.start().updateText("Processing description...");
+                return { description: desc };
             }
             else {
+                // Fallback to simple text input
                 const short = await (0, prompts_1.default)({
                     type: "text",
                     name: "desc",
-                    message: "Short project description (optional):",
+                    message: "Short project description:",
                 });
                 if (short?.desc && String(short.desc).trim().length > 0) {
+                    this.spinner.start().updateText("Processing description...");
                     return { description: String(short.desc).trim() };
                 }
             }
+            this.spinner.start().updateText("Continuing without description...");
         }
         // 6) Fallback to project config
         return await this.getProjectContext();
@@ -391,10 +412,29 @@ class GenerateCommand {
             }
         }
         catch { }
+        // Get active playbook for additional context
+        const activePlaybook = await this.getActivePlaybook();
         const prompt = [
             `[mycontext] Plan: plan → generate → QA → docs → preview (→ checks)`,
             `Create a production-grade PRD for: ${projectContext.description || "MyContext project"}`,
             "",
+            // Include playbook context if available
+            ...(activePlaybook
+                ? [
+                    "",
+                    "## Proven Process Reference",
+                    `**Active Playbook: ${activePlaybook.title}**`,
+                    `Category: ${activePlaybook.category || "N/A"}`,
+                    `Difficulty: ${activePlaybook.metadata?.difficulty || "N/A"}`,
+                    `Estimated Time: ${activePlaybook.metadata?.estimatedTime || "N/A"}`,
+                    "",
+                    "**Process Guidelines:**",
+                    activePlaybook.content,
+                    "",
+                    "**Important:** Follow the proven patterns and best practices outlined in the playbook above. This will ensure your implementation follows industry standards and proven approaches.",
+                    "",
+                ]
+                : []),
             "Assume default stack unless user specifies otherwise:",
             "- Frontend: Next.js (App Router) with Shadcn UI",
             "- Auth/DB/File storage: InstantDB (auth, data, file persistence)",
@@ -455,22 +495,51 @@ class GenerateCommand {
             "Write concretely. Ground content in the provided description. No placeholders.",
         ].join("\n");
         try {
-            this.spinner.updateText(`Generating PRD with AI (${await this.ai.getActiveProviderName()}/${await this.ai.getActiveTextModelName()})...`);
-            const { text, provider } = await this.ai.generateText(prompt, {
-                model: options.model || process.env.MYCONTEXT_MODEL,
-                modelCandidates: this.getModelCandidates(options),
-            });
-            const cleaned = this.sanitizeMarkdownOutput(text);
-            return {
-                success: true,
-                content: cleaned,
-                provider: provider,
-                metadata: {
-                    model: "auto",
-                    tokens: cleaned.length / 4, // Rough estimate
-                    latency: 1000,
-                },
-            };
+            // Check if user has local AI keys configured
+            const hasLocalKeys = this.hasLocalAIKeys();
+            if (hasLocalKeys) {
+                // Use local AI first (user's own keys)
+                this.spinner.updateText(`🤖 Generating PRD with ${await this.ai.getActiveProviderName()}...`);
+                const { text, provider } = await this.ai.generateText(prompt, {
+                    model: options.model || process.env.MYCONTEXT_MODEL,
+                    modelCandidates: this.getModelCandidates(options),
+                });
+                const cleaned = this.sanitizeMarkdownOutput(text);
+                return {
+                    success: true,
+                    content: cleaned,
+                    provider: provider,
+                    metadata: {
+                        model: "local",
+                        tokens: cleaned.length / 4,
+                        latency: 1000,
+                    },
+                };
+            }
+            else {
+                // No local keys - use hosted API (requires authentication)
+                this.spinner.updateText("🤖 Generating PRD with MyContext AI (hosted)...");
+                const hostedResult = await this.hostedApi.generateContext("context", prompt, {
+                    model: options.model || "mycontext",
+                    context: projectContext,
+                });
+                if (hostedResult.success && hostedResult.data) {
+                    const cleaned = this.sanitizeMarkdownOutput(hostedResult.data);
+                    return {
+                        success: true,
+                        content: cleaned,
+                        provider: "hosted",
+                        metadata: {
+                            model: "mycontext",
+                            tokens: cleaned.length / 4,
+                            latency: 1000,
+                        },
+                    };
+                }
+                else {
+                    throw new Error(hostedResult.error || "Hosted API failed");
+                }
+            }
         }
         catch (error) {
             return {
@@ -536,23 +605,53 @@ lib/types/
 - Use generics where appropriate
 - Keep types focused and single-purpose`;
         try {
-            this.spinner.updateText(`Generating comprehensive TypeScript type system with AI (${await this.ai.getActiveProviderName()}/${await this.ai.getActiveTextModelName()})...`);
-            const { text, provider } = await this.ai.generateText(prompt, {
-                model: options.model || process.env.MYCONTEXT_MODEL,
-                modelCandidates: this.getModelCandidates(options),
-            });
-            // Parse the generated content and create structured files
-            const structuredContent = this.parseAndStructureTypes(text);
-            return {
-                success: true,
-                content: structuredContent,
-                provider: provider,
-                metadata: {
-                    model: "auto",
-                    tokens: structuredContent.length / 4,
-                    latency: 600,
-                },
-            };
+            // Check if user has local AI keys configured
+            const hasLocalKeys = this.hasLocalAIKeys();
+            if (hasLocalKeys) {
+                // Use local AI first (user's own keys)
+                this.spinner.updateText(`🔧 Generating TypeScript types with ${await this.ai.getActiveProviderName()}...`);
+                const { text, provider } = await this.ai.generateText(prompt, {
+                    model: options.model || process.env.MYCONTEXT_MODEL,
+                    modelCandidates: this.getModelCandidates(options),
+                });
+                // Parse the generated content and create structured files
+                const structuredContent = this.parseAndStructureTypes(text);
+                return {
+                    success: true,
+                    content: structuredContent,
+                    provider: provider,
+                    metadata: {
+                        model: "local",
+                        tokens: structuredContent.length / 4,
+                        latency: 600,
+                    },
+                };
+            }
+            else {
+                // No local keys - use hosted API (requires authentication)
+                this.spinner.updateText("🔧 Generating TypeScript types with MyContext AI (hosted)...");
+                const hostedResult = await this.hostedApi.generateContext("types", prompt, {
+                    model: options.model || "mycontext",
+                    context: projectContext,
+                });
+                if (hostedResult.success && hostedResult.data) {
+                    // Parse the generated content and create structured files
+                    const structuredContent = this.parseAndStructureTypes(hostedResult.data);
+                    return {
+                        success: true,
+                        content: structuredContent,
+                        provider: "hosted",
+                        metadata: {
+                            model: "mycontext",
+                            tokens: structuredContent.length / 4,
+                            latency: 600,
+                        },
+                    };
+                }
+                else {
+                    throw new Error(hostedResult.error || "Hosted API failed");
+                }
+            }
         }
         catch (error) {
             return {
@@ -1123,23 +1222,53 @@ Create a globals.css file with proper CSS custom properties following this exact
 
 Make the CSS immediately usable - no placeholders, actual working values!`;
         try {
-            this.spinner.updateText(`Generating comprehensive brand system with CSS custom properties (${await this.ai.getActiveProviderName()}/${await this.ai.getActiveTextModelName()})...`);
-            const { text, provider } = await this.ai.generateText(prompt, {
-                model: options.model || process.env.MYCONTEXT_MODEL,
-                modelCandidates: this.getModelCandidates(options),
-            });
-            // Parse and create the brand system files
-            const brandFiles = this.parseAndCreateBrandSystem(text);
-            return {
-                success: true,
-                content: brandFiles.guide,
-                provider: provider,
-                metadata: {
-                    model: "auto",
-                    tokens: brandFiles.guide.length / 4,
-                    latency: 600,
-                },
-            };
+            // Check if user has local AI keys configured
+            const hasLocalKeys = this.hasLocalAIKeys();
+            if (hasLocalKeys) {
+                // Use local AI first (user's own keys)
+                this.spinner.updateText(`🎨 Generating brand system with ${await this.ai.getActiveProviderName()}...`);
+                const { text, provider } = await this.ai.generateText(prompt, {
+                    model: options.model || process.env.MYCONTEXT_MODEL,
+                    modelCandidates: this.getModelCandidates(options),
+                });
+                // Parse and create the brand system files
+                const brandFiles = this.parseAndCreateBrandSystem(text);
+                return {
+                    success: true,
+                    content: brandFiles.guide,
+                    provider: provider,
+                    metadata: {
+                        model: "local",
+                        tokens: brandFiles.guide.length / 4,
+                        latency: 600,
+                    },
+                };
+            }
+            else {
+                // No local keys - use hosted API (requires authentication)
+                this.spinner.updateText("🎨 Generating brand system with MyContext AI (hosted)...");
+                const hostedResult = await this.hostedApi.generateContext("brand", prompt, {
+                    model: options.model || "mycontext",
+                    context: projectContext,
+                });
+                if (hostedResult.success && hostedResult.data) {
+                    // Parse and create the brand system files
+                    const brandFiles = this.parseAndCreateBrandSystem(hostedResult.data);
+                    return {
+                        success: true,
+                        content: brandFiles.guide,
+                        provider: "hosted",
+                        metadata: {
+                            model: "mycontext",
+                            tokens: brandFiles.guide.length / 4,
+                            latency: 600,
+                        },
+                    };
+                }
+                else {
+                    throw new Error(hostedResult.error || "Hosted API failed");
+                }
+            }
         }
         catch (error) {
             return {
@@ -1279,31 +1408,51 @@ Make the CSS immediately usable - no placeholders, actual working values!`;
             "- Provide up to 3 'coreCandidates' that best represent the design anchor (canvas/layout), with a short reason.",
         ].join("\n");
         try {
-            this.spinner.updateText(`Generating component list with AI (${await this.ai.getActiveProviderName()}/${await this.ai.getActiveTextModelName()})...`);
+            // Check if user has local AI keys configured
+            const hasLocalKeys = this.hasLocalAIKeys();
             let text;
             let provider;
-            try {
-                const r = await this.ai.generateText(prompt, {
-                    model: options.model || process.env.MYCONTEXT_MODEL,
-                    modelCandidates: this.getModelCandidates(options),
-                });
-                text = r.text;
-                provider = r.provider;
-            }
-            catch (e) {
-                // Handle transient network issues like unexpected EOF with a single retry
-                const msg = String(e?.message || e);
-                if (/unexpected EOF|ECONNRESET|EPIPE/i.test(msg)) {
-                    this.spinner.updateText("Retrying component list generation after transient error...");
-                    const r2 = await this.ai.generateText(prompt, {
+            if (hasLocalKeys) {
+                // Use local AI first (user's own keys)
+                this.spinner.updateText(`📋 Generating component list with ${await this.ai.getActiveProviderName()}...`);
+                try {
+                    const r = await this.ai.generateText(prompt, {
                         model: options.model || process.env.MYCONTEXT_MODEL,
                         modelCandidates: this.getModelCandidates(options),
                     });
-                    text = r2.text;
-                    provider = r2.provider;
+                    text = r.text;
+                    provider = r.provider;
+                }
+                catch (e) {
+                    // Handle transient network issues like unexpected EOF with a single retry
+                    const msg = String(e?.message || e);
+                    if (/unexpected EOF|ECONNRESET|EPIPE/i.test(msg)) {
+                        this.spinner.updateText("Retrying component list generation after transient error...");
+                        const r2 = await this.ai.generateText(prompt, {
+                            model: options.model || process.env.MYCONTEXT_MODEL,
+                            modelCandidates: this.getModelCandidates(options),
+                        });
+                        text = r2.text;
+                        provider = r2.provider;
+                    }
+                    else {
+                        throw e;
+                    }
+                }
+            }
+            else {
+                // No local keys - use hosted API (requires authentication)
+                this.spinner.updateText("📋 Generating component list with MyContext AI (hosted)...");
+                const hostedResult = await this.hostedApi.generateContext("components-list", prompt, {
+                    model: options.model || "mycontext",
+                    context: projectContext,
+                });
+                if (hostedResult.success && hostedResult.data) {
+                    text = hostedResult.data;
+                    provider = "hosted";
                 }
                 else {
-                    throw e;
+                    throw new Error(hostedResult.error || "Hosted API failed");
                 }
             }
             // Attempt to repair and extract valid JSON
@@ -2774,6 +2923,14 @@ ${isEcommerce
         }
         catch { }
     }
+    hasLocalAIKeys() {
+        // Check for any local AI provider keys
+        return !!(process.env.MYCONTEXT_GITHUB_TOKEN ||
+            process.env.MYCONTEXT_QWEN_API_KEY ||
+            process.env.OPENAI_API_KEY ||
+            process.env.ANTHROPIC_API_KEY ||
+            process.env.HUGGINGFACE_API_KEY);
+    }
     getModelCandidates(options) {
         const raw = options.modelCandidates ||
             options.models ||