ultra-dex 2.2.0 → 3.1.0

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.`;
+}

package/lib/commands/sync.js

@@ -0,0 +1,94 @@
+/**
+ * ultra-dex sync command
+ * Synchronizes project state and graph across devices
+ */
+
+import chalk from 'chalk';
+import fs from 'fs/promises';
+import path from 'path';
+import { loadState, saveState } from './state.js';
+import { buildGraph } from '../utils/graph.js';
+import { snapshotContext } from '../utils/sync.js';
+import { validateSafePath } from '../utils/validation.js';
+
+export function registerSyncCommand(program) {
+  program
+    .command('sync')
+    .description('Synchronize project state and graph (God Mode Sync)')
+    .option('-d, --dir <directory>', 'Project directory to sync', '.')
+    .option('--push', 'Push local state to sync target')
+    .option('--pull', 'Pull state from sync target')
+    .option('--target <path>', 'Sync target (local folder or s3-like)', '.ultra/sync')
+    .action(async (options) => {
+      console.log(chalk.cyan('\n🔄 Ultra-Dex State Sync\n'));
+
+      const dirValidation = validateSafePath(options.dir, 'Project directory');
+      if (dirValidation !== true) {
+        console.log(chalk.red(dirValidation));
+        process.exit(1);
+      }
+
+      const projectDir = path.resolve(options.dir);
+
+      // 1. Snapshot Context (Updates CONTEXT.md)
+      const syncResult = await snapshotContext(projectDir);
+      console.log(chalk.green(`  ✅ Context Snapshot Complete (${syncResult.summary.fileCount} Files scanned)`));
+      if (syncResult.updated) {
+        console.log(chalk.gray('     CONTEXT.md updated with latest project structure.'));
+      }
+
+      const syncTarget = path.resolve(projectDir, options.target);
+      await fs.mkdir(syncTarget, { recursive: true });
+
+      if (options.push) {
+        await handlePush(projectDir, syncTarget);
+      } else if (options.pull) {
+        await handlePull(projectDir, syncTarget);
+      } else {
+        // Default: Bidirectional Sync (Simplified for Phase 2.1)
+        console.log(chalk.yellow('\nDefaulting to PUSH local state to target.'));
+        await handlePush(projectDir, syncTarget);
+      }
+    });
+}
+
+async function handlePush(projectDir, target) {
+  const spinner = (await import('ora')).default('Pushing state to sync target...').start();
+  try {
+    // Note: loadState/saveState might need to be aware of projectDir if they use relative paths
+    // For now they use process.cwd() which might be wrong if --dir is used.
+    // However, let's keep it simple as most commands assume CWD = project root unless --dir is used.
+    
+    const state = await loadState();
+    if (!state) throw new Error('No local state found');
+
+    const graph = await buildGraph();
+    
+    const bundle = {
+      state,
+      graph,
+      timestamp: new Date().toISOString(),
+      machine: process.env.USER || 'unknown'
+    };
+
+    await fs.writeFile(path.join(target, 'sync-bundle.json'), JSON.stringify(bundle, null, 2));
+    spinner.succeed(chalk.green(`State pushed to ${target}`));
+  } catch (e) {
+    spinner.fail(chalk.red(`Push failed: ${e.message}`));
+  }
+}
+
+async function handlePull(projectDir, target) {
+  const spinner = (await import('ora')).default('Pulling state from sync target...').start();
+  try {
+    const bundleContent = await fs.readFile(path.join(target, 'sync-bundle.json'), 'utf8');
+    const bundle = JSON.parse(bundleContent);
+
+    await saveState(bundle.state);
+    spinner.succeed(chalk.green('Local state updated from sync bundle.'));
+    console.log(chalk.gray(`   Bundle Timestamp: ${bundle.timestamp}`));
+    console.log(chalk.gray(`   Source Machine: ${bundle.machine}`));
+  } catch (e) {
+    spinner.fail(chalk.red(`Pull failed: ${e.message}`));
+  }
+}

package/lib/commands/team.js

@@ -0,0 +1,275 @@
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import fs from 'fs/promises';
+import path from 'path';
+import { Command } from 'commander';
+
+const TEAM_DIR = '.ultra-dex';
+const TEAM_FILE = 'team.json';
+const TEAM_PATH = path.resolve(process.cwd(), TEAM_DIR, TEAM_FILE);
+const VALID_ROLES = ['admin', 'member', 'viewer'];
+const EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+
+function normalizeEmail(email) {
+  return email.trim().toLowerCase();
+}
+
+function isValidEmail(email) {
+  return EMAIL_REGEX.test(email);
+}
+
+async function loadTeamConfig() {
+  try {
+    const content = await fs.readFile(TEAM_PATH, 'utf8');
+    return JSON.parse(content);
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      return null;
+    }
+    throw error;
+  }
+}
+
+async function saveTeamConfig(config) {
+  const dir = path.resolve(process.cwd(), TEAM_DIR);
+  await fs.mkdir(dir, { recursive: true });
+  await fs.writeFile(TEAM_PATH, JSON.stringify(config, null, 2));
+}
+
+function requireTeamConfig(team) {
+  if (!team) {
+    console.log(chalk.red('\n❌ Team not initialized. Run "ultra-dex team init" first.\n'));
+    process.exit(1);
+  }
+}
+
+function formatTable(rows) {
+  const headers = ['Email', 'Role', 'Added'];
+  const widths = headers.map((header, index) => {
+    const maxRow = rows.reduce((max, row) => Math.max(max, row[index].length), header.length);
+    return Math.max(header.length, maxRow);
+  });
+
+  const headerLine = headers
+    .map((header, index) => header.padEnd(widths[index]))
+    .join(' | ');
+  const divider = widths.map((width) => '-'.repeat(width)).join('-|-');
+
+  const body = rows
+    .map((row) => row.map((cell, index) => cell.padEnd(widths[index])).join(' | '))
+    .join('\n');
+
+  return `${headerLine}\n${divider}\n${body}`;
+}
+
+function buildInitCommand() {
+  const command = new Command('init');
+  command
+    .description('Initialize team configuration')
+    .action(async () => {
+      const existing = await loadTeamConfig();
+      if (existing) {
+        const { overwrite } = await inquirer.prompt([
+          {
+            type: 'confirm',
+            name: 'overwrite',
+            message: 'Team config already exists. Overwrite it?',
+            default: false,
+          },
+        ]);
+        if (!overwrite) {
+          console.log(chalk.yellow('\nCanceled.\n'));
+          return;
+        }
+      }
+
+      const answers = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'name',
+          message: 'Team name:',
+          validate: (input) => (input.trim().length > 0 ? true : 'Team name is required'),
+        },
+        {
+          type: 'input',
+          name: 'description',
+          message: 'Team description:',
+          default: '',
+        },
+      ]);
+
+      const config = {
+        name: answers.name.trim(),
+        description: answers.description.trim(),
+        members: [],
+        createdAt: new Date().toISOString(),
+      };
+
+      await saveTeamConfig(config);
+      console.log(chalk.green('\n✅ Team config created at .ultra-dex/team.json\n'));
+    });
+
+  return command;
+}
+
+function buildAddCommand() {
+  const command = new Command('add');
+  command
+    .description('Add a team member')
+    .argument('<email>', 'Member email')
+    .option('-r, --role <role>', 'Role (admin|member|viewer)', 'member')
+    .action(async (email, options) => {
+      const normalizedEmail = normalizeEmail(email);
+      if (!isValidEmail(normalizedEmail)) {
+        console.log(chalk.red('\n❌ Invalid email format.\n'));
+        process.exit(1);
+      }
+
+      const role = options.role?.toLowerCase() || 'member';
+      if (!VALID_ROLES.includes(role)) {
+        console.log(chalk.red(`\n❌ Invalid role. Use one of: ${VALID_ROLES.join(', ')}.\n`));
+        process.exit(1);
+      }
+
+      const team = await loadTeamConfig();
+      requireTeamConfig(team);
+
+      const exists = team.members.some((member) => normalizeEmail(member.email) === normalizedEmail);
+      if (exists) {
+        console.log(chalk.yellow(`\n⚠️  ${normalizedEmail} is already on the team.\n`));
+        process.exit(1);
+      }
+
+      team.members.push({
+        email: normalizedEmail,
+        role,
+        addedAt: new Date().toISOString(),
+      });
+
+      await saveTeamConfig(team);
+      console.log(chalk.green(`\n✅ Added ${normalizedEmail} as ${role}.\n`));
+    });
+
+  return command;
+}
+
+function buildListCommand() {
+  const command = new Command('list');
+  command
+    .description('List team members')
+    .action(async () => {
+      const team = await loadTeamConfig();
+      requireTeamConfig(team);
+
+      if (!team.members.length) {
+        console.log(chalk.yellow('\nNo team members yet.\n'));
+        return;
+      }
+
+      const rows = team.members.map((member) => [
+        member.email,
+        member.role,
+        member.addedAt,
+      ]);
+
+      console.log('\n' + chalk.bold('Team Members'));
+      console.log(formatTable(rows));
+      console.log('');
+    });
+
+  return command;
+}
+
+function buildRemoveCommand() {
+  const command = new Command('remove');
+  command
+    .description('Remove a team member')
+    .argument('<email>', 'Member email')
+    .action(async (email) => {
+      const normalizedEmail = normalizeEmail(email);
+      if (!isValidEmail(normalizedEmail)) {
+        console.log(chalk.red('\n❌ Invalid email format.\n'));
+        process.exit(1);
+      }
+
+      const team = await loadTeamConfig();
+      requireTeamConfig(team);
+
+      const index = team.members.findIndex((member) => normalizeEmail(member.email) === normalizedEmail);
+      if (index === -1) {
+        console.log(chalk.red(`\n❌ ${normalizedEmail} not found in team.\n`));
+        process.exit(1);
+      }
+
+      const { confirm } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'confirm',
+          message: `Remove ${normalizedEmail} from the team?`,
+          default: false,
+        },
+      ]);
+
+      if (!confirm) {
+        console.log(chalk.yellow('\nCanceled.\n'));
+        return;
+      }
+
+      team.members.splice(index, 1);
+      await saveTeamConfig(team);
+      console.log(chalk.green(`\n✅ Removed ${normalizedEmail}.\n`));
+    });
+
+  return command;
+}
+
+function buildConfigCommand() {
+  const command = new Command('config');
+  command
+    .description('Show or update team settings')
+    .argument('[key]', 'Setting key (name, description)')
+    .argument('[value]', 'Setting value')
+    .action(async (key, value) => {
+      const team = await loadTeamConfig();
+      requireTeamConfig(team);
+
+      const validKeys = ['name', 'description'];
+      if (!key) {
+        console.log(chalk.bold('\nTeam Settings\n'));
+        console.log(chalk.gray(`Name: ${team.name || '-'}`));
+        console.log(chalk.gray(`Description: ${team.description || '-'}`));
+        console.log(chalk.gray(`Created: ${team.createdAt || '-'}`));
+        console.log(chalk.gray(`Members: ${team.members.length}`));
+        console.log('');
+        return;
+      }
+
+      if (!validKeys.includes(key)) {
+        console.log(chalk.red(`\n❌ Invalid key. Use: ${validKeys.join(', ')}.\n`));
+        process.exit(1);
+      }
+
+      if (value === undefined) {
+        console.log(chalk.gray(`\n${key}: ${team[key] || '-'}\n`));
+        return;
+      }
+
+      team[key] = value.trim();
+      await saveTeamConfig(team);
+      console.log(chalk.green(`\n✅ Updated ${key}.\n`));
+    });
+
+  return command;
+}
+
+export function registerTeamCommand(program) {
+  const team = program
+    .command('team')
+    .description('Team collaboration');
+
+  team.addCommand(buildInitCommand());
+  team.addCommand(buildAddCommand());
+  team.addCommand(buildListCommand());
+  team.addCommand(buildRemoveCommand());
+  team.addCommand(buildConfigCommand());
+}