@vibecheckai/cli 3.9.0 → 4.0.0

package/mcp-server/src/services/prompt-builder-service.ts

@@ -0,0 +1,1031 @@
+/**
+ * Prompt Builder Service for MCP Server
+ * Provides intelligent prompt templates and building functionality
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import type {
+  PromptTemplate,
+  PromptCategory,
+  ContextQuestion,
+  WorkspaceContext,
+  BuiltPrompt,
+  PromptQuality,
+  SmartSuggestion,
+} from '../types.js';
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// Smart Variables
+// ═══════════════════════════════════════════════════════════════════════════════
+
+const SMART_VARIABLES: Record<string, (ctx: WorkspaceContext) => string> = {
+  '{{PROJECT_NAME}}': ctx => ctx.projectName,
+  '{{FRAMEWORK}}': ctx => ctx.framework,
+  '{{LANGUAGE}}': ctx => ctx.language === 'typescript' ? 'TypeScript' : 'JavaScript',
+  '{{PACKAGE_MANAGER}}': ctx => ctx.packageManager,
+  '{{DATABASE}}': ctx => {
+    if (ctx.hasSupabase) return 'Supabase';
+    if (ctx.hasPrisma && ctx.hasPostgres) return 'PostgreSQL with Prisma';
+    if (ctx.hasDrizzle) return 'Drizzle ORM';
+    if (ctx.hasMongoDB) return 'MongoDB';
+    if (ctx.hasFirebase) return 'Firebase';
+    return 'PostgreSQL';
+  },
+  '{{AUTH_LIBRARY}}': ctx => {
+    if (ctx.hasClerk) return 'Clerk';
+    if (ctx.hasNextAuth || ctx.hasAuthJs) return 'NextAuth.js / Auth.js';
+    if (ctx.hasSupabase) return 'Supabase Auth';
+    if (ctx.hasFirebase) return 'Firebase Auth';
+    return 'NextAuth.js';
+  },
+  '{{UI_LIBRARY}}': ctx => {
+    if (ctx.hasShadcn) return 'shadcn/ui';
+    if (ctx.hasRadix) return 'Radix UI';
+    if (ctx.hasTailwind) return 'Tailwind CSS';
+    return 'Tailwind CSS';
+  },
+  '{{TEST_FRAMEWORK}}': ctx => ctx.testFramework || 'Vitest',
+};
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// Prompt Templates (Subset for MCP - Full set available)
+// ═══════════════════════════════════════════════════════════════════════════════
+
+const PROMPT_TEMPLATES: PromptTemplate[] = [
+  // Authentication
+  {
+    id: 'auth-oauth',
+    name: 'OAuth Login (Google, GitHub, etc.)',
+    category: 'authentication',
+    description: 'Social login with multiple OAuth providers',
+    icon: '🔐',
+    keywords: ['login', 'signin', 'oauth', 'google', 'github', 'auth', 'authentication', 'social login'],
+    popularity: 100,
+    contextQuestions: [
+      {
+        id: 'providers',
+        label: 'OAuth Providers',
+        placeholder: 'Select providers to integrate',
+        type: 'multiselect',
+        options: [
+          { label: 'Google', value: 'google', default: true },
+          { label: 'GitHub', value: 'github', default: true },
+          { label: 'Discord', value: 'discord' },
+          { label: 'Apple', value: 'apple' },
+        ],
+        required: true,
+      },
+      {
+        id: 'authLibrary',
+        label: 'Auth Library',
+        placeholder: 'Select authentication library',
+        type: 'select',
+        options: [
+          { label: 'NextAuth.js / Auth.js', value: 'nextauth', default: true },
+          { label: 'Clerk', value: 'clerk' },
+          { label: 'Supabase Auth', value: 'supabase' },
+        ],
+        required: true,
+      },
+    ],
+    outputSections: ['Plan', 'Files', 'Code', 'Env Variables', 'Provider Setup', 'Test Checklist'],
+    template: `You are a senior full-stack engineer. IMPLEMENT a production-ready authentication system with **{{providers}}** OAuth.
+
+## Project Context
+- **Framework**: {{frontend}}
+- **Backend**: {{backend}}
+- **Database**: {{database}}
+- **Auth Library**: {{authLibrary}}
+- **TypeScript**: {{typescript}}
+
+## Requirements
+1. **Login Page** at \`/login\` with provider buttons
+2. **Auth Callbacks** for each provider
+3. **Session Management** with secure cookies
+4. **Protected Routes** middleware
+5. **Sign Out** functionality
+
+## Output Format
+A) Plan (10 bullets max)
+B) Files to create
+C) Complete code for each file
+D) Environment variables
+E) Provider setup guide
+F) Testing checklist`,
+  },
+
+  // API Development
+  {
+    id: 'api-rest-crud',
+    name: 'REST API with CRUD',
+    category: 'api',
+    description: 'Full CRUD API with validation and error handling',
+    icon: '🔌',
+    keywords: ['api', 'rest', 'crud', 'endpoint', 'route', 'backend'],
+    popularity: 90,
+    contextQuestions: [
+      {
+        id: 'resource',
+        label: 'Resource Name',
+        placeholder: 'e.g., users, products, posts',
+        type: 'text',
+        required: true,
+      },
+      {
+        id: 'operations',
+        label: 'Operations',
+        placeholder: 'Select CRUD operations',
+        type: 'multiselect',
+        options: [
+          { label: 'Create (POST)', value: 'create', default: true },
+          { label: 'Read One (GET /:id)', value: 'read-one', default: true },
+          { label: 'Read All (GET /)', value: 'read-all', default: true },
+          { label: 'Update (PATCH)', value: 'update', default: true },
+          { label: 'Delete (DELETE)', value: 'delete', default: true },
+          { label: 'Pagination', value: 'pagination', default: true },
+        ],
+        required: true,
+      },
+    ],
+    outputSections: ['Plan', 'Schema', 'Routes', 'Validation', 'Code', 'Tests'],
+    template: `You are a senior backend engineer. IMPLEMENT a production-ready REST API for **{{resource}}**.
+
+## Context
+- **Backend**: {{backend}}
+- **Database**: {{database}}
+- **Validation**: Zod
+- **TypeScript**: {{typescript}}
+
+## Endpoints
+POST   /api/{{resource}}           # Create
+GET    /api/{{resource}}           # List (paginated)
+GET    /api/{{resource}}/:id       # Get by ID
+PATCH  /api/{{resource}}/:id       # Update
+DELETE /api/{{resource}}/:id       # Delete
+
+## Output Format
+A) Plan (10 bullets)
+B) Database schema
+C) Zod validation schemas
+D) Route handlers (complete code)
+E) Error handling
+F) Test examples`,
+  },
+
+  // Frontend Component
+  {
+    id: 'frontend-component',
+    name: 'React Component',
+    category: 'frontend',
+    description: 'Production-ready React component with variants',
+    icon: '⚛️',
+    keywords: ['react', 'component', 'ui', 'frontend', 'tsx'],
+    popularity: 95,
+    contextQuestions: [
+      {
+        id: 'componentName',
+        label: 'Component Name',
+        placeholder: 'e.g., DataTable, Modal, Sidebar',
+        type: 'text',
+        required: true,
+      },
+      {
+        id: 'componentType',
+        label: 'Component Type',
+        placeholder: 'Select component type',
+        type: 'select',
+        options: [
+          { label: 'UI Component', value: 'ui', default: true },
+          { label: 'Layout', value: 'layout' },
+          { label: 'Form', value: 'form' },
+          { label: 'Data Display', value: 'data' },
+        ],
+        required: true,
+      },
+    ],
+    outputSections: ['Plan', 'API Design', 'Code', 'Variants', 'Usage', 'Tests'],
+    template: `You are a senior frontend engineer. IMPLEMENT a production-ready React component: **{{componentName}}**.
+
+## Context
+- **Framework**: {{frontend}}
+- **Styling**: {{styling}}
+- **TypeScript**: {{typescript}}
+
+## Requirements
+1. **TypeScript** with comprehensive props interface
+2. **Accessible** with proper ARIA attributes
+3. **Composable** using forwardRef
+4. **Dark mode** support
+
+## Output Format
+A) Props interface with JSDoc
+B) Component implementation
+C) Variant definitions
+D) Usage examples
+E) Tests`,
+  },
+
+  // Debugging
+  {
+    id: 'debug-error',
+    name: 'Debug Error',
+    category: 'debugging',
+    description: 'Systematic error diagnosis and fix',
+    icon: '🐛',
+    keywords: ['debug', 'error', 'bug', 'fix', 'troubleshoot'],
+    popularity: 90,
+    contextQuestions: [
+      {
+        id: 'errorMessage',
+        label: 'Error Message',
+        placeholder: 'Paste the error message or stack trace',
+        type: 'text',
+        required: true,
+      },
+      {
+        id: 'context',
+        label: 'When it occurs',
+        placeholder: 'Describe when the error happens',
+        type: 'text',
+        required: true,
+      },
+    ],
+    outputSections: ['Analysis', 'Root Cause', 'Solution', 'Prevention', 'Testing'],
+    template: `You are a senior debugging specialist. DIAGNOSE and FIX this error:
+
+## Error
+\`\`\`
+{{errorMessage}}
+\`\`\`
+
+## Context
+- **When**: {{context}}
+- **Stack**: {{frontend}} + {{backend}} + {{database}}
+
+## Your Task
+1. **Analyze** the error message and trace
+2. **Identify** the root cause
+3. **Provide** the exact fix (code, not explanation)
+4. **Explain** why this happened
+5. **Prevent** similar issues
+
+## Output Format
+A) Error Analysis
+B) Root Cause
+C) Solution (exact code fix)
+D) Prevention strategy
+E) Test to verify fix`,
+  },
+
+  // Testing
+  {
+    id: 'testing-unit',
+    name: 'Unit Tests',
+    category: 'testing',
+    description: 'Comprehensive unit tests with edge cases',
+    icon: '🧪',
+    keywords: ['test', 'unit', 'jest', 'vitest', 'testing'],
+    popularity: 80,
+    contextQuestions: [
+      {
+        id: 'target',
+        label: 'Code to Test',
+        placeholder: 'Describe the function/component',
+        type: 'text',
+        required: true,
+      },
+      {
+        id: 'framework',
+        label: 'Test Framework',
+        placeholder: 'Select framework',
+        type: 'select',
+        options: [
+          { label: 'Vitest', value: 'vitest', default: true },
+          { label: 'Jest', value: 'jest' },
+        ],
+        required: true,
+      },
+    ],
+    outputSections: ['Test Plan', 'Tests', 'Mocks', 'Coverage'],
+    template: `You are a senior QA engineer. WRITE comprehensive unit tests for: **{{target}}**.
+
+## Context
+- **Framework**: {{framework}}
+
+## Test Categories
+1. **Happy Path** - Normal expected flows
+2. **Edge Cases** - Empty, null, max values
+3. **Error Cases** - Invalid inputs, failures
+
+## Requirements
+1. **AAA pattern**: Arrange, Act, Assert
+2. **Isolated tests** - Each test independent
+3. **80%+ coverage** target
+
+## Output Format
+A) Test plan
+B) Complete test files
+C) Mock implementations
+D) Coverage notes`,
+  },
+
+  // Database
+  {
+    id: 'database-schema',
+    name: 'Database Schema Design',
+    category: 'database',
+    description: 'Complete schema with relationships and indexes',
+    icon: '🗄️',
+    keywords: ['database', 'schema', 'model', 'table', 'migration', 'prisma'],
+    popularity: 85,
+    contextQuestions: [
+      {
+        id: 'domain',
+        label: 'Domain/Feature',
+        placeholder: 'e.g., e-commerce, blog, SaaS',
+        type: 'text',
+        required: true,
+      },
+      {
+        id: 'entities',
+        label: 'Main Entities',
+        placeholder: 'e.g., users, products, orders',
+        type: 'text',
+        required: true,
+      },
+      {
+        id: 'orm',
+        label: 'ORM',
+        placeholder: 'Select ORM',
+        type: 'select',
+        options: [
+          { label: 'Prisma', value: 'prisma', default: true },
+          { label: 'Drizzle ORM', value: 'drizzle' },
+        ],
+        required: true,
+      },
+    ],
+    outputSections: ['Plan', 'ERD', 'Schema', 'Migrations', 'Seeds', 'Queries'],
+    template: `You are a senior database architect. DESIGN and IMPLEMENT a schema for **{{domain}}**.
+
+## Context
+- **Database**: {{database}}
+- **ORM**: {{orm}}
+- **Entities**: {{entities}}
+
+## Requirements
+1. **Normalized** (3NF minimum)
+2. **Proper relationships** with foreign keys
+3. **Strategic indexes** for common queries
+
+## Output Format
+A) Plan with design decisions
+B) ERD diagram (Mermaid)
+C) Complete schema file
+D) Migration files
+E) Seed data
+F) Example queries`,
+  },
+
+  // General Feature
+  {
+    id: 'general-feature',
+    name: 'Implement Feature',
+    category: 'general',
+    description: 'Build any feature with best practices',
+    icon: '✨',
+    keywords: ['feature', 'implement', 'build', 'create', 'add'],
+    popularity: 100,
+    contextQuestions: [
+      {
+        id: 'feature',
+        label: 'Feature Description',
+        placeholder: 'Describe what you want to build',
+        type: 'text',
+        required: true,
+      },
+      {
+        id: 'acceptance',
+        label: 'Acceptance Criteria',
+        placeholder: 'What defines "done"?',
+        type: 'text',
+        required: false,
+      },
+    ],
+    outputSections: ['Plan', 'Files', 'Code', 'Tests', 'Documentation'],
+    template: `You are a senior full-stack engineer. IMPLEMENT: **{{feature}}**.
+
+## Context
+- **Frontend**: {{frontend}}
+- **Backend**: {{backend}}
+- **Database**: {{database}}
+- **TypeScript**: {{typescript}}
+
+{{#if acceptance}}
+## Acceptance Criteria
+{{acceptance}}
+{{/if}}
+
+## Requirements
+1. **Production-ready** code
+2. **Type-safe** with TypeScript
+3. **Error handling** for all edge cases
+4. **File-by-file** implementation
+
+## Output Format
+A) Plan (10 bullets max)
+B) Files to create
+C) Complete code for each file
+D) Tests
+E) Usage example`,
+  },
+
+  // AI Integration
+  {
+    id: 'ai-integration',
+    name: 'AI Integration',
+    category: 'ai-ml',
+    description: 'Integrate OpenAI, Anthropic, or other AI APIs',
+    icon: '🤖',
+    keywords: ['ai', 'openai', 'gpt', 'claude', 'anthropic', 'llm'],
+    popularity: 85,
+    isNew: true,
+    contextQuestions: [
+      {
+        id: 'provider',
+        label: 'AI Provider',
+        placeholder: 'Select provider',
+        type: 'select',
+        options: [
+          { label: 'OpenAI (GPT-4)', value: 'openai', default: true },
+          { label: 'Anthropic (Claude)', value: 'anthropic' },
+          { label: 'Vercel AI SDK', value: 'vercel-ai' },
+        ],
+        required: true,
+      },
+      {
+        id: 'useCase',
+        label: 'Use Case',
+        placeholder: 'Select use case',
+        type: 'select',
+        options: [
+          { label: 'Chat interface', value: 'chat', default: true },
+          { label: 'Text generation', value: 'generation' },
+          { label: 'Embeddings/RAG', value: 'embeddings' },
+        ],
+        required: true,
+      },
+    ],
+    outputSections: ['Plan', 'API Setup', 'Client', 'UI', 'Code', 'Error Handling'],
+    template: `You are a senior AI engineer. IMPLEMENT **{{useCase}}** with **{{provider}}**.
+
+## Context
+- **Framework**: {{frontend}}
+- **Provider**: {{provider}}
+
+## Requirements
+1. **Type-safe** API integration
+2. **Streaming** support (if chat)
+3. **Error handling** with retries
+4. **Secure** API key handling
+
+## Output Format
+A) Plan
+B) API client setup
+C) React hooks/components
+D) UI implementation
+E) Error handling
+F) Usage examples`,
+  },
+
+  // Deployment
+  {
+    id: 'deployment-docker',
+    name: 'Docker Setup',
+    category: 'deployment',
+    description: 'Optimized Docker for dev and production',
+    icon: '🐳',
+    keywords: ['docker', 'container', 'dockerfile', 'compose', 'deployment'],
+    popularity: 80,
+    contextQuestions: [
+      {
+        id: 'appType',
+        label: 'Application Type',
+        placeholder: 'Select app type',
+        type: 'select',
+        options: [
+          { label: 'Next.js', value: 'nextjs', default: true },
+          { label: 'Node.js', value: 'node' },
+          { label: 'Python', value: 'python' },
+        ],
+        required: true,
+      },
+    ],
+    outputSections: ['Plan', 'Dockerfile', 'Compose Dev', 'Compose Prod', 'Scripts'],
+    template: `You are a senior DevOps engineer. CREATE Docker configuration for **{{appType}}**.
+
+## Requirements
+1. **Multi-stage build** for minimal production image
+2. **Non-root user** in production
+3. **.dockerignore** to exclude unnecessary files
+4. **Health checks** for all services
+
+## Output Format
+A) Plan
+B) Dockerfile (optimized)
+C) docker-compose.yml (dev)
+D) docker-compose.prod.yml
+E) .dockerignore
+F) Common commands`,
+  },
+
+  // Security
+  {
+    id: 'security-audit',
+    name: 'Security Audit',
+    category: 'security',
+    description: 'Comprehensive security review',
+    icon: '🛡️',
+    keywords: ['security', 'audit', 'vulnerability', 'penetration', 'secure'],
+    popularity: 75,
+    contextQuestions: [
+      {
+        id: 'scope',
+        label: 'Audit Scope',
+        placeholder: 'What to audit',
+        type: 'multiselect',
+        options: [
+          { label: 'Authentication', value: 'auth', default: true },
+          { label: 'Authorization', value: 'authz', default: true },
+          { label: 'API Security', value: 'api', default: true },
+          { label: 'Data Validation', value: 'validation' },
+          { label: 'Dependencies', value: 'deps' },
+        ],
+        required: true,
+      },
+    ],
+    outputSections: ['Summary', 'Findings', 'Risk Matrix', 'Remediation', 'Checklist'],
+    template: `You are a senior security engineer. CONDUCT a security audit.
+
+## Scope
+{{scope}}
+
+## Framework
+- **Frontend**: {{frontend}}
+- **Backend**: {{backend}}
+- **Database**: {{database}}
+
+## Audit Areas
+1. Authentication mechanisms
+2. Authorization controls
+3. Input validation
+4. Output encoding
+5. Session management
+6. Error handling
+7. Dependency vulnerabilities
+
+## Output Format
+A) Executive summary
+B) Detailed findings with severity
+C) Risk matrix
+D) Remediation steps (prioritized)
+E) Security checklist`,
+  },
+];
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// Prompt Quality Analyzer
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function analyzePromptQuality(prompt: string, template: PromptTemplate): PromptQuality {
+  const suggestions: string[] = [];
+
+  // Completeness
+  let completeness = 0;
+  const expectedSections = template.outputSections.length;
+  const foundSections = template.outputSections.filter(s =>
+    prompt.toLowerCase().includes(s.toLowerCase())
+  ).length;
+  completeness = Math.round((foundSections / expectedSections) * 100);
+
+  // Specificity
+  let specificity = 50;
+  if (prompt.includes('```')) specificity += 15;
+  if (prompt.includes('.env')) specificity += 10;
+  if (prompt.match(/\d+/)) specificity += 10;
+  if (prompt.includes('TypeScript')) specificity += 10;
+  specificity = Math.min(specificity, 100);
+
+  // Clarity
+  let clarity = 70;
+  const wordCount = prompt.split(/\s+/).length;
+  if (wordCount > 500) clarity += 10;
+  if (wordCount > 1000) clarity += 10;
+  if (prompt.includes('## ')) clarity += 10;
+  clarity = Math.min(clarity, 100);
+
+  const score = Math.round((completeness + specificity + clarity) / 3);
+
+  if (completeness < 80) {
+    suggestions.push('Add more output sections for comprehensive results');
+  }
+  if (specificity < 70) {
+    suggestions.push('Include more specific requirements (versions, exact paths)');
+  }
+  if (clarity < 80) {
+    suggestions.push('Consider adding code examples or format specifications');
+  }
+  if (!prompt.includes('TypeScript')) {
+    suggestions.push('Specify TypeScript requirement for type safety');
+  }
+
+  return { score, completeness, specificity, clarity, suggestions };
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// Service Implementation
+// ═══════════════════════════════════════════════════════════════════════════════
+
+export class PromptBuilderService {
+  private workspacePath: string;
+  private cachedContext: WorkspaceContext | null = null;
+
+  constructor(workspacePath?: string) {
+    this.workspacePath = workspacePath || process.cwd();
+  }
+
+  /**
+   * Get all templates sorted by popularity
+   */
+  getTemplates(): PromptTemplate[] {
+    return PROMPT_TEMPLATES.sort((a, b) => (b.popularity || 0) - (a.popularity || 0));
+  }
+
+  /**
+   * Get templates by category
+   */
+  getTemplatesByCategory(category: PromptCategory): PromptTemplate[] {
+    return PROMPT_TEMPLATES.filter(t => t.category === category);
+  }
+
+  /**
+   * Get all categories with counts
+   */
+  getCategories(): { category: PromptCategory; count: number; icon: string }[] {
+    const categoryMeta: Record<PromptCategory, { icon: string; order: number }> = {
+      authentication: { icon: '🔐', order: 1 },
+      api: { icon: '🔌', order: 2 },
+      frontend: { icon: '⚛️', order: 3 },
+      database: { icon: '🗄️', order: 4 },
+      testing: { icon: '🧪', order: 5 },
+      deployment: { icon: '🚀', order: 6 },
+      debugging: { icon: '🐛', order: 7 },
+      performance: { icon: '⚡', order: 8 },
+      refactoring: { icon: '♻️', order: 9 },
+      security: { icon: '🛡️', order: 10 },
+      'ai-ml': { icon: '🤖', order: 11 },
+      mobile: { icon: '📱', order: 12 },
+      backend: { icon: '⚙️', order: 13 },
+      documentation: { icon: '📚', order: 14 },
+      general: { icon: '✨', order: 15 },
+    };
+
+    const counts = new Map<PromptCategory, number>();
+    for (const template of PROMPT_TEMPLATES) {
+      counts.set(template.category, (counts.get(template.category) || 0) + 1);
+    }
+
+    return Array.from(counts.entries())
+      .map(([category, count]) => ({
+        category,
+        count,
+        icon: categoryMeta[category]?.icon || '📁',
+      }))
+      .sort((a, b) => (categoryMeta[a.category]?.order || 99) - (categoryMeta[b.category]?.order || 99));
+  }
+
+  /**
+   * Get a specific template by ID
+   */
+  getTemplate(id: string): PromptTemplate | undefined {
+    return PROMPT_TEMPLATES.find(t => t.id === id);
+  }
+
+  /**
+   * Detect best template from user input
+   */
+  detectTemplate(input: string): PromptTemplate | null {
+    const normalizedInput = input.toLowerCase();
+    let bestMatch: PromptTemplate | null = null;
+    let bestScore = 0;
+
+    for (const template of PROMPT_TEMPLATES) {
+      let score = 0;
+
+      for (const keyword of template.keywords) {
+        if (normalizedInput.includes(keyword)) {
+          score += keyword.length * 2;
+          if (new RegExp(`\\b${keyword}\\b`).test(normalizedInput)) {
+            score += 5;
+          }
+        }
+      }
+
+      score += (template.popularity || 0) / 20;
+
+      if (score > bestScore) {
+        bestScore = score;
+        bestMatch = template;
+      }
+    }
+
+    return bestScore > 8 ? bestMatch : null;
+  }
+
+  /**
+   * Detect workspace context from project files
+   */
+  async detectWorkspaceContext(): Promise<WorkspaceContext> {
+    if (this.cachedContext) {
+      return this.cachedContext;
+    }
+
+    const context: WorkspaceContext = {
+      projectName: path.basename(this.workspacePath),
+      hasTypeScript: false,
+      hasNextJs: false,
+      hasReact: false,
+      hasVue: false,
+      hasSvelte: false,
+      hasAngular: false,
+      hasVite: false,
+      hasExpress: false,
+      hasFastify: false,
+      hasNestJs: false,
+      hasPrisma: false,
+      hasDrizzle: false,
+      hasMongoDB: false,
+      hasPostgres: false,
+      hasSupabase: false,
+      hasFirebase: false,
+      hasClerk: false,
+      hasNextAuth: false,
+      hasAuthJs: false,
+      hasTailwind: false,
+      hasShadcn: false,
+      hasRadix: false,
+      packageManager: 'npm',
+      framework: 'unknown',
+      language: 'javascript',
+      testFramework: null,
+      hasDocker: false,
+      hasGit: false,
+      hasTurbo: false,
+      isMonorepo: false,
+    };
+
+    // Check package.json
+    const packageJsonPath = path.join(this.workspacePath, 'package.json');
+    if (fs.existsSync(packageJsonPath)) {
+      try {
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+        const allDeps = { ...packageJson.dependencies, ...packageJson.devDependencies };
+
+        context.hasTypeScript = !!allDeps.typescript;
+        context.hasNextJs = !!allDeps.next;
+        context.hasReact = !!allDeps.react;
+        context.hasVue = !!allDeps.vue;
+        context.hasSvelte = !!allDeps.svelte;
+        context.hasAngular = !!allDeps['@angular/core'];
+        context.hasVite = !!allDeps.vite;
+        context.hasExpress = !!allDeps.express;
+        context.hasFastify = !!allDeps.fastify;
+        context.hasNestJs = !!allDeps['@nestjs/core'];
+
+        context.hasPrisma = !!allDeps['@prisma/client'] || !!allDeps.prisma;
+        context.hasDrizzle = !!allDeps['drizzle-orm'];
+        context.hasMongoDB = !!allDeps.mongoose || !!allDeps.mongodb;
+        context.hasPostgres = !!allDeps.pg || !!allDeps['@vercel/postgres'];
+        context.hasSupabase = !!allDeps['@supabase/supabase-js'];
+        context.hasFirebase = !!allDeps.firebase || !!allDeps['firebase-admin'];
+
+        context.hasClerk = !!allDeps['@clerk/nextjs'] || !!allDeps['@clerk/clerk-react'];
+        context.hasNextAuth = !!allDeps['next-auth'];
+        context.hasAuthJs = !!allDeps['@auth/core'];
+
+        context.hasTailwind = !!allDeps.tailwindcss;
+        context.hasShadcn = fs.existsSync(path.join(this.workspacePath, 'components.json'));
+        context.hasRadix = Object.keys(allDeps).some(k => k.startsWith('@radix-ui'));
+
+        context.hasTurbo = !!allDeps.turbo;
+        context.isMonorepo = fs.existsSync(path.join(this.workspacePath, 'pnpm-workspace.yaml')) ||
+          !!packageJson.workspaces;
+
+        context.language = context.hasTypeScript ? 'typescript' : 'javascript';
+
+        if (allDeps.vitest) context.testFramework = 'vitest';
+        else if (allDeps.jest) context.testFramework = 'jest';
+        else if (allDeps['@playwright/test']) context.testFramework = 'playwright';
+
+        if (context.hasNextJs) context.framework = 'Next.js';
+        else if (context.hasVite && context.hasReact) context.framework = 'React + Vite';
+        else if (context.hasNestJs) context.framework = 'NestJS';
+        else if (context.hasFastify) context.framework = 'Fastify';
+        else if (context.hasExpress) context.framework = 'Express';
+        else if (context.hasVue) context.framework = 'Vue';
+        else if (context.hasSvelte) context.framework = 'SvelteKit';
+        else if (context.hasReact) context.framework = 'React';
+      } catch {
+        // Ignore parse errors
+      }
+    }
+
+    // Package manager detection
+    if (fs.existsSync(path.join(this.workspacePath, 'bun.lockb'))) context.packageManager = 'bun';
+    else if (fs.existsSync(path.join(this.workspacePath, 'pnpm-lock.yaml'))) context.packageManager = 'pnpm';
+    else if (fs.existsSync(path.join(this.workspacePath, 'yarn.lock'))) context.packageManager = 'yarn';
+
+    context.hasDocker = fs.existsSync(path.join(this.workspacePath, 'Dockerfile')) ||
+      fs.existsSync(path.join(this.workspacePath, 'docker-compose.yml'));
+    context.hasGit = fs.existsSync(path.join(this.workspacePath, '.git'));
+
+    this.cachedContext = context;
+    return context;
+  }
+
+  /**
+   * Build a prompt from template and answers
+   */
+  async buildPrompt(
+    templateId: string,
+    userInput: string,
+    answers: Record<string, string | string[]>
+  ): Promise<BuiltPrompt | null> {
+    const template = this.getTemplate(templateId);
+    if (!template) {
+      return null;
+    }
+
+    const workspaceContext = await this.detectWorkspaceContext();
+
+    // Build context from workspace and answers
+    const context: Record<string, string> = {
+      appType: 'Web app',
+      frontend: this.detectFrontend(workspaceContext),
+      backend: this.detectBackend(workspaceContext),
+      database: this.detectDatabase(workspaceContext),
+      typescript: workspaceContext.hasTypeScript ? 'yes' : 'no',
+      language: workspaceContext.language,
+      styling: workspaceContext.hasTailwind ? 'Tailwind CSS' : 'CSS',
+      baseUrl: 'http://localhost:3000',
+    };
+
+    // Add answers
+    for (const [key, value] of Object.entries(answers)) {
+      if (Array.isArray(value)) {
+        context[key] = value.join(', ');
+        context[`${key}List`] = value.map((v, i) => `${i + 1}. ${v}`).join('\n');
+      } else {
+        context[key] = value;
+      }
+    }
+
+    // Process template
+    let expandedPrompt = template.template;
+
+    // Replace smart variables
+    for (const [variable, resolver] of Object.entries(SMART_VARIABLES)) {
+      expandedPrompt = expandedPrompt.replace(new RegExp(variable.replace(/[{}]/g, '\\$&'), 'g'), resolver(workspaceContext));
+    }
+
+    // Replace {{variable}}
+    expandedPrompt = expandedPrompt.replace(/\{\{(\w+)\}\}/g, (_, key) => {
+      return context[key] || `[${key}]`;
+    });
+
+    // Handle {{#if variable}} ... {{/if}}
+    expandedPrompt = expandedPrompt.replace(
+      /\{\{#if (\w+)\}\}([\s\S]*?)\{\{\/if\}\}/g,
+      (_, key, content) => context[key] ? content : ''
+    );
+
+    // Clean up whitespace
+    expandedPrompt = expandedPrompt.replace(/\n{3,}/g, '\n\n').trim();
+
+    // Analyze quality
+    const quality = analyzePromptQuality(expandedPrompt, template);
+
+    const builtPrompt: BuiltPrompt = {
+      id: this.generateId(),
+      timestamp: new Date().toISOString(),
+      originalInput: userInput,
+      category: template.category,
+      templateId: template.id,
+      expandedPrompt,
+      context,
+      quality,
+    };
+
+    return builtPrompt;
+  }
+
+  /**
+   * Get smart suggestions based on input
+   */
+  getSmartSuggestions(input: string): SmartSuggestion[] {
+    const suggestions: SmartSuggestion[] = [];
+    const inputLower = input.toLowerCase();
+
+    // Detect template from input
+    const detectedTemplate = this.detectTemplate(input);
+    if (detectedTemplate) {
+      suggestions.push({
+        type: 'template',
+        title: detectedTemplate.name,
+        description: detectedTemplate.description,
+        action: 'selectTemplate',
+        data: detectedTemplate.id,
+      });
+    }
+
+    // Enhancement suggestions
+    if (input && input.length > 20) {
+      if (!inputLower.includes('typescript')) {
+        suggestions.push({
+          type: 'enhancement',
+          title: 'Add TypeScript',
+          description: 'Specify TypeScript for better type safety',
+          action: 'enhance',
+          data: 'typescript',
+        });
+      }
+
+      if (!inputLower.includes('test')) {
+        suggestions.push({
+          type: 'enhancement',
+          title: 'Include Tests',
+          description: 'Add unit or integration tests',
+          action: 'enhance',
+          data: 'tests',
+        });
+      }
+
+      if (!inputLower.includes('error')) {
+        suggestions.push({
+          type: 'enhancement',
+          title: 'Add Error Handling',
+          description: 'Include comprehensive error handling',
+          action: 'enhance',
+          data: 'error-handling',
+        });
+      }
+    }
+
+    return suggestions;
+  }
+
+  /**
+   * Set workspace path
+   */
+  setWorkspacePath(workspacePath: string): void {
+    this.workspacePath = workspacePath;
+    this.cachedContext = null; // Clear cache
+  }
+
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Private Methods
+  // ─────────────────────────────────────────────────────────────────────────────
+
+  private detectFrontend(ctx: WorkspaceContext): string {
+    if (ctx.hasNextJs) return 'Next.js App Router';
+    if (ctx.hasVite && ctx.hasReact) return 'React + Vite';
+    if (ctx.hasVue) return 'Vue 3';
+    if (ctx.hasSvelte) return 'SvelteKit';
+    if (ctx.hasReact) return 'React';
+    return 'Next.js App Router';
+  }
+
+  private detectBackend(ctx: WorkspaceContext): string {
+    if (ctx.hasNextJs) return 'Next.js API Routes';
+    if (ctx.hasNestJs) return 'NestJS';
+    if (ctx.hasFastify) return 'Fastify';
+    if (ctx.hasExpress) return 'Express';
+    return 'Next.js API Routes';
+  }
+
+  private detectDatabase(ctx: WorkspaceContext): string {
+    if (ctx.hasSupabase) return 'Supabase (PostgreSQL)';
+    if (ctx.hasFirebase) return 'Firebase';
+    if (ctx.hasPrisma && ctx.hasPostgres) return 'PostgreSQL + Prisma';
+    if (ctx.hasDrizzle) return 'Drizzle ORM';
+    if (ctx.hasPrisma) return 'Prisma';
+    if (ctx.hasMongoDB) return 'MongoDB';
+    if (ctx.hasPostgres) return 'PostgreSQL';
+    return 'PostgreSQL + Prisma';
+  }
+
+  private generateId(): string {
+    return `pb_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+  }
+}