@girardmedia/bootspring 1.2.0 → 2.0.3

package/mcp/tools/seed-tool.js

@@ -0,0 +1,447 @@
+/**
+ * MCP seed tool module
+ * Provides seed operations via MCP: setup, init, generate, scaffold, status, export
+ */
+
+function getToolDefinition() {
+  return {
+    name: 'bootspring_seed',
+    description: 'Manage seed configuration and project scaffolding. Setup input folders, run questionnaire, ingest files, generate documents, and scaffold projects.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        action: {
+          type: 'string',
+          enum: ['setup', 'init', 'generate', 'scaffold', 'status', 'export'],
+          description: 'Action to perform: setup (create input folders), init (run questionnaire), generate (ingest files and generate docs), scaffold (create project structure), status (show config), export (export as JSON/YAML)'
+        },
+        preset: {
+          type: 'string',
+          description: 'Preset for init (minimal, standard, full, startup, api) or scaffold (nextjs, react, node, fullstack)'
+        },
+        format: {
+          type: 'string',
+          enum: ['json', 'yaml'],
+          description: 'Export format (for export action)'
+        },
+        dryRun: {
+          type: 'boolean',
+          description: 'For scaffold action: show plan without creating files'
+        }
+      },
+      required: ['action']
+    }
+  };
+}
+
+function createHandler({ ingestModule, scaffoldModule, config, format }) {
+  return async (args) => {
+    const { action, preset, dryRun } = args;
+    const cfg = config.load();
+    const projectRoot = cfg._projectRoot;
+
+    try {
+      switch (action) {
+        case 'setup':
+          return await handleSetup(projectRoot, format);
+
+        case 'init':
+          return format.warning(
+            'Interactive questionnaire not available via MCP',
+            ['Run "bootspring seed init" in terminal for interactive mode']
+          );
+
+        case 'generate':
+          return await handleGenerate(projectRoot, ingestModule, format);
+
+        case 'scaffold':
+          return await handleScaffold(projectRoot, preset, dryRun, scaffoldModule, config, format);
+
+        case 'status':
+          return await handleStatus(projectRoot, config, scaffoldModule, format);
+
+        case 'export':
+          return await handleExport(projectRoot, args.format || 'json', format);
+
+        default:
+          return format.error(`Unknown action: ${action}`, [
+            'Valid actions: setup, init, generate, scaffold, status, export'
+          ]);
+      }
+    } catch (error) {
+      return format.error(`Seed operation failed: ${error.message}`);
+    }
+  };
+}
+
+async function handleSetup(projectRoot, _format) {
+  const fs = require('fs');
+  const path = require('path');
+
+  const folders = [
+    '.bootspring',
+    '.bootspring/inputs',
+    '.bootspring/inputs/mvp',
+    '.bootspring/inputs/mvp/source',
+    '.bootspring/inputs/business',
+    '.bootspring/inputs/prd',
+    '.bootspring/inputs/prd/features',
+    '.bootspring/inputs/designs',
+    '.bootspring/inputs/designs/figma-exports',
+    '.bootspring/inputs/designs/wireframes',
+    '.bootspring/inputs/legal',
+    '.bootspring/inputs/api',
+    '.bootspring/inputs/data',
+    '.bootspring/generated',
+    '.bootspring/generated/prd',
+    '.bootspring/generated/master-plan',
+    '.bootspring/generated/business',
+    '.bootspring/generated/architecture',
+    '.bootspring/generated/legal',
+    '.bootspring/context',
+    '.bootspring/logs',
+    '.bootspring/config'
+  ];
+
+  let created = 0;
+  for (const folder of folders) {
+    const folderPath = path.join(projectRoot, folder);
+    if (!fs.existsSync(folderPath)) {
+      fs.mkdirSync(folderPath, { recursive: true });
+      created++;
+    }
+  }
+
+  const inputReadme = `# Input Files
+
+Drop your existing files here before running \`bootspring seed generate\`.
+
+| Folder | What to put here |
+|--------|------------------|
+| \`mvp/source/\` | AI-generated MVP code (Lovable, Bolt, V0, etc.) |
+| \`business/\` | Business plans, pitch decks, market research |
+| \`prd/\` | Product requirements documents |
+| \`designs/\` | Figma exports, wireframes, mockups |
+| \`legal/\` | Existing terms, privacy policies |
+| \`api/\` | OpenAPI specs, API documentation |
+| \`data/\` | Sample data, database schemas |
+`;
+
+  const readmePath = path.join(projectRoot, '.bootspring/inputs/README.md');
+  if (!fs.existsSync(readmePath)) {
+    fs.writeFileSync(readmePath, inputReadme);
+    created++;
+  }
+
+  return {
+    content: [{
+      type: 'text',
+      text: `## Seed Setup Complete
+
+Created ${created} folders/files.
+
+**Folder Structure:**
+\`\`\`
+.bootspring/
+├── inputs/
+│   ├── mvp/source/     # AI-generated MVP code
+│   ├── business/       # Business plans, pitch decks
+│   ├── prd/            # Product requirements
+│   ├── designs/        # Figma exports, wireframes
+│   ├── legal/          # Terms, privacy policies
+│   ├── api/            # OpenAPI specs
+│   └── data/           # Sample data, schemas
+├── generated/          # Bootspring output
+├── context/            # AI context index
+└── logs/               # Action history
+\`\`\`
+
+**Next Steps:**
+1. Drop your files in \`.bootspring/inputs/\` subfolders
+2. Run \`bootspring_seed\` with action: "generate" to process them`
+    }]
+  };
+}
+
+async function handleGenerate(projectRoot, ingestModule, format) {
+  const fs = require('fs');
+  const path = require('path');
+
+  const inputsDir = path.join(projectRoot, '.bootspring', 'inputs');
+  if (!fs.existsSync(inputsDir)) {
+    return format.warning(
+      'No .bootspring/inputs folder found',
+      ['Run bootspring_seed with action: "setup" first']
+    );
+  }
+
+  // Ingest all files
+  const ingested = await ingestModule.ingestAll(projectRoot);
+
+  // Count files found
+  const counts = {
+    mvp: ingested.mvp?.files?.length || 0,
+    business: ingested.business?.length || 0,
+    prd: ingested.prd?.length || 0,
+    designs: ingested.designs?.files?.length || 0,
+    api: ingested.api?.length || 0,
+    data: ingested.data?.length || 0
+  };
+
+  const totalFiles = Object.values(counts).reduce((a, b) => a + b, 0);
+
+  // Parse SEED.md if exists
+  const seedPath = path.join(projectRoot, 'SEED.md');
+  const seedConfig = {};
+  if (fs.existsSync(seedPath)) {
+    try {
+      const content = fs.readFileSync(seedPath, 'utf-8');
+      const yamlBlocks = content.matchAll(/```yaml\n([\s\S]*?)```/g);
+      for (const match of yamlBlocks) {
+        try {
+          const yaml = require('yaml');
+          const parsed = yaml.parse(match[1]);
+          Object.assign(seedConfig, parsed);
+        } catch {
+          // Skip invalid blocks
+        }
+      }
+    } catch {
+      // Continue without seed config
+    }
+  }
+
+  // Generate documents
+  const outputs = await ingestModule.generateDocuments(ingested, seedConfig, projectRoot);
+
+  // Update context index
+  await ingestModule.updateContextIndex(projectRoot, ingested);
+
+  const generatedDocs = Object.keys(outputs).filter(k => outputs[k]).length;
+
+  return {
+    content: [{
+      type: 'text',
+      text: `## Files Ingested
+
+| Category | Files Found |
+|----------|-------------|
+| MVP Code | ${counts.mvp} |
+| Business Docs | ${counts.business} |
+| PRD Docs | ${counts.prd} |
+| Design Files | ${counts.designs} |
+| API Specs | ${counts.api} |
+| Data Files | ${counts.data} |
+| **Total** | **${totalFiles}** |
+
+## Documents Generated
+
+Generated ${generatedDocs} documents in \`.bootspring/generated/\`
+
+**MVP Patterns Detected:**
+${ingested.mvp?.patterns?.join(', ') || 'None'}
+
+**Next Steps:**
+1. Review generated documents in \`.bootspring/generated/\`
+2. Run \`bootspring_seed\` with action: "scaffold" to create project structure`
+    }]
+  };
+}
+
+async function handleScaffold(projectRoot, preset, dryRun, scaffoldModule, config, format) {
+  const fs = require('fs');
+  const path = require('path');
+
+  let scaffoldConfig;
+
+  if (preset) {
+    const validPresets = scaffoldModule.getPresets();
+    if (!validPresets.includes(preset)) {
+      return format.error(`Invalid preset: ${preset}`, [
+        `Valid presets: ${validPresets.join(', ')}`
+      ]);
+    }
+    scaffoldConfig = scaffoldModule.getPresetConfig(preset);
+  } else {
+    // Try SEED.md
+    const seedPath = path.join(projectRoot, 'SEED.md');
+    if (!fs.existsSync(seedPath)) {
+      const presets = scaffoldModule.getPresets();
+      return format.warning(
+        'No SEED.md found',
+        [`Use preset parameter: ${presets.join(', ')}`, 'Or run "bootspring seed init" first']
+      );
+    }
+
+    // Parse SEED.md
+    const content = fs.readFileSync(seedPath, 'utf-8');
+    scaffoldConfig = {};
+    const yamlBlocks = content.matchAll(/```yaml\n([\s\S]*?)```/g);
+    for (const match of yamlBlocks) {
+      try {
+        const yaml = require('yaml');
+        Object.assign(scaffoldConfig, yaml.parse(match[1]));
+      } catch {
+        // Skip
+      }
+    }
+  }
+
+  const plan = scaffoldModule.planScaffold(scaffoldConfig, projectRoot);
+
+  if (dryRun) {
+    return {
+      content: [{
+        type: 'text',
+        text: `## Scaffold Plan (Dry Run)
+
+**Configuration:**
+- Framework: ${scaffoldConfig.stack?.framework || 'nextjs'}
+- Language: ${scaffoldConfig.stack?.language || 'typescript'}
+- UI: ${scaffoldConfig.frontend?.uiLibrary || 'shadcn'}
+
+**Directories:** ${plan.directories.length}
+**Files:** ${plan.files.length}
+
+**Sample directories:**
+${plan.directories.slice(0, 10).map(d => `- ${d}`).join('\n')}
+${plan.directories.length > 10 ? `\n... and ${plan.directories.length - 10} more` : ''}
+
+**Sample files:**
+${plan.files.slice(0, 10).map(f => `- ${f.path}`).join('\n')}
+${plan.files.length > 10 ? `\n... and ${plan.files.length - 10} more` : ''}`
+      }]
+    };
+  }
+
+  const result = await scaffoldModule.execute(plan, projectRoot);
+
+  return {
+    content: [{
+      type: 'text',
+      text: `## Scaffold Complete
+
+Created ${result.filesCreated} files and ${result.dirsCreated} directories.
+
+**Configuration:**
+- Framework: ${scaffoldConfig.stack?.framework || 'nextjs'}
+- Language: ${scaffoldConfig.stack?.language || 'typescript'}
+
+${result.warnings.length > 0 ? `**Warnings:**\n${result.warnings.map(w => `- ${w}`).join('\n')}` : ''}
+
+**Next Steps:**
+1. Run \`npm install\` to install dependencies
+2. Copy \`.env.example\` to \`.env.local\`
+3. Run \`npm run dev\` to start development`
+    }]
+  };
+}
+
+async function handleStatus(projectRoot, _config, scaffoldModule, _format) {
+  const fs = require('fs');
+  const path = require('path');
+
+  const seedPath = path.join(projectRoot, 'SEED.md');
+  const configPath = path.join(projectRoot, 'bootspring.config.js');
+  const inputsDir = path.join(projectRoot, '.bootspring', 'inputs');
+
+  const status = {
+    seedMd: fs.existsSync(seedPath),
+    config: fs.existsSync(configPath),
+    inputsFolder: fs.existsSync(inputsDir)
+  };
+
+  let seedInfo = '';
+  if (status.seedMd) {
+    try {
+      const content = fs.readFileSync(seedPath, 'utf-8');
+      const seedConfig = {};
+      const yamlBlocks = content.matchAll(/```yaml\n([\s\S]*?)```/g);
+      for (const match of yamlBlocks) {
+        try {
+          const yaml = require('yaml');
+          Object.assign(seedConfig, yaml.parse(match[1]));
+        } catch {
+          // Skip
+        }
+      }
+      seedInfo = `
+**Configuration:**
+- Project: ${seedConfig.project?.name || 'unknown'}
+- Framework: ${seedConfig.stack?.framework || 'unknown'}
+- Language: ${seedConfig.stack?.language || 'unknown'}
+- Database: ${seedConfig.stack?.database || 'none'}`;
+    } catch {
+      // Continue without seed info
+    }
+  }
+
+  const presets = scaffoldModule.getPresets();
+
+  return {
+    content: [{
+      type: 'text',
+      text: `## Seed Status
+
+| Item | Status |
+|------|--------|
+| SEED.md | ${status.seedMd ? '✓ exists' : '○ not found'} |
+| bootspring.config.js | ${status.config ? '✓ exists' : '○ not found'} |
+| .bootspring/inputs/ | ${status.inputsFolder ? '✓ exists' : '○ not found'} |
+${seedInfo}
+
+**Available Presets:** ${presets.join(', ')}
+
+**Commands:**
+- \`bootspring_seed\` action: "setup" - Create input folders
+- \`bootspring_seed\` action: "generate" - Process input files
+- \`bootspring_seed\` action: "scaffold" preset: "nextjs" - Generate project`
+    }]
+  };
+}
+
+async function handleExport(projectRoot, exportFormat, format) {
+  const fs = require('fs');
+  const path = require('path');
+
+  const seedPath = path.join(projectRoot, 'SEED.md');
+  if (!fs.existsSync(seedPath)) {
+    return format.error('No SEED.md found', ['Run "bootspring seed init" first']);
+  }
+
+  const content = fs.readFileSync(seedPath, 'utf-8');
+  const seedConfig = {};
+  const yamlBlocks = content.matchAll(/```yaml\n([\s\S]*?)```/g);
+  for (const match of yamlBlocks) {
+    try {
+      const yaml = require('yaml');
+      Object.assign(seedConfig, yaml.parse(match[1]));
+    } catch {
+      // Skip
+    }
+  }
+
+  let exported;
+  if (exportFormat === 'yaml') {
+    const yaml = require('yaml');
+    exported = yaml.stringify(seedConfig);
+  } else {
+    exported = JSON.stringify(seedConfig, null, 2);
+  }
+
+  return {
+    content: [{
+      type: 'text',
+      text: `## Seed Configuration (${exportFormat.toUpperCase()})
+
+\`\`\`${exportFormat}
+${exported}
+\`\`\``
+    }]
+  };
+}
+
+module.exports = {
+  getToolDefinition,
+  createHandler
+};

package/mcp/tools/skill-tool.js

@@ -112,18 +112,28 @@ function createHandler({ skills, entitlements, trackTelemetry }) {
 
     switch (action) {
       case 'list': {
-        let skillIds = skills.listSkills({ includeExternal });
-        if (includeExternal) {
-          skillIds = entitlements.filterAccessibleSkills(skillIds, accessOptions).allowed;
+        const skillIds = skills.listSkills({ includeExternal });
+        // Filter by access - includes both external skills and premium patterns
+        const filtered = [];
+        for (const id of skillIds) {
+          const metadata = skills.getSkillMetadata(id) || {};
+          const access = entitlements.checkSkillAccess(id, {
+            ...accessOptions,
+            skillTier: metadata.tier
+          });
+          if (access.allowed) {
+            filtered.push(id);
+          }
         }
-        const items = skillIds
+        const items = filtered
           .slice(0, limit)
           .map(id => {
             const metadata = skills.getSkillMetadata(id) || {};
             return {
               id,
               name: metadata.name || id,
-              description: metadata.description || ''
+              description: metadata.description || '',
+              tier: metadata.tier || 'free'
             };
           });
 
@@ -138,11 +148,17 @@ function createHandler({ skills, entitlements, trackTelemetry }) {
         if (!name) throw new Error('Skill name required');
         const metadata = skills.getSkillMetadata(name);
         const targetSkillId = metadata?.id || name;
-        const access = entitlements.checkSkillAccess(targetSkillId, accessOptions);
+        const skillTier = metadata?.tier || 'free';
+        const access = entitlements.checkSkillAccess(targetSkillId, {
+          ...accessOptions,
+          skillTier
+        });
         if (!access.allowed) {
+          const isPremium = entitlements.isExternalSkill(targetSkillId) || skillTier === 'pro';
           trackTelemetry('premium_prompted', {
-            capability: 'external_skill',
+            capability: isPremium ? 'premium_pattern' : 'external_skill',
             skillId: targetSkillId,
+            skillTier,
             mode: access.context?.mode,
             tier: access.context?.tier,
             reason: access.code
@@ -158,10 +174,12 @@ function createHandler({ skills, entitlements, trackTelemetry }) {
           sections,
           maxChars
         });
-        if (entitlements.isExternalSkill(targetSkillId)) {
+        const isPremiumUnlock = entitlements.isExternalSkill(targetSkillId) || skillTier === 'pro';
+        if (isPremiumUnlock) {
           trackTelemetry('premium_unlocked', {
-            capability: 'external_skill',
+            capability: skillTier === 'pro' ? 'premium_pattern' : 'external_skill',
             skillId: targetSkillId,
+            skillTier,
             mode: access.context?.mode,
             tier: access.context?.tier,
             reason: access.code
@@ -176,6 +194,7 @@ function createHandler({ skills, entitlements, trackTelemetry }) {
               name: metadata?.name || name,
               description: metadata?.description || '',
               source: metadata?.source || 'built-in',
+              tier: skillTier,
               content
             }, null, 2)
           }]
@@ -183,18 +202,28 @@ function createHandler({ skills, entitlements, trackTelemetry }) {
       }
       case 'search': {
         if (!query) throw new Error('Search query required');
-        let matches = skills.searchSkills(query, { includeExternal, limit });
-        if (includeExternal) {
-          matches = entitlements.filterAccessibleSkills(matches, accessOptions).allowed;
+        const matches = skills.searchSkills(query, { includeExternal, limit });
+        // Filter by access - includes both external skills and premium patterns
+        const filtered = [];
+        for (const id of matches) {
+          const metadata = skills.getSkillMetadata(id) || {};
+          const access = entitlements.checkSkillAccess(id, {
+            ...accessOptions,
+            skillTier: metadata.tier
+          });
+          if (access.allowed) {
+            filtered.push(id);
+          }
         }
-        const items = matches
+        const items = filtered
           .map(id => {
             const metadata = skills.getSkillMetadata(id) || {};
             return {
               id,
               name: metadata.name || id,
               description: metadata.description || '',
-              source: metadata.source || 'built-in'
+              source: metadata.source || 'built-in',
+              tier: metadata.tier || 'free'
             };
           });
 

package/mcp/tools/suggest-tool.js

@@ -0,0 +1,147 @@
+/**
+ * MCP Auto-Suggest Tool
+ *
+ * Analyzes user context and suggests relevant Bootspring commands.
+ *
+ * @package bootspring
+ * @module mcp/tools/suggest-tool
+ */
+
+const toolName = 'bootspring_suggest';
+
+/**
+ * Get tool definition for MCP
+ */
+function getToolDefinition() {
+  return {
+    name: toolName,
+    description: 'Analyze user context and suggest relevant Bootspring commands. Use this to proactively help users discover Bootspring features that can assist with their current task.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        userMessage: {
+          type: 'string',
+          description: 'The user message or context to analyze for suggestions'
+        },
+        action: {
+          type: 'string',
+          enum: ['analyze', 'enable', 'disable', 'config', 'toggle-category'],
+          description: 'Action to perform. Default is "analyze"'
+        },
+        category: {
+          type: 'string',
+          description: 'Category name for toggle-category action'
+        }
+      },
+      required: []
+    }
+  };
+}
+
+/**
+ * Create tool handler
+ */
+function createHandler({ config, format }) {
+  // Lazy load auto-suggest
+  let autoSuggestModule = null;
+
+  function getAutoSuggest() {
+    if (!autoSuggestModule) {
+      autoSuggestModule = require('../../intelligence/auto-suggest');
+    }
+    return autoSuggestModule;
+  }
+
+  return async (params) => {
+    const cfg = config.load();
+    const projectRoot = cfg._projectRoot;
+    const action = params.action || 'analyze';
+
+    const { AutoSuggest } = getAutoSuggest();
+    const autoSuggest = new AutoSuggest(projectRoot);
+
+    switch (action) {
+      case 'analyze': {
+        if (!params.userMessage) {
+          return format.error('userMessage is required for analyze action');
+        }
+
+        const suggestions = autoSuggest.analyze(params.userMessage);
+
+        if (suggestions.length === 0) {
+          return format.success('No relevant suggestions for this context');
+        }
+
+        const formattedSuggestions = suggestions.map(s => ({
+          command: s.command,
+          description: s.description,
+          confidence: Math.round(s.confidence * 100),
+          category: s.category,
+          priority: s.priority
+        }));
+
+        return format.success(
+          `Found ${suggestions.length} relevant suggestion(s)`,
+          formattedSuggestions.map(s => `${s.command} (${s.confidence}%) - ${s.description}`)
+        );
+      }
+
+      case 'enable': {
+        autoSuggest.setEnabled(true);
+        return format.success('Auto-suggest enabled. Bootspring will proactively suggest relevant commands.');
+      }
+
+      case 'disable': {
+        autoSuggest.setEnabled(false);
+        return format.success('Auto-suggest disabled. Run with action="enable" to re-enable.');
+      }
+
+      case 'config': {
+        const status = autoSuggest.getStatus();
+        const enabledCategories = Object.entries(status.categories)
+          .filter(([, enabled]) => enabled)
+          .map(([name]) => name);
+        const disabledCategories = Object.entries(status.categories)
+          .filter(([, enabled]) => !enabled)
+          .map(([name]) => name);
+
+        return format.success(
+          status.enabled
+            ? 'Auto-suggest is enabled and will proactively suggest commands'
+            : 'Auto-suggest is disabled',
+          [
+            `Status: ${status.enabled ? 'enabled' : 'disabled'}`,
+            `Enabled categories: ${enabledCategories.join(', ') || 'none'}`,
+            `Disabled categories: ${disabledCategories.join(', ') || 'none'}`,
+            `Suppressed commands: ${status.suppressedCommands.length || 0}`
+          ]
+        );
+      }
+
+      case 'toggle-category': {
+        if (!params.category) {
+          return format.error('category is required for toggle-category action');
+        }
+
+        const status = autoSuggest.getStatus();
+        if (!status.categories.hasOwnProperty(params.category)) {
+          return format.error(`Unknown category: ${params.category}. Available: ${Object.keys(status.categories).join(', ')}`);
+        }
+
+        const newState = !status.categories[params.category];
+        autoSuggest.setCategory(params.category, newState);
+
+        return format.success(`Category '${params.category}' ${newState ? 'enabled' : 'disabled'}`);
+      }
+
+      default:
+        return format.error(`Unknown action: ${action}`);
+    }
+  };
+}
+
+module.exports = {
+  getToolDefinition,
+  createHandler,
+  toolName
+};