ultra-dex 2.2.0 → 3.1.0

package/lib/commands/serve.js

@@ -1,56 +1,204 @@
 import chalk from 'chalk';
-import fs from 'fs/promises';
 import http from 'http';
-import { validateSafePath } from '../utils/validation.js';
-
-async function readFileSafe(filePath, label) {
-  try {
-    const content = await fs.readFile(filePath, 'utf-8');
-    return { label, content };
-  } catch {
-    return { label, content: '' };
-  }
-}
+import fs from 'fs/promises';
+import path from 'path';
+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';
 
 export function registerServeCommand(program) {
   program
     .command('serve')
-    .description('Serve Ultra-Dex context over HTTP (MCP-compatible)')
+    .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) => {
-      const port = Number.parseInt(options.port, 10);
-      if (Number.isNaN(port)) {
-        console.log(chalk.red('Invalid port. Use a numeric value.'));
-        process.exit(1);
+      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);
       }
+    });
+}
 
-      const server = http.createServer(async (req, res) => {
-        if (!req.url || req.url === '/') {
-          res.writeHead(200, { 'Content-Type': 'text/plain' });
-          res.end('Ultra-Dex MCP Server\n');
-          return;
-        }
+async function getGitInfo() {
+  try {
+    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 { branch: 'unknown', lastCommit: 'N/A', changedFiles: 0 };
+  }
+}
+
+// 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 {
+    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 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');
+
+    if (req.method === 'OPTIONS') {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+
+    const url = new URL(req.url, `http://${req.headers.host}`);
+    const pathname = url.pathname;
+
+    try {
+      // Dashboard UI
+      if (pathname === '/' || pathname === '/dashboard') {
+        const html = await getDashboardHTML();
+        res.writeHead(200, { 'Content-Type': 'text/html' });
+        res.end(html);
+        return;
+      }
 
-        if (req.url === '/context') {
-          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'),
-          ]);
+      // 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;
+      }
+
+      // 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;
+      }
+
+      // 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;
+      }
 
-          res.writeHead(200, { 'Content-Type': 'application/json' });
-          res.end(JSON.stringify({ files: [context, plan, quickStart] }));
+      // 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;
+      }
+
+      // 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;
+      }
+
+      // 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;
-        }
+      }
+
+      res.writeHead(404, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: 'Not found' }));
+
+    } catch (error) {
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: error.message }));
+    }
+  });
+  
+  const wss = new UltraDexSocket(server);
 
-        res.writeHead(404, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ error: 'Not found' }));
-      });
+  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.`));
 
-      server.listen(port, () => {
-        console.log(chalk.green(`\n✅ Ultra-Dex MCP server running on http://localhost:${port}`));
-        console.log(chalk.gray('  GET /context -> CONTEXT.md, IMPLEMENTATION-PLAN.md, QUICK-START.md'));
-        console.log(chalk.gray('  GET / -> health check\n'));
-      });
+    // 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) {}
     });
-}
+  });
+}

package/lib/commands/state.js

@@ -0,0 +1,354 @@
+/**
+ * ultra-dex state management commands
+ * align, status, watch, pre-commit, state
+ */
+
+import chalk from 'chalk';
+import ora from 'ora';
+import fs from 'fs/promises';
+import { watch as fsWatch } from 'fs';
+import path from 'path';
+import { validateSafePath } from '../utils/validation.js';
+import { buildGraph } from '../utils/graph.js';
+
+// State management helpers
+export async function loadState() {
+  try {
+    const content = await fs.readFile(path.resolve(process.cwd(), '.ultra/state.json'), 'utf8');
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+
+export async function saveState(state) {
+  const ultraDir = path.resolve(process.cwd(), '.ultra');
+  const statePath = path.resolve(ultraDir, 'state.json');
+  try {
+    await fs.mkdir(ultraDir, { recursive: true });
+    await fs.writeFile(statePath, JSON.stringify(state, null, 2));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function computeState() {
+  // Try to load existing state first to check schema
+  const existing = await loadState();
+  if (existing && existing.project?.mode === 'GOD_MODE') {
+    // In God Mode, we update the timestamp
+    existing.updatedAt = new Date().toISOString();
+    return existing;
+  }
+
+  // Legacy computation logic
+  const state = {
+    version: '2.4.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, modified: stat.mtime.toISOString() };
+    } catch {
+      state.files[file] = { exists: false };
+    }
+  }
+
+  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 */ }
+
+  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);
+
+  return state;
+}
+
+export async function updateState() {
+  const state = await computeState();
+  await saveState(state);
+  return state;
+}
+
+export function registerAlignCommand(program) {
+  program
+    .command('align')
+    .description('Quick alignment score using Code Property Graph')
+    .option('--strict', 'Exit with error if score < 70')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+      // 1. Compute Base State
+      const state = await computeState();
+      
+      // 2. Compute Graph Score (God Mode)
+      let graphScore = 0;
+      let graphStats = { nodes: 0, edges: 0 };
+      
+      try {
+        const graph = await buildGraph();
+        graphStats = { nodes: graph.nodes.length, edges: graph.edges.length };
+        
+        // Simple heuristic: A healthy project has nodes and edges
+        // 10+ nodes = 20 points
+        // 10+ edges = 20 points
+        const nodesPoints = Math.min(graph.nodes.length * 2, 20);
+        const edgesPoints = Math.min(graph.edges.length * 2, 20);
+        graphScore = nodesPoints + edgesPoints;
+      } catch (e) {
+        // Graph failed
+      }
+
+      // 3. Combine Scores
+      // Legacy score (files/plan) is 60% weight, Graph is 40%
+      const totalScore = Math.min(Math.round((state.score * 0.6) + graphScore), 100);
+
+      if (options.json) {
+        console.log(JSON.stringify({ 
+            score: totalScore, 
+            legacyScore: state.score,
+            graphScore,
+            graphStats,
+            files: Object.values(state.files).filter(f => f.exists).length, 
+            sections: state.sections.completed 
+        }));
+      } else {
+        const icon = totalScore >= 80 ? '✅' : totalScore >= 50 ? '⚠️' : '❌';
+        console.log(`${icon} Alignment: ${totalScore}/100`);
+        console.log(chalk.gray(`   • Plan/Docs: ${state.score}/100`));
+        console.log(chalk.gray(`   • Code Graph: ${graphScore}/40 (Nodes: ${graphStats.nodes}, Edges: ${graphStats.edges})`));
+      }
+      
+      if (options.strict && totalScore < 70) {
+        process.exit(1);
+      }
+    });
+}
+
+export function registerStatusCommand(program) {
+  program
+    .command('status')
+    .description('Show current project state')
+    .option('--refresh', 'Refresh state before showing')
+    .option('--json', 'Output raw JSON')
+    .action(async (options) => {
+      if (options.refresh) {
+        const state = await computeState();
+        await saveState(state);
+      }
+
+      let state = await loadState();
+      if (!state) {
+        console.log(chalk.yellow('\n⚠️  No .ultra/state.json found. Generating...\n'));
+        state = await computeState();
+        await saveState(state);
+      }
+
+      if (options.json) {
+        console.log(JSON.stringify(state, null, 2));
+        return;
+      }
+
+      console.log(chalk.bold('\n📊 Ultra-Dex Status\n'));
+      console.log(chalk.gray('─'.repeat(50)));
+      
+      if (state.project?.mode === 'GOD_MODE') {
+          // Render God Mode Status
+          console.log(chalk.cyan(`  MODE: ${state.project.mode}`));
+          console.log(chalk.gray(`  Version: ${state.project.version}`));
+          console.log(chalk.gray('─'.repeat(50)));
+          
+          console.log(chalk.bold('\n🚀 Phases:'));
+          state.phases.forEach(phase => {
+              const icon = phase.status === 'completed' ? '✅' : phase.status === 'in_progress' ? '🔄' : '⏳';
+              console.log(`  ${icon} ${chalk.bold(phase.name)}`);
+              phase.steps.forEach(step => {
+                  const stepIcon = step.status === 'completed' ? chalk.green('✓') : chalk.gray('-');
+                  console.log(`    ${stepIcon} ${step.task}`);
+              });
+              console.log('');
+          });
+
+          console.log(chalk.bold('🤖 Agents:'));
+          state.agents.registry.forEach(agent => {
+              const active = state.agents.active.includes(agent) ? chalk.green('(Active)') : '';
+              console.log(`  • @${agent} ${active}`);
+          });
+
+      } else {
+          // Render Legacy Status
+          const scoreColor = state.score >= 80 ? 'green' : state.score >= 50 ? 'yellow' : 'red';
+          console.log(chalk[scoreColor](`  Score: ${state.score}/100`));
+          console.log(chalk.gray(`  Updated: ${state.updatedAt}`));
+          console.log(chalk.gray('─'.repeat(50)));
+
+          console.log(chalk.bold('\n📁 Files:'));
+          if (state.files) {
+            Object.entries(state.files).forEach(([name, info]) => {
+                const icon = info.exists ? chalk.green('✓') : chalk.red('✗');
+                const size = info.exists ? chalk.gray(` (${info.size} bytes)`) : '';
+                console.log(`  ${icon} ${name}${size}`);
+            });
+          }
+
+          console.log(chalk.bold('\n📝 Sections:'));
+          console.log(`  ${state.sections.completed}/${state.sections.total} documented`);
+          if (state.sections.list.length > 0) {
+            const recent = state.sections.list.slice(-3);
+            recent.forEach(s => console.log(chalk.gray(`    ${s.number}. ${s.title}`)));
+            if (state.sections.list.length > 3) {
+            console.log(chalk.gray(`    ... and ${state.sections.list.length - 3} more`));
+            }
+          }
+      }
+      console.log('');
+    });
+}
+
+export function registerWatchCommand(program) {
+    // This is now handled by watch.js, but keeping here for legacy imports if any. 
+    // In God Mode, watch.js replaces this.
+    // The bin/ultra-dex.js uses watch.js, so this might be dead code or overwritten.
+    // I will leave it as is or update it to be safe.
+    program
+    .command('watch-legacy') // Rename to avoid conflict if both registered
+    .action(() => console.log("Use 'ultra-dex watch' instead."));
+}
+
+export function registerPreCommitCommand(program) {
+  program
+    .command('pre-commit')
+    .description('Pre-commit hook - verify before commit')
+    .option('--install', 'Install git pre-commit hook')
+    .option('--scan', 'Include deep code quality scan in hook')
+    .option('--ai', 'Run AI-powered quality review on staged changes')
+    .option('-d, --dir <directory>', 'Project directory', '.')
+    .action(async (options) => {
+      const dirValidation = validateSafePath(options.dir, 'Project directory');
+      if (dirValidation !== true) {
+        console.log(chalk.red(dirValidation));
+        process.exit(1);
+      }
+
+      const rootDir = path.resolve(options.dir);
+
+      if (options.install) {
+        const hookPath = path.resolve(rootDir, '.git/hooks/pre-commit');
+        const scanCmd = options.scan ? '\nnpx ultra-dex validate --scan' : '';
+        const aiCmd = options.ai ? '\nnpx ultra-dex pre-commit --ai' : '';
+        const hookScript = `#!/bin/sh
+# Ultra-Dex pre-commit hook
+npx ultra-dex align --strict${scanCmd}${aiCmd}
+if [ $? -ne 0 ]; then
+  echo "❌ Ultra-Dex quality gate failed."
+  echo "   Run 'ultra-dex review' or 'ultra-dex validate --scan' for details."
+  exit 1
+fi
+`;
+        try {
+          await fs.mkdir(path.dirname(hookPath), { recursive: true });
+          await fs.writeFile(hookPath, hookScript, { mode: 0o755 });
+          console.log(chalk.green('✅ Pre-commit hook installed!'));
+          console.log(chalk.gray('   Commits will be blocked if alignment score < 70 or AI review fails.'));
+        } catch (e) {
+          console.log(chalk.red('❌ Failed to install hook: ' + e.message));
+        }
+        return;
+      }
+      
+      const state = await loadState();
+      
+      // AI Quality Gate (God Mode)
+      if (options.ai) {
+          const spinner = (await import('ora')).default('🤖 AI Quality Gate: Reviewing staged changes...').start();
+          try {
+              const { execSync } = await import('child_process');
+              // Get staged changes
+              const staged = execSync('git diff --cached --name-only', { encoding: 'utf8' }).split('\n').filter(Boolean);
+              if (staged.length === 0) {
+                  spinner.succeed('No staged changes to review.');
+                  return;
+              }
+
+              const { createProvider, getDefaultProvider } = await import('../providers/index.js');
+              const { runAgentLoop } = await import('./run.js');
+              
+              const provider = createProvider(getDefaultProvider());
+              const reviewResult = await runAgentLoop('reviewer', `Review these staged files for architectural violations (e.g. missing validation, security risks):\n${staged.join('\n')}`, provider, { state });
+
+              if (reviewResult.toLowerCase().includes('reject') || reviewResult.toLowerCase().includes('blocking violation')) {
+                  spinner.fail('AI Quality Gate: REJECTED');
+                  console.log(chalk.red('\nviolations found:'));
+                  console.log(reviewResult);
+                  process.exit(1);
+              }
+              spinner.succeed('AI Quality Gate: PASSED');
+          } catch (e) {
+              spinner.warn('AI Quality Gate skipped: ' + e.message);
+          }
+      }
+
+      if (state && state.project?.mode === 'GOD_MODE') {
+          console.log(chalk.green(`✅ Alignment OK: GOD MODE ACTIVE`));
+          return;
+      }
+
+      if (state && state.score < 70) {
+        console.log(chalk.red(`❌ BLOCKED: Alignment score ${state.score}/100 (required: 70)`));
+        console.log(chalk.yellow('   Run `ultra-dex review` for detailed analysis.'));
+        process.exit(1);
+      } else {
+        console.log(chalk.green(`✅ Alignment OK: ${state ? state.score : 'N/A'}/100`));
+      }
+    });
+}
+
+export function registerStateCommand(program) {
+  program
+    .command('state')
+    .description('Manage .ultra/state.json')
+    .option('--init', 'Initialize .ultra directory')
+    .option('--refresh', 'Refresh state from files')
+    .action(async (options) => {
+      if (options.init || options.refresh) {
+        const state = await computeState();
+        await saveState(state);
+        console.log(chalk.green('✅ State updated'));
+        if (state.project?.mode === 'GOD_MODE') {
+             console.log(chalk.gray(`   Mode: GOD_MODE`));
+        } else {
+             console.log(chalk.gray(`   Score: ${state.score}/100`));
+        }
+        return;
+      }
+
+      const state = await loadState();
+      if (!state) {
+        console.log(chalk.yellow('No .ultra/state.json found. Run `ultra-dex state --init`'));
+        return;
+      }
+      console.log(JSON.stringify(state, null, 2));
+    });
+}
+
+export default {
+  registerAlignCommand,
+  registerStatusCommand,
+  registerWatchCommand,
+  registerPreCommitCommand,
+  registerStateCommand,
+};