ultra-dex 2.2.1 → 3.1.0

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,
+};

package/lib/commands/swarm.js

@@ -0,0 +1,284 @@
+// cli/lib/commands/swarm.js
+import chalk from 'chalk';
+import ora from 'ora';
+import { getProvider } from '../providers/index.js';
+import { readFile, writeFile, mkdir } from 'fs/promises';
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { glob } from 'glob';
+import { projectGraph } from '../mcp/graph.js';
+import { updateState, loadState, saveState } from './state.js';
+
+const AGENT_PIPELINE = [
+  { name: 'planner', description: 'Break down task into steps', tier: '1-planning' },
+  { name: 'cto', description: 'Define architecture', tier: '1-planning' },
+  { name: 'auth', description: 'Security & authentication review', tier: '3-security' },
+  { name: 'database', description: 'Design schema', tier: '2-implementation' },
+  { name: 'backend', description: 'Implement API', tier: '2-implementation' },
+  { name: 'frontend', description: 'Build UI', tier: '2-implementation' },
+  { name: 'testing', description: 'Write tests', tier: '4-quality' },
+  { name: 'reviewer', description: 'Code review', tier: '4-quality' }
+];
+
+async function runAgent(agent, task, context, previousOutput, provider) {
+  const agentPrompt = await loadAgentPrompt(agent.name);
+  const prompt = `
+${agentPrompt}
+
+## Context
+${context}
+
+## Previous Agent Output
+${previousOutput}
+
+## Task
+${task}
+
+Provide your output for the next agent in the pipeline.
+`;
+
+  // Standardize provider call
+  const response = provider.complete 
+    ? await provider.complete(prompt) 
+    : await provider.generate('', prompt);
+    
+  return typeof response === 'string' 
+    ? response 
+    : (response.content || response.text || JSON.stringify(response));
+}
+
+async function ensureLogDirectory() {
+  const logDir = join(process.cwd(), '.ultra-dex', 'swarm-logs');
+  await mkdir(logDir, { recursive: true });
+  return logDir;
+}
+
+async function writeSwarmLog(logDir, task, results, stats) {
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+  const logPath = join(logDir, `swarm-${timestamp}.json`);
+  const logData = {
+    task,
+    timestamp: new Date().toISOString(),
+    stats,
+    results
+  };
+  await writeFile(logPath, JSON.stringify(logData, null, 2));
+  return logPath;
+}
+
+export async function swarmCommand(task, options) {
+  console.log(chalk.cyan.bold('\n🐝 Ultra-Dex Swarm Mode v3.0\n'));
+  console.log(chalk.white(`Task: "${task}"\n`));
+
+  const startTime = Date.now();
+
+  if (options.dryRun) {
+    console.log(chalk.yellow('Dry run - showing pipeline:\n'));
+    AGENT_PIPELINE.forEach((agent, i) => {
+      console.log(`  ${i + 1}. @${agent.name} - ${agent.description} [${agent.tier}]`);
+    });
+    if (options.parallel) {
+      console.log(chalk.blue('\nℹ️  Parallel execution enabled for 2-implementation tier'));
+    }
+    return;
+  }
+
+  // Load context & Graph (God Mode)
+  const contextPath = join(process.cwd(), 'CONTEXT.md');
+  const planPath = join(process.cwd(), 'IMPLEMENTATION-PLAN.md');
+  
+  let context = '';
+  if (existsSync(contextPath)) {
+    context += await readFile(contextPath, 'utf-8');
+  }
+  if (existsSync(planPath)) {
+    context += '\n\n' + await readFile(planPath, 'utf-8');
+  }
+
+  // Inject Code Graph into Context
+  const spinnerGraph = ora('🧠 Scanning Codebase Graph...').start();
+  try {
+    const graphSummary = await projectGraph.scan();
+    context += `\n\n## Codebase Graph Summary\n- Total Files: ${graphSummary.nodeCount}\n- Total Dependencies: ${graphSummary.edgeCount}\n- Files Analyzed: ${graphSummary.files.join(', ')}\n`;
+    spinnerGraph.succeed('Codebase Graph integrated into context.');
+  } catch (e) {
+    spinnerGraph.warn('Codebase Graph scan failed, proceeding with limited context.');
+  }
+
+  // Get AI provider
+  const provider = getProvider();
+  if (!provider) {
+    console.log(chalk.red('No AI provider configured. Set ANTHROPIC_API_KEY, OPENAI_API_KEY, or GOOGLE_AI_KEY'));
+    return;
+  }
+
+  // Ensure log directory exists
+  const logDir = await ensureLogDirectory();
+
+  // Update State to indicate Swarm is running
+  const state = await loadState() || { project: { mode: 'GOD_MODE' }, agents: { active: [] } };
+  state.agents = state.agents || { active: [] };
+  state.updatedAt = new Date().toISOString();
+  await saveState(state);
+
+  // Run pipeline
+  let previousOutput = '';
+  const agentResults = [];
+  const agentTimings = {};
+  
+  // Define execution tiers (sorted by tier number)
+  const executionTiers = options.parallel 
+    ? [
+        { name: '1-Planning', agents: AGENT_PIPELINE.filter(a => a.tier === '1-planning'), parallel: false },
+        { name: '2-Implementation', agents: AGENT_PIPELINE.filter(a => a.tier === '2-implementation'), parallel: true },
+        { name: '3-Security', agents: AGENT_PIPELINE.filter(a => a.tier === '3-security'), parallel: false },
+        { name: '4-Quality', agents: AGENT_PIPELINE.filter(a => a.tier === '4-quality'), parallel: false }
+      ]
+    : [{ name: 'All', agents: AGENT_PIPELINE, parallel: false }];
+
+  for (const tier of executionTiers) {
+    if (tier.agents.length === 0) continue;
+    
+    if (options.parallel) {
+      console.log(chalk.blue.bold(`\n📦 Tier: ${tier.name}`));
+    }
+
+    if (tier.parallel) {
+      // Parallel Execution for implementation tier
+      const tierStart = Date.now();
+      const promises = tier.agents.map(async (agent) => {
+        const agentStart = Date.now();
+        const spinner = ora(`Running @${agent.name}...`).start();
+        
+        // Update state with active agent
+        const currentState = await loadState();
+        if (currentState) {
+          currentState.agents.active.push(agent.name);
+          await saveState(currentState);
+        }
+
+        try {
+          const result = await runAgent(agent, task, context, previousOutput, provider);
+          const duration = Date.now() - agentStart;
+          agentTimings[agent.name] = duration;
+          spinner.succeed(chalk.green(` @${agent.name} complete`) + chalk.gray(` (${duration}ms)`));
+          
+          // Remove active agent from state
+          const stateDone = await loadState();
+          if (stateDone) {
+            stateDone.agents.active = stateDone.agents.active.filter(a => a !== agent.name);
+            await saveState(stateDone);
+          }
+
+          return { agent: agent.name, result, success: true };
+        } catch (error) {
+          const duration = Date.now() - agentStart;
+          agentTimings[agent.name] = duration;
+          spinner.fail(chalk.red(` @${agent.name} failed: ${error.message}`) + chalk.gray(` (${duration}ms)`));
+          
+          const stateFail = await loadState();
+          if (stateFail) {
+            stateFail.agents.active = stateFail.agents.active.filter(a => a !== agent.name);
+            await saveState(stateFail);
+          }
+
+          return { agent: agent.name, error: error.message, success: false };
+        }
+      });
+
+      const results = await Promise.all(promises);
+      agentResults.push(...results);
+      previousOutput += '\n\n' + results.filter(r => r.success).map(r => r.result).join('\n\n');
+      console.log(chalk.gray(`  Tier completed in ${Date.now() - tierStart}ms`));
+      
+    } else {
+      // Serial Execution
+      for (const agent of tier.agents) {
+        const agentStart = Date.now();
+        const spinner = ora(`Running @${agent.name}...`).start();
+
+        // Update state
+        const currentState = await loadState();
+        if (currentState) {
+          currentState.agents.active.push(agent.name);
+          await saveState(currentState);
+        }
+
+        try {
+          const result = await runAgent(agent, task, context, previousOutput, provider);
+          const duration = Date.now() - agentStart;
+          agentTimings[agent.name] = duration;
+          previousOutput = result;
+          spinner.succeed(chalk.green(` @${agent.name} complete`) + chalk.gray(` (${duration}ms)`));
+          console.log(chalk.gray(`  → ${result.slice(0, 100).replace(/\n/g, ' ')}...`));
+          agentResults.push({ agent: agent.name, result, success: true });
+
+          // Remove active agent
+          const stateDone = await loadState();
+          if (stateDone) {
+            stateDone.agents.active = stateDone.agents.active.filter(a => a !== agent.name);
+            await saveState(stateDone);
+          }
+
+        } catch (error) {
+          const duration = Date.now() - agentStart;
+          agentTimings[agent.name] = duration;
+          spinner.fail(chalk.red(` @${agent.name} failed: ${error.message}`) + chalk.gray(` (${duration}ms)`));
+          agentResults.push({ agent: agent.name, error: error.message, success: false });
+          
+          const stateFail = await loadState();
+          if (stateFail) {
+            stateFail.agents.active = stateFail.agents.active.filter(a => a !== agent.name);
+            await saveState(stateFail);
+          }
+          break;
+        }
+      }
+    }
+  }
+
+  const totalDuration = Date.now() - startTime;
+  const successCount = agentResults.filter(r => r.success).length;
+  const failCount = agentResults.filter(r => !r.success).length;
+
+  // Final state update
+  await updateState();
+
+  // Write log
+  const stats = {
+    totalDuration,
+    agentTimings,
+    successCount,
+    failCount,
+    parallel: options.parallel || false
+  };
+  const logPath = await writeSwarmLog(logDir, task, agentResults, stats);
+
+  // Summary
+  console.log(chalk.cyan.bold('\n📊 Execution Stats:'));
+  console.log(chalk.white(`  Total time: ${totalDuration}ms`));
+  console.log(chalk.green(`  Succeeded: ${successCount}`) + chalk.red(` Failed: ${failCount}`));
+  Object.entries(agentTimings).forEach(([agent, time]) => {
+    console.log(chalk.gray(`  • @${agent}: ${time}ms`));
+  });
+  console.log(chalk.gray(`\n  Log saved: ${logPath}`));
+
+  console.log(chalk.green.bold('\n✅ Swarm complete!\n'));
+}
+
+async function loadAgentPrompt(name) {
+  // Use glob to find agent file recursively
+  const files = await glob(`agents/**/${name}.md`, { ignore: 'node_modules/**' });
+  
+  if (files.length > 0) {
+    return await readFile(files[0], 'utf-8');
+  }
+
+  // Fallback to direct check
+  const directPath = join(process.cwd(), 'agents', `${name}.md`);
+  if (existsSync(directPath)) {
+    return await readFile(directPath, 'utf-8');
+  }
+
+  return `You are the @${name} agent.`;
+}