ultra-dex 2.2.1 → 3.1.0

package/lib/commands/serve.js

@@ -2,172 +2,203 @@ import chalk from 'chalk';
 import http from 'http';
 import fs from 'fs/promises';
 import path from 'path';
-import { readFileSafe } from '../utils/files.js';
+import { loadState, generateMarkdown } from './plan.js';
+import { startMcpServer } from '../mcp/server.js';
+import { projectGraph } from '../mcp/graph.js';
+import { UltraDexSocket } from '../mcp/websocket.js';
+import { swarmCommand } from './swarm.js';
+import { glob } from 'glob';
+import { execSync, spawn } from 'child_process';
 
-// State management helpers
-async function loadState() {
+export function registerServeCommand(program) {
+  program
+    .command('serve')
+    .description('Start the Ultra-Dex Active Kernel (MCP + Dashboard + API)')
+    .option('-p, --port <port>', 'Port to listen on', '3001')
+    .option('--stdio', 'Run in Stdio mode (MCP Standard Only)', false)
+    .action(async (options) => {
+      if (options.stdio) {
+        // Run only MCP Stdio server
+        try {
+          await startMcpServer();
+        } catch (error) {
+          console.error("Failed to start MCP Server:", error);
+          process.exit(1);
+        }
+      } else {
+        // Run full Unified Kernel (HTTP + WebSocket + Dashboard + MCP over HTTP)
+        await startUnifiedKernel(options.port);
+      }
+    });
+}
+
+async function getGitInfo() {
   try {
-    const content = await fs.readFile(path.resolve(process.cwd(), '.ultra/state.json'), 'utf8');
-    return JSON.parse(content);
+    const branch = execSync('git branch --show-current', { encoding: 'utf8' }).trim();
+    const lastCommit = execSync('git log -1 --format="%h %s" 2>/dev/null', { encoding: 'utf8' }).trim();
+    const status = execSync('git status --porcelain 2>/dev/null', { encoding: 'utf8' });
+    const changedFiles = status.split('\n').filter(l => l.trim()).length;
+    return { branch, lastCommit, changedFiles };
   } catch {
-    return null;
+    return { branch: 'unknown', lastCommit: 'N/A', changedFiles: 0 };
   }
 }
 
-async function computeState() {
-  const state = {
-    version: '2.1.0',
-    updatedAt: new Date().toISOString(),
-    project: { name: path.basename(process.cwd()) },
-    files: {},
-    sections: { total: 34, completed: 0, list: [] },
-    score: 0
-  };
-
-  const coreFiles = ['CONTEXT.md', 'IMPLEMENTATION-PLAN.md', 'CHECKLIST.md', 'QUICK-START.md'];
-  for (const file of coreFiles) {
-    try {
-      const stat = await fs.stat(path.resolve(process.cwd(), file));
-      state.files[file] = { exists: true, size: stat.size };
-    } catch {
-      state.files[file] = { exists: false };
-    }
-  }
+// Re-using dashboard HTML generation logic (modularized)
+async function getDashboardHTML() {
+  const { generateDashboardHTML } = await import('./dashboard.js');
+  const state = await loadState();
+  const gitInfo = await getGitInfo();
+  await projectGraph.scan();
+  const summary = projectGraph.getSummary();
+  return generateDashboardHTML(state, gitInfo, { nodes: summary.nodeCount, edges: summary.edgeCount });
+}
+
+async function startUnifiedKernel(portStr) {
+  const port = Number.parseInt(portStr, 10);
+      
+  console.log(chalk.bold.cyan('\n🚀 Ultra-Dex Active Kernel Starting (GOD MODE)...\n'));
 
+  // Initialize Graph
+  console.log(chalk.gray('🧠 Initializing Neural Link (Code Graph)...'));
   try {
-    const plan = await fs.readFile(path.resolve(process.cwd(), 'IMPLEMENTATION-PLAN.md'), 'utf8');
-    const sectionRegex = /^##\s+(\d+)\.\s+(.+)$/gm;
-    let match;
-    while ((match = sectionRegex.exec(plan)) !== null) {
-      state.sections.list.push({ number: parseInt(match[1]), title: match[2].trim() });
-    }
-    state.sections.completed = state.sections.list.length;
-  } catch { /* no plan */ }
+    await projectGraph.scan();
+    console.log(chalk.green(`✅ Graph loaded: ${projectGraph.nodes.size} nodes`));
+  } catch (e) {
+    console.log(chalk.yellow(`⚠️ Graph init failed: ${e.message}`));
+  }
 
-  const fileScore = Object.values(state.files).filter(f => f.exists).length / coreFiles.length * 40;
-  const sectionScore = state.sections.completed / state.sections.total * 60;
-  state.score = Math.round(fileScore + sectionScore);
+  const server = http.createServer(async (req, res) => {
+    // CORS headers for local tools
+    res.setHeader('Access-Control-Allow-Origin', '*');
+    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+    res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
 
-  return state;
-}
+    if (req.method === 'OPTIONS') {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
 
-const BUILD_AGENTS = [
-  { name: 'planner', tier: 'architect', task: 'Break down requirements into tasks' },
-  { name: 'cto', tier: 'architect', task: 'Technical decisions & architecture' },
-  { name: 'backend', tier: 'core', task: 'API, business logic, services' },
-  { name: 'frontend', tier: 'core', task: 'UI components, pages, styling' },
-  { name: 'database', tier: 'core', task: 'Schema design, migrations, queries' },
-  { name: 'auth', tier: 'specialist', task: 'Authentication & authorization' },
-  { name: 'security', tier: 'specialist', task: 'Security audit & hardening' },
-  { name: 'testing', tier: 'specialist', task: 'Test strategy & implementation' },
-  { name: 'reviewer', tier: 'quality', task: 'Code review & best practices' },
-  { name: 'devops', tier: 'quality', task: 'CI/CD, deployment, infrastructure' }
-];
+    const url = new URL(req.url, `http://${req.headers.host}`);
+    const pathname = url.pathname;
 
-export function registerServeCommand(program) {
-  program
-    .command('serve')
-    .description('Serve Ultra-Dex context over HTTP (MCP-compatible)')
-    .option('-p, --port <port>', 'Port to listen on', '3001')
-    .action(async (options) => {
-      const port = Number.parseInt(options.port, 10);
-      if (Number.isNaN(port)) {
-        console.log(chalk.red('Invalid port. Use a numeric value.'));
-        process.exit(1);
+    try {
+      // Dashboard UI
+      if (pathname === '/' || pathname === '/dashboard') {
+        const html = await getDashboardHTML();
+        res.writeHead(200, { 'Content-Type': 'text/html' });
+        res.end(html);
+        return;
       }
 
-      const server = http.createServer(async (req, res) => {
-        res.setHeader('Access-Control-Allow-Origin', '*');
-        
-        if (!req.url || req.url === '/') {
-          res.writeHead(200, { 'Content-Type': 'application/json' });
-          res.end(JSON.stringify({
-            name: 'Ultra-Dex MCP Server',
-            version: '2.1.0',
-            endpoints: ['/context', '/state', '/score', '/agents', '/agent/:name', '/refresh']
-          }));
-          return;
-        }
+      // Endpoint: /api/info
+      if (pathname === '/api/info') {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({
+          name: 'Ultra-Dex Active Kernel',
+          version: '2.4.1',
+          status: 'online',
+          endpoints: ['/api/state', '/api/plan', '/api/context', '/api/graph', '/api/swarm']
+        }, null, 2));
+        return;
+      }
 
-        if (req.url === '/context') {
-          const meta = {
-            protocol: 'mcp-lite',
-            version: '0.1',
-            generatedAt: new Date().toISOString(),
-          };
-          const [context, plan, quickStart] = await Promise.all([
-            readFileSafe('CONTEXT.md', 'CONTEXT.md'),
-            readFileSafe('IMPLEMENTATION-PLAN.md', 'IMPLEMENTATION-PLAN.md'),
-            readFileSafe('QUICK-START.md', 'QUICK-START.md'),
-          ]);
-
-          res.writeHead(200, { 'Content-Type': 'application/json' });
-          res.end(JSON.stringify({ meta, files: [context, plan, quickStart] }));
-          return;
-        }
+      // Endpoint: /api/graph
+      if (pathname === '/api/graph' || pathname === '/graph') {
+        const summary = projectGraph.getSummary();
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(summary, null, 2));
+        return;
+      }
 
-        // /state - returns .ultra/state.json
-        if (req.url === '/state') {
-          let state = await loadState();
-          if (!state) state = await computeState();
-          res.writeHead(200, { 'Content-Type': 'application/json' });
-          res.end(JSON.stringify(state));
-          return;
-        }
+      // Endpoint: /api/state
+      if (pathname === '/api/state' || pathname === '/state') {
+        const state = await loadState();
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(state, null, 2));
+        return;
+      }
 
-        // /score - quick alignment score
-        if (req.url === '/score') {
-          const state = await computeState();
-          res.writeHead(200, { 'Content-Type': 'application/json' });
-          res.end(JSON.stringify({ score: state.score, sections: state.sections.completed, total: 34 }));
-          return;
-        }
+      // Endpoint: /api/swarm (Execute Swarm)
+      if ((pathname === '/api/swarm' || pathname === '/swarm') && req.method === 'POST') {
+        let body = '';
+        req.on('data', chunk => body += chunk);
+        req.on('end', async () => {
+           try {
+             const { task, feature, parallel } = JSON.parse(body);
+             const objective = task || feature;
+             if (!objective) throw new Error('Task/Feature objective is required');
+             
+             // Run swarm
+             swarmCommand(objective, { parallel, dryRun: false }).catch(err => console.error(err));
+             
+             res.writeHead(202, { 'Content-Type': 'application/json' });
+             res.end(JSON.stringify({ status: 'accepted', message: 'Swarm started' }));
+           } catch (e) {
+             res.writeHead(400, { 'Content-Type': 'application/json' });
+             res.end(JSON.stringify({ error: e.message }));
+           }
+        });
+        return;
+      }
 
-        // /agents - list available agents
-        if (req.url === '/agents') {
-          res.writeHead(200, { 'Content-Type': 'application/json' });
-          res.end(JSON.stringify({ agents: BUILD_AGENTS }));
-          return;
-        }
+      // Endpoint: /api/plan
+      if (pathname === '/api/plan' || pathname === '/plan') {
+        const state = await loadState();
+        const markdown = generateMarkdown(state);
+        res.writeHead(200, { 'Content-Type': 'text/markdown' });
+        res.end(markdown);
+        return;
+      }
 
-        // /agent/:name - get specific agent prompt
-        if (req.url.startsWith('/agent/')) {
-          const agentName = req.url.replace('/agent/', '');
-          try {
-            const agentPath = path.resolve(process.cwd(), `agents/${agentName}.md`);
-            const content = await fs.readFile(agentPath, 'utf8');
-            res.writeHead(200, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ agent: agentName, prompt: content }));
-          } catch {
-            res.writeHead(404, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ error: `Agent ${agentName} not found` }));
-          }
+      // SSE Events for Dashboard
+      if (pathname === '/events') {
+          res.writeHead(200, {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            'Connection': 'keep-alive'
+          });
+          res.write(`data: ${JSON.stringify({ type: 'log', message: 'Connected to Active Kernel' })}\n\n`);
+          // We'd need to manage clients here if we wanted to push updates
           return;
-        }
+      }
 
-        // /refresh - force state refresh
-        if (req.url === '/refresh') {
-          const state = await computeState();
-          res.writeHead(200, { 'Content-Type': 'application/json' });
-          res.end(JSON.stringify({ refreshed: true, score: state.score }));
-          return;
-        }
+      res.writeHead(404, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: 'Not found' }));
 
-        res.writeHead(404, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ error: 'Not found' }));
-      });
-
-      server.listen(port, () => {
-        console.log(chalk.green(`\n✅ Ultra-Dex MCP server running on http://localhost:${port}`));
-        console.log(chalk.bold('\n📡 Endpoints:'));
-        console.log(chalk.gray('  GET /          → Server info & endpoint list'));
-        console.log(chalk.gray('  GET /context   → All context files'));
-        console.log(chalk.gray('  GET /state     → Full project state'));
-        console.log(chalk.gray('  GET /score     → Quick alignment score'));
-        console.log(chalk.gray('  GET /agents    → List available agents'));
-        console.log(chalk.gray('  GET /agent/:n  → Get specific agent prompt'));
-        console.log(chalk.gray('  GET /refresh   → Force state refresh'));
-        console.log(chalk.cyan('\n💡 Connect your AI tool to this server for live context.\n'));
-      });
+    } catch (error) {
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: error.message }));
+    }
+  });
+  
+  const wss = new UltraDexSocket(server);
+
+  server.listen(port, () => {
+    console.log(chalk.green(`✅ Unified Kernel active at http://localhost:${port}`));
+    console.log(chalk.gray(`   • Dashboard: http://localhost:${port}/`));
+    console.log(chalk.gray(`   • MCP API:   http://localhost:${port}/api/info`));
+    
+    console.log(chalk.bold.magenta('\n🔌 AI Tool Integration:'));
+    console.log(chalk.white('   Cursor IDE: '));
+    console.log(chalk.cyan(`     URL: http://localhost:${port}/api/info`));
+    console.log(chalk.white('   Claude Desktop:'));
+    console.log(chalk.cyan(`     Run "ultra-dex config --mcp" to register.`));
+
+    // Auto-Pilot
+    fs.watch(process.cwd(), { recursive: true }, async (eventType, filename) => {
+      if (!filename || filename.includes('node_modules') || filename.includes('.git') || filename.includes('IMPLEMENTATION-PLAN.md')) return;
+      
+      console.log(chalk.gray(`\n🔄 Change in ${filename}. Synchronizing...`));
+      try {
+        const state = await loadState();
+        if (state) {
+            const markdown = generateMarkdown(state);
+            await fs.writeFile(path.resolve(process.cwd(), 'IMPLEMENTATION-PLAN.md'), markdown);
+            wss.sendStateUpdate(state);
+        }
+      } catch (e) {}
     });
-}
+  });
+}