@girardmedia/bootspring 1.2.0 → 2.0.3

package/intelligence/auto-suggest.js

@@ -0,0 +1,634 @@
+/**
+ * Bootspring Auto-Suggest
+ *
+ * Proactive natural language suggestions for Claude Code users.
+ * Monitors context and suggests relevant Bootspring features.
+ *
+ * @package bootspring
+ * @module intelligence/auto-suggest
+ */
+
+const fs = require('fs');
+const path = require('path');
+const config = require('../core/config');
+
+/**
+ * Suggestion patterns - triggers and their suggestions
+ */
+const SUGGESTION_PATTERNS = {
+  // Analysis & Understanding
+  codebaseUnderstanding: {
+    triggers: [
+      /understand\s+(the\s+)?codebase/i,
+      /how\s+does\s+(this|the)\s+(code|project)/i,
+      /explain\s+(the\s+)?architecture/i,
+      /what\s+does\s+this\s+(project|codebase)/i,
+      /overview\s+of\s+(the\s+)?(project|code)/i,
+      /new\s+to\s+(this\s+)?project/i,
+      /getting\s+started/i,
+      /onboard/i
+    ],
+    suggestion: {
+      command: 'bootspring analyze',
+      description: 'Run deep codebase analysis to understand architecture, patterns, and dependencies',
+      priority: 'high',
+      category: 'analysis'
+    }
+  },
+
+  // Quality & Auditing
+  codeQuality: {
+    triggers: [
+      /code\s+quality/i,
+      /check\s+(for\s+)?(bugs|issues|problems)/i,
+      /security\s+(scan|audit|check)/i,
+      /vulnerabilities/i,
+      /best\s+practices/i,
+      /tech\s+debt/i,
+      /code\s+review/i,
+      /linting/i
+    ],
+    suggestion: {
+      command: 'bootspring audit',
+      description: 'Run comprehensive quality, security, and best practices audit',
+      priority: 'high',
+      category: 'quality'
+    }
+  },
+
+  // Deployment
+  deployment: {
+    triggers: [
+      /deploy\s+(to|this)/i,
+      /push\s+to\s+production/i,
+      /vercel/i,
+      /railway/i,
+      /fly\.io/i,
+      /netlify/i,
+      /hosting/i,
+      /go\s+live/i,
+      /launch/i
+    ],
+    suggestion: {
+      command: 'bootspring deploy',
+      description: 'Deploy to Vercel, Railway, Fly.io, Netlify, AWS, or Docker',
+      priority: 'high',
+      category: 'deployment'
+    }
+  },
+
+  // Task Management
+  todoManagement: {
+    triggers: [
+      /add\s+(a\s+)?todo/i,
+      /task\s+list/i,
+      /track\s+(this\s+)?task/i,
+      /remember\s+to/i,
+      /don't\s+forget/i,
+      /need\s+to\s+do/i,
+      /pending\s+tasks/i
+    ],
+    suggestion: {
+      command: 'bootspring todo add "<task>"',
+      description: 'Track tasks with integrated todo management',
+      priority: 'medium',
+      category: 'workflow'
+    }
+  },
+
+  // PRD & Planning
+  productPlanning: {
+    triggers: [
+      /product\s+requirements/i,
+      /prd/i,
+      /feature\s+spec/i,
+      /plan\s+(this\s+)?feature/i,
+      /user\s+stories/i,
+      /acceptance\s+criteria/i,
+      /scope\s+(the\s+)?work/i
+    ],
+    suggestion: {
+      command: 'bootspring prd create',
+      description: 'Create structured product requirements with user stories',
+      priority: 'medium',
+      category: 'planning'
+    }
+  },
+
+  // Autonomous Loop
+  autonomousWork: {
+    triggers: [
+      /work\s+on\s+this\s+automatically/i,
+      /automate\s+(this|the)\s+(task|work)/i,
+      /do\s+this\s+without\s+me/i,
+      /autonomous/i,
+      /hands[\s-]?free/i,
+      /loop\s+through\s+tasks/i,
+      /batch\s+process/i
+    ],
+    suggestion: {
+      command: 'bootspring loop start',
+      description: 'Start autonomous task execution loop until all stories complete',
+      priority: 'high',
+      category: 'automation'
+    }
+  },
+
+  // Business & Legal
+  businessDocs: {
+    triggers: [
+      /business\s+plan/i,
+      /pitch\s+deck/i,
+      /investor/i,
+      /fundraising/i,
+      /competitor\s+analysis/i,
+      /market\s+research/i
+    ],
+    suggestion: {
+      command: 'bootspring business plan',
+      description: 'Generate business plans, competitor analysis, and strategy docs',
+      priority: 'medium',
+      category: 'business'
+    }
+  },
+
+  legalDocs: {
+    triggers: [
+      /terms\s+(of\s+service|and\s+conditions)/i,
+      /privacy\s+policy/i,
+      /legal\s+(docs|documents)/i,
+      /gdpr/i,
+      /compliance/i,
+      /data\s+protection/i
+    ],
+    suggestion: {
+      command: 'bootspring legal init',
+      description: 'Generate terms of service, privacy policy, and GDPR compliance docs',
+      priority: 'medium',
+      category: 'legal'
+    }
+  },
+
+  // Content Generation
+  contentGeneration: {
+    triggers: [
+      /write\s+(a\s+)?blog\s+post/i,
+      /release\s+notes/i,
+      /changelog/i,
+      /documentation/i,
+      /readme/i,
+      /announcement/i
+    ],
+    suggestion: {
+      command: 'bootspring content new <type>',
+      description: 'Generate blogs, docs, release notes, and more',
+      priority: 'medium',
+      category: 'content'
+    }
+  },
+
+  // Project Health
+  projectHealth: {
+    triggers: [
+      /project\s+(health|status)/i,
+      /how\s+is\s+(the\s+)?project\s+doing/i,
+      /overall\s+status/i,
+      /check\s+(the\s+)?health/i,
+      /project\s+overview/i
+    ],
+    suggestion: {
+      command: 'bootspring health',
+      description: 'Get quick project health score and recommendations',
+      priority: 'low',
+      category: 'monitoring'
+    }
+  },
+
+  // Recommendations
+  whatNext: {
+    triggers: [
+      /what\s+should\s+i\s+do\s+next/i,
+      /what's\s+next/i,
+      /suggest\s+(something|next\s+steps)/i,
+      /recommendations/i,
+      /what\s+to\s+work\s+on/i,
+      /prioritize/i
+    ],
+    suggestion: {
+      command: 'bootspring suggest',
+      description: 'Get AI-powered recommendations based on your project context',
+      priority: 'high',
+      category: 'intelligence'
+    }
+  },
+
+  // Testing
+  testing: {
+    triggers: [
+      /write\s+tests/i,
+      /add\s+tests/i,
+      /test\s+coverage/i,
+      /unit\s+tests/i,
+      /integration\s+tests/i,
+      /e2e\s+tests/i
+    ],
+    suggestion: {
+      command: 'bootspring quality pre-commit',
+      description: 'Run quality gates including test checks',
+      priority: 'medium',
+      category: 'quality'
+    }
+  },
+
+  // Context Management
+  contextRegenerate: {
+    triggers: [
+      /update\s+(the\s+)?context/i,
+      /regenerate\s+claude\.md/i,
+      /refresh\s+(project\s+)?context/i,
+      /context\s+is\s+(out\s+of\s+date|outdated|stale)/i
+    ],
+    suggestion: {
+      command: 'bootspring generate',
+      description: 'Regenerate CLAUDE.md with fresh project context',
+      priority: 'low',
+      category: 'maintenance'
+    }
+  },
+
+  // Monitoring
+  monitoring: {
+    triggers: [
+      /set\s+up\s+monitoring/i,
+      /alerting/i,
+      /sentry/i,
+      /datadog/i,
+      /error\s+tracking/i,
+      /production\s+monitoring/i
+    ],
+    suggestion: {
+      command: 'bootspring monitor init',
+      description: 'Set up production monitoring with Sentry, Datadog, or PagerDuty',
+      priority: 'medium',
+      category: 'monitoring'
+    }
+  },
+
+  // Agents
+  specializedHelp: {
+    triggers: [
+      /security\s+review/i,
+      /performance\s+optimization/i,
+      /database\s+design/i,
+      /api\s+design/i,
+      /accessibility/i,
+      /need\s+(an\s+)?expert/i
+    ],
+    suggestion: {
+      command: 'bootspring agent list',
+      description: 'Get specialized help from security, performance, or design agents',
+      priority: 'medium',
+      category: 'intelligence'
+    }
+  },
+
+  // Skills
+  codePatterns: {
+    triggers: [
+      /how\s+to\s+implement/i,
+      /code\s+pattern/i,
+      /example\s+code/i,
+      /snippet/i,
+      /boilerplate/i,
+      /template\s+for/i
+    ],
+    suggestion: {
+      command: 'bootspring skill search "<query>"',
+      description: 'Find code patterns and implementation examples',
+      priority: 'low',
+      category: 'skills'
+    }
+  },
+
+  // Preseed
+  projectSetup: {
+    triggers: [
+      /new\s+project/i,
+      /start\s+a\s+project/i,
+      /project\s+setup/i,
+      /initialize\s+(the\s+)?project/i,
+      /scaffold/i,
+      /bootstrap/i
+    ],
+    suggestion: {
+      command: 'bootspring preseed init',
+      description: 'Generate foundational project documents from minimal input',
+      priority: 'high',
+      category: 'setup'
+    }
+  }
+};
+
+/**
+ * Auto-suggest configuration
+ */
+const CONFIG_KEY = 'autoSuggest';
+const DEFAULT_CONFIG = {
+  enabled: true,
+  minConfidence: 0.6,
+  maxSuggestionsPerMessage: 2,
+  cooldownMs: 30000, // Don't suggest same command within 30s
+  categories: {
+    analysis: true,
+    quality: true,
+    deployment: true,
+    workflow: true,
+    planning: true,
+    automation: true,
+    business: true,
+    legal: true,
+    content: true,
+    monitoring: true,
+    intelligence: true,
+    skills: true,
+    setup: true,
+    maintenance: true
+  },
+  suppressedCommands: [] // Commands user doesn't want suggested
+};
+
+/**
+ * AutoSuggest class
+ */
+class AutoSuggest {
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    this.configPath = path.join(projectRoot, '.bootspring', 'auto-suggest.json');
+    this.config = this.loadConfig();
+    this.recentSuggestions = new Map(); // command -> timestamp
+  }
+
+  loadConfig() {
+    try {
+      if (fs.existsSync(this.configPath)) {
+        const saved = JSON.parse(fs.readFileSync(this.configPath, 'utf-8'));
+        return { ...DEFAULT_CONFIG, ...saved };
+      }
+    } catch {
+      // Use defaults
+    }
+    return { ...DEFAULT_CONFIG };
+  }
+
+  saveConfig() {
+    const dir = path.dirname(this.configPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(this.configPath, JSON.stringify(this.config, null, 2));
+  }
+
+  /**
+   * Enable or disable auto-suggest
+   */
+  setEnabled(enabled) {
+    this.config.enabled = enabled;
+    this.saveConfig();
+    return this.config.enabled;
+  }
+
+  /**
+   * Toggle a category
+   */
+  setCategory(category, enabled) {
+    if (this.config.categories.hasOwnProperty(category)) {
+      this.config.categories[category] = enabled;
+      this.saveConfig();
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Suppress a command from suggestions
+   */
+  suppressCommand(command) {
+    if (!this.config.suppressedCommands.includes(command)) {
+      this.config.suppressedCommands.push(command);
+      this.saveConfig();
+    }
+  }
+
+  /**
+   * Unsuppress a command
+   */
+  unsuppressCommand(command) {
+    this.config.suppressedCommands = this.config.suppressedCommands.filter(c => c !== command);
+    this.saveConfig();
+  }
+
+  /**
+   * Analyze text and return relevant suggestions
+   */
+  analyze(text) {
+    if (!this.config.enabled) {
+      return [];
+    }
+
+    const suggestions = [];
+    const now = Date.now();
+
+    for (const [patternName, pattern] of Object.entries(SUGGESTION_PATTERNS)) {
+      // Check if category is enabled
+      if (!this.config.categories[pattern.suggestion.category]) {
+        continue;
+      }
+
+      // Check if command is suppressed
+      const baseCommand = pattern.suggestion.command.split(' ')[0] + ' ' + pattern.suggestion.command.split(' ')[1];
+      if (this.config.suppressedCommands.some(c => pattern.suggestion.command.startsWith(c))) {
+        continue;
+      }
+
+      // Check cooldown
+      const lastSuggested = this.recentSuggestions.get(baseCommand);
+      if (lastSuggested && (now - lastSuggested) < this.config.cooldownMs) {
+        continue;
+      }
+
+      // Check triggers
+      let matchCount = 0;
+      const matchedTriggers = [];
+
+      for (const trigger of pattern.triggers) {
+        if (trigger.test(text)) {
+          matchCount++;
+          matchedTriggers.push(trigger.source);
+        }
+      }
+
+      if (matchCount > 0) {
+        // Calculate confidence based on matches
+        const confidence = Math.min(1, matchCount / 2);
+
+        if (confidence >= this.config.minConfidence) {
+          suggestions.push({
+            ...pattern.suggestion,
+            patternName,
+            confidence,
+            matchedTriggers
+          });
+
+          // Record suggestion
+          this.recentSuggestions.set(baseCommand, now);
+        }
+      }
+    }
+
+    // Sort by priority and confidence
+    const priorityOrder = { high: 0, medium: 1, low: 2 };
+    suggestions.sort((a, b) => {
+      const priorityDiff = priorityOrder[a.priority] - priorityOrder[b.priority];
+      if (priorityDiff !== 0) return priorityDiff;
+      return b.confidence - a.confidence;
+    });
+
+    // Limit suggestions
+    return suggestions.slice(0, this.config.maxSuggestionsPerMessage);
+  }
+
+  /**
+   * Format suggestions for display
+   */
+  formatSuggestions(suggestions) {
+    if (suggestions.length === 0) return null;
+
+    const lines = ['', '\x1b[36m\x1b[1m💡 Bootspring Suggestions\x1b[0m'];
+
+    for (const suggestion of suggestions) {
+      lines.push(`  \x1b[32m→\x1b[0m \x1b[1m${suggestion.command}\x1b[0m`);
+      lines.push(`    \x1b[2m${suggestion.description}\x1b[0m`);
+    }
+
+    lines.push('');
+    lines.push('\x1b[2mDisable with: bootspring suggest --disable-auto\x1b[0m');
+
+    return lines.join('\n');
+  }
+
+  /**
+   * Generate skill prompt for Claude Code
+   */
+  generateSkillPrompt() {
+    return `# Bootspring Auto-Suggest
+
+You have access to Bootspring, a development scaffolding tool. When you detect the user is working on something that Bootspring can help with, proactively suggest relevant commands.
+
+## Available Suggestions
+
+${Object.entries(SUGGESTION_PATTERNS).map(([name, pattern]) => `
+### ${name}
+**Command:** \`${pattern.suggestion.command}\`
+**Description:** ${pattern.suggestion.description}
+**Triggers:** ${pattern.triggers.slice(0, 3).map(t => t.source).join(', ')}
+`).join('\n')}
+
+## How to Suggest
+
+When you detect a relevant context, include a suggestion block:
+
+\`\`\`
+💡 Bootspring can help with this!
+
+Run: \`${'{command}'}\`
+${'{description}'}
+\`\`\`
+
+## User Preferences
+
+The user can enable/disable suggestions with:
+- \`bootspring suggest --enable-auto\` - Enable auto-suggestions
+- \`bootspring suggest --disable-auto\` - Disable auto-suggestions
+- \`bootspring suggest --config\` - Configure categories
+
+Only suggest when highly relevant. Don't spam suggestions.
+`;
+  }
+
+  /**
+   * Get configuration status
+   */
+  getStatus() {
+    return {
+      enabled: this.config.enabled,
+      categories: this.config.categories,
+      suppressedCommands: this.config.suppressedCommands,
+      recentSuggestionsCount: this.recentSuggestions.size
+    };
+  }
+}
+
+/**
+ * Middleware for integration with CLI
+ */
+function createMiddleware(projectRoot) {
+  const autoSuggest = new AutoSuggest(projectRoot);
+
+  return {
+    /**
+     * Process user input and return suggestions
+     */
+    process(userInput) {
+      return autoSuggest.analyze(userInput);
+    },
+
+    /**
+     * Format suggestions for display
+     */
+    format(suggestions) {
+      return autoSuggest.formatSuggestions(suggestions);
+    },
+
+    /**
+     * Get the AutoSuggest instance
+     */
+    getInstance() {
+      return autoSuggest;
+    }
+  };
+}
+
+/**
+ * Export for MCP integration
+ */
+function createMCPHandler(autoSuggest) {
+  return {
+    name: 'bootspring_suggest_context',
+    description: 'Analyze user context and suggest relevant Bootspring commands',
+    parameters: {
+      type: 'object',
+      properties: {
+        userMessage: {
+          type: 'string',
+          description: 'The user message to analyze for suggestions'
+        }
+      },
+      required: ['userMessage']
+    },
+    handler: async (params) => {
+      const suggestions = autoSuggest.analyze(params.userMessage);
+      return {
+        suggestions,
+        formatted: autoSuggest.formatSuggestions(suggestions)
+      };
+    }
+  };
+}
+
+module.exports = {
+  AutoSuggest,
+  SUGGESTION_PATTERNS,
+  DEFAULT_CONFIG,
+  createMiddleware,
+  createMCPHandler
+};