@girardmedia/bootspring 1.2.0 → 2.0.3

package/mcp/tools/dashboard-tool.js

@@ -2,17 +2,108 @@
  * MCP dashboard tool module
  */
 
+const { spawn, execSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const http = require('http');
+const os = require('os');
+
+// PID file location for tracking the dashboard process
+const PID_FILE = path.join(os.tmpdir(), 'bootspring-dashboard.pid');
+
+/**
+ * Check if dashboard is running by trying to connect
+ */
+async function isDashboardRunning(port) {
+  return new Promise((resolve) => {
+    const req = http.request({ host: 'localhost', port, method: 'GET', timeout: 1000 }, (_res) => {
+      resolve(true);
+    });
+    req.on('error', () => resolve(false));
+    req.on('timeout', () => { req.destroy(); resolve(false); });
+    req.end();
+  });
+}
+
+/**
+ * Get the PID of process using a specific port
+ */
+function getProcessOnPort(port) {
+  try {
+    // macOS/Linux: use lsof to find process on port
+    const result = execSync(`lsof -ti:${port} 2>/dev/null || true`, { encoding: 'utf-8' }).trim();
+    if (result) {
+      // Return first PID (there might be multiple lines for IPv4/IPv6)
+      return parseInt(result.split('\n')[0], 10);
+    }
+  } catch {
+    // Ignore errors
+  }
+  return null;
+}
+
+/**
+ * Save PID to file for tracking
+ */
+function savePid(pid) {
+  try {
+    fs.writeFileSync(PID_FILE, String(pid), 'utf-8');
+  } catch {
+    // Ignore write errors
+  }
+}
+
+/**
+ * Read saved PID from file
+ */
+function readSavedPid() {
+  try {
+    if (fs.existsSync(PID_FILE)) {
+      const pid = parseInt(fs.readFileSync(PID_FILE, 'utf-8').trim(), 10);
+      return isNaN(pid) ? null : pid;
+    }
+  } catch {
+    // Ignore read errors
+  }
+  return null;
+}
+
+/**
+ * Remove PID file
+ */
+function removePidFile() {
+  try {
+    if (fs.existsSync(PID_FILE)) {
+      fs.unlinkSync(PID_FILE);
+    }
+  } catch {
+    // Ignore errors
+  }
+}
+
+/**
+ * Kill a process by PID
+ */
+function killProcess(pid) {
+  try {
+    process.kill(pid, 'SIGTERM');
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 function getToolDefinition() {
   return {
     name: 'bootspring_dashboard',
-    description: 'Get dashboard status or start URL.',
+    description: 'Get dashboard status, start the dashboard server, or get the URL.',
     inputSchema: {
       type: 'object',
       properties: {
         action: {
           type: 'string',
-          enum: ['status', 'url'],
-          description: 'Action: status or url'
+          enum: ['status', 'url', 'start', 'stop'],
+          description: 'Action: status, url, start, or stop'
         }
       },
       required: []
@@ -27,18 +118,20 @@ function createHandler({ config }) {
     const port = cfg.dashboard?.port || 3456;
 
     switch (action) {
-      case 'status':
+      case 'status': {
+        const running = await isDashboardRunning(port);
         return {
           content: [{
             type: 'text',
             text: JSON.stringify({
-              status: 'available',
+              status: running ? 'running' : 'stopped',
               port,
               url: `http://localhost:${port}`,
               command: 'bootspring dashboard'
             }, null, 2)
           }]
         };
+      }
       case 'url':
         return {
           content: [{
@@ -46,6 +139,159 @@ function createHandler({ config }) {
             text: `http://localhost:${port}`
           }]
         };
+      case 'start': {
+        // Check if already running
+        const alreadyRunning = await isDashboardRunning(port);
+        if (alreadyRunning) {
+          const existingPid = getProcessOnPort(port);
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({
+                status: 'already_running',
+                port,
+                url: `http://localhost:${port}`,
+                pid: existingPid,
+                message: 'Dashboard is already running'
+              }, null, 2)
+            }]
+          };
+        }
+
+        // Find the dashboard server script
+        const serverPath = path.join(__dirname, '..', '..', 'dashboard', 'server.js');
+
+        // Verify server script exists
+        if (!fs.existsSync(serverPath)) {
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({
+                status: 'error',
+                message: `Dashboard server script not found at: ${serverPath}`,
+                hint: 'Ensure the dashboard module is installed'
+              }, null, 2)
+            }]
+          };
+        }
+
+        // Spawn the dashboard process
+        const dashboardProcess = spawn('node', [serverPath], {
+          detached: true,
+          stdio: 'ignore',
+          env: { ...process.env, BOOTSPRING_PORT: String(port) }
+        });
+
+        // Unref so parent can exit independently
+        dashboardProcess.unref();
+
+        // Save PID for later tracking
+        if (dashboardProcess.pid) {
+          savePid(dashboardProcess.pid);
+        }
+
+        // Wait a moment for startup
+        await new Promise(resolve => setTimeout(resolve, 1500));
+
+        // Verify it started
+        const started = await isDashboardRunning(port);
+
+        if (!started) {
+          removePidFile();
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({
+                status: 'failed',
+                port,
+                message: 'Failed to start dashboard. The server may have crashed on startup.',
+                hint: 'Try running "node dashboard/server.js" manually to see errors'
+              }, null, 2)
+            }]
+          };
+        }
+
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              status: 'started',
+              port,
+              url: `http://localhost:${port}`,
+              pid: dashboardProcess.pid,
+              message: 'Dashboard started successfully'
+            }, null, 2)
+          }]
+        };
+      }
+      case 'stop': {
+        const running = await isDashboardRunning(port);
+        if (!running) {
+          removePidFile();
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({
+                status: 'not_running',
+                message: 'Dashboard is not running'
+              }, null, 2)
+            }]
+          };
+        }
+
+        // Try multiple methods to find and kill the process
+        let killed = false;
+        let killedPid = null;
+
+        // Method 1: Try to find process by port (most reliable)
+        const pidOnPort = getProcessOnPort(port);
+        if (pidOnPort) {
+          killed = killProcess(pidOnPort);
+          if (killed) killedPid = pidOnPort;
+        }
+
+        // Method 2: Try saved PID file as fallback
+        if (!killed) {
+          const savedPid = readSavedPid();
+          if (savedPid) {
+            killed = killProcess(savedPid);
+            if (killed) killedPid = savedPid;
+          }
+        }
+
+        // Clean up PID file
+        removePidFile();
+
+        // Wait a moment and verify it stopped
+        await new Promise(resolve => setTimeout(resolve, 500));
+        const stillRunning = await isDashboardRunning(port);
+
+        if (stillRunning) {
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({
+                status: 'stop_failed',
+                port,
+                message: 'Failed to stop dashboard. Process may require manual termination.',
+                hint: `Try: kill $(lsof -ti:${port})`
+              }, null, 2)
+            }]
+          };
+        }
+
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              status: 'stopped',
+              port,
+              pid: killedPid,
+              message: 'Dashboard stopped successfully'
+            }, null, 2)
+          }]
+        };
+      }
       default:
         throw new Error(`Unknown action: ${action}`);
     }

package/mcp/tools/mvp-tool.js

@@ -0,0 +1,344 @@
+/**
+ * MCP MVP tool module
+ * Provides MVP operations via MCP: init, analyze, import, list, show, extract
+ */
+
+function getToolDefinition() {
+  return {
+    name: 'bootspring_mvp',
+    description: 'Import and manage AI-generated MVP code from tools like Lovable, Bolt, V0, etc. Analyze code quality, transform patterns, and import into production structure.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        action: {
+          type: 'string',
+          enum: ['init', 'analyze', 'import', 'list', 'show', 'extract'],
+          description: 'Action to perform: init (create folders), analyze (assess code quality), import (transform and import), list (show available files), show (display specific file), extract (extract patterns)'
+        },
+        mode: {
+          type: 'string',
+          enum: ['copy', 'inspire', 'hybrid'],
+          description: 'Import mode: copy (direct copy), inspire (extract patterns only), hybrid (copy + refactor)'
+        },
+        file: {
+          type: 'string',
+          description: 'File path for show action'
+        },
+        category: {
+          type: 'string',
+          enum: ['components', 'hooks', 'services', 'utilities', 'pages', 'all'],
+          description: 'Category filter for list/extract actions'
+        }
+      },
+      required: ['action']
+    }
+  };
+}
+
+function createHandler({ mvpModule, config: _config, format }) {
+  return async (args) => {
+    const { action, mode, file, category } = args;
+
+    try {
+      switch (action) {
+        case 'init':
+          return handleInit(mvpModule, format);
+
+        case 'analyze':
+          return handleAnalyze(mvpModule, format);
+
+        case 'import':
+          return handleImport(mvpModule, mode || 'hybrid', format);
+
+        case 'list':
+          return handleList(mvpModule, category || 'all', format);
+
+        case 'show':
+          return handleShow(mvpModule, file, format);
+
+        case 'extract':
+          return handleExtract(mvpModule, category || 'all', format);
+
+        default:
+          return format.error(`Unknown action: ${action}`, [
+            'Valid actions: init, analyze, import, list, show, extract'
+          ]);
+      }
+    } catch (error) {
+      return format.error(`MVP operation failed: ${error.message}`);
+    }
+  };
+}
+
+function handleInit(mvpModule, format) {
+  try {
+    mvpModule.initMvpFolders();
+
+    return {
+      content: [{
+        type: 'text',
+        text: `## MVP Folders Created
+
+| Folder | Purpose |
+|--------|---------|
+| \`${mvpModule.MVP_STRUCTURE.source}/\` | Put your MVP code here |
+| \`${mvpModule.MVP_STRUCTURE.references}/\` | Reference files kept here |
+
+**Next Steps:**
+1. Copy your AI-generated MVP code to \`${mvpModule.MVP_STRUCTURE.source}/\`
+2. Run \`bootspring_mvp\` with action: "analyze" to analyze the code
+3. Run \`bootspring_mvp\` with action: "import" to import with transformations`
+      }]
+    };
+  } catch (error) {
+    return format.error(`Failed to initialize: ${error.message}`);
+  }
+}
+
+function handleAnalyze(mvpModule, format) {
+  const result = mvpModule.analyzeMvp();
+
+  if (!result.success) {
+    return format.warning(result.error, [
+      'Run bootspring_mvp with action: "init" to create the folder structure'
+    ]);
+  }
+
+  const { analysis } = result;
+
+  // Build issue summary
+  const issueCount = {};
+  for (const file of analysis.files) {
+    for (const issue of file.issues) {
+      issueCount[issue.type] = (issueCount[issue.type] || 0) + 1;
+    }
+  }
+
+  const topIssues = Object.entries(issueCount)
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, 5)
+    .map(([type, count]) => `- ${type}: ${count} occurrences`)
+    .join('\n');
+
+  // Find low quality files
+  const lowQualityFiles = analysis.files
+    .filter(f => f.quality < 70)
+    .sort((a, b) => a.quality - b.quality)
+    .slice(0, 5)
+    .map(f => `- ${f.path}: ${f.quality}%`)
+    .join('\n');
+
+  return {
+    content: [{
+      type: 'text',
+      text: `## MVP Analysis
+
+**Summary:**
+| Metric | Value |
+|--------|-------|
+| Total Files | ${analysis.totalFiles} |
+| Average Quality | ${analysis.summary.averageQuality}% |
+| Total Issues | ${analysis.summary.totalIssues} |
+| Critical Issues | ${analysis.summary.criticalIssues} |
+| Suggested Mode | ${analysis.summary.suggestedMode} |
+
+**File Categories:**
+${Object.entries(analysis.categories).map(([_cat, data]) => `- ${data.description}: ${data.count} files`).join('\n')}
+
+**Top Issues:**
+${topIssues || 'None detected'}
+
+**Lowest Quality Files:**
+${lowQualityFiles || 'All files above 70%'}
+
+**Recommended Mode:** \`${analysis.summary.suggestedMode}\`
+- **copy**: Direct copy, minimal changes
+- **inspire**: Extract patterns only
+- **hybrid**: Copy with refactoring (recommended for most cases)`
+    }]
+  };
+}
+
+function handleImport(mvpModule, mode, format) {
+  const result = mvpModule.importMvp({ mode });
+
+  if (!result.success) {
+    return format.error(result.error);
+  }
+
+  const { imported, skipped, transformed, referencesMoved } = result;
+
+  return {
+    content: [{
+      type: 'text',
+      text: `## MVP Import Complete
+
+**Mode:** ${mode}
+
+| Metric | Count |
+|--------|-------|
+| Files Imported | ${imported} |
+| Files Skipped | ${skipped} |
+| Files Transformed | ${transformed} |
+| References Moved | ${referencesMoved} |
+
+**Import Summary:**
+${result.summary || 'MVP code has been imported into your project structure.'}
+
+**Next Steps:**
+1. Review imported files in your project
+2. Run \`npm install\` if new dependencies were added
+3. Check for any TODO comments added during transformation`
+    }]
+  };
+}
+
+function handleList(mvpModule, category, format) {
+  const result = mvpModule.analyzeMvp();
+
+  if (!result.success) {
+    return format.warning(result.error, [
+      'Run bootspring_mvp with action: "init" to create the folder structure'
+    ]);
+  }
+
+  const { analysis } = result;
+
+  let files = analysis.files;
+  if (category !== 'all') {
+    files = files.filter(f => f.category === category);
+  }
+
+  const fileList = files
+    .slice(0, 30)
+    .map(f => `- \`${f.path}\` (${f.category}, ${f.quality}%)`)
+    .join('\n');
+
+  return {
+    content: [{
+      type: 'text',
+      text: `## MVP Files ${category !== 'all' ? `(${category})` : ''}
+
+**Total:** ${files.length} files
+
+${fileList}
+${files.length > 30 ? `\n... and ${files.length - 30} more files` : ''}
+
+**Categories:**
+${Object.entries(analysis.categories).map(([cat, data]) => `- ${cat}: ${data.count} files`).join('\n')}`
+    }]
+  };
+}
+
+function handleShow(mvpModule, filePath, format) {
+  if (!filePath) {
+    return format.error('File path required', [
+      'Use file parameter to specify which file to show'
+    ]);
+  }
+
+  const fs = require('fs');
+  const path = require('path');
+
+  const result = mvpModule.analyzeMvp();
+  if (!result.success) {
+    return format.error(result.error);
+  }
+
+  // Find the file in the MVP source
+  const mvpSource = mvpModule.MVP_STRUCTURE.source;
+  const fullPath = path.join(process.cwd(), mvpSource, filePath);
+
+  if (!fs.existsSync(fullPath)) {
+    return format.error(`File not found: ${filePath}`, [
+      `File should be in ${mvpSource}/`
+    ]);
+  }
+
+  const content = fs.readFileSync(fullPath, 'utf-8');
+  const ext = path.extname(filePath).slice(1) || 'text';
+
+  // Get analysis for this specific file
+  const fileAnalysis = result.analysis.files.find(f => f.path === filePath);
+
+  return {
+    content: [{
+      type: 'text',
+      text: `## ${filePath}
+
+${fileAnalysis ? `**Quality:** ${fileAnalysis.quality}% | **Category:** ${fileAnalysis.category} | **Issues:** ${fileAnalysis.issues.length}` : ''}
+
+\`\`\`${ext}
+${content.slice(0, 5000)}${content.length > 5000 ? '\n... (truncated)' : ''}
+\`\`\`
+
+${fileAnalysis && fileAnalysis.issues.length > 0 ? `**Issues:**\n${fileAnalysis.issues.map(i => `- ${i.type}: ${i.message}`).join('\n')}` : ''}`
+    }]
+  };
+}
+
+function handleExtract(mvpModule, category, format) {
+  const result = mvpModule.analyzeMvp();
+
+  if (!result.success) {
+    return format.warning(result.error);
+  }
+
+  const { analysis } = result;
+
+  // Extract patterns based on category
+  const patterns = {
+    components: [],
+    hooks: [],
+    services: [],
+    utilities: [],
+    pages: []
+  };
+
+  for (const file of analysis.files) {
+    if (category !== 'all' && file.category !== category) continue;
+
+    const pattern = {
+      file: file.path,
+      category: file.category,
+      exports: file.exports || [],
+      dependencies: file.dependencies || [],
+      quality: file.quality
+    };
+
+    if (patterns[file.category]) {
+      patterns[file.category].push(pattern);
+    }
+  }
+
+  const patternSummary = Object.entries(patterns)
+    .filter(([_, items]) => items.length > 0)
+    .map(([cat, items]) => {
+      const topItems = items
+        .sort((a, b) => b.quality - a.quality)
+        .slice(0, 5);
+      return `### ${cat.charAt(0).toUpperCase() + cat.slice(1)}
+
+${topItems.map(p => `- \`${p.file}\` (${p.quality}%)`).join('\n')}`;
+    })
+    .join('\n\n');
+
+  return {
+    content: [{
+      type: 'text',
+      text: `## Extracted Patterns ${category !== 'all' ? `(${category})` : ''}
+
+${patternSummary || 'No patterns found'}
+
+**Summary:**
+${Object.entries(patterns).map(([cat, items]) => `- ${cat}: ${items.length} patterns`).join('\n')}
+
+Use these patterns to understand the MVP's architecture and inform your production implementation.`
+    }]
+  };
+}
+
+module.exports = {
+  getToolDefinition,
+  createHandler
+};

package/mcp/tools/plugin-tool.js

@@ -57,10 +57,32 @@ function createHandler({ config }) {
       case 'enable':
       case 'disable': {
         if (!name) throw new Error('Plugin name required');
+
+        // Initialize plugins object if it doesn't exist
+        if (!cfg.plugins) {
+          cfg.plugins = {};
+        }
+
+        // Initialize the plugin if it doesn't exist
+        if (!cfg.plugins[name]) {
+          cfg.plugins[name] = { enabled: false };
+        }
+
+        // Update the enabled state
+        const isEnabled = action === 'enable';
+        cfg.plugins[name].enabled = isEnabled;
+
+        // Persist the configuration
+        const saved = config.save(cfg);
+
+        if (!saved) {
+          throw new Error(`Failed to save configuration after ${action}ing plugin ${name}`);
+        }
+
         return {
           content: [{
             type: 'text',
-            text: `Plugin ${name} ${action}d. Update bootspring.config.js to persist.`
+            text: `Plugin '${name}' has been ${action}d and saved to configuration.`
           }]
         };
       }