ultra-dex 2.2.1 → 3.2.0

package/lib/commands/sync.js

@@ -1,35 +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('Auto-sync CONTEXT.md with current codebase')
-    .option('-d, --dir <directory>', 'Project directory', '.')
+    .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) => {
-      const rootDir = path.resolve(options.dir);
-      console.log(chalk.cyan('\n🔁 Ultra-Dex Context Sync\n'));
-
-      try {
-        const result = await snapshotContext(rootDir);
-        if (result.missingContext) {
-          console.log(chalk.red('❌ CONTEXT.md not found. Run `ultra-dex init` first.'));
-          process.exit(1);
-        }
-
-        if (result.updated) {
-          console.log(chalk.green('✅ CONTEXT.md updated with latest snapshot.'));
-        } else {
-          console.log(chalk.yellow('⚠️  CONTEXT.md already up to date.'));
-        }
-        console.log(chalk.gray(`Files scanned: ${result.summary.fileCount}`));
-        console.log(chalk.gray(`Stack guess: ${result.summary.stack}`));
-        console.log(chalk.gray(`Changes since last sync: +${result.diff.added} / -${result.diff.removed}\n`));
-      } catch (error) {
-        console.log(chalk.red('❌ Sync failed.'));
-        console.error(error);
+      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());
+}

package/lib/commands/upgrade.js

@@ -0,0 +1,190 @@
+// cli/lib/commands/upgrade.js
+import chalk from 'chalk';
+import ora from 'ora';
+import { execSync } from 'child_process';
+import { readFileSync, existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+export async function upgradeCommand(options) {
+  console.log(chalk.cyan.bold('\n⬆️  Ultra-Dex Upgrade Check\n'));
+
+  // Get local version from package.json
+  const localVersion = getLocalVersion();
+  
+  const spinner = ora('Checking npm registry...').start();
+  
+  try {
+    // Query npm registry for latest version
+    const latestVersion = await getLatestVersion();
+    spinner.succeed('Registry check complete');
+    
+    console.log(chalk.gray('─'.repeat(50)));
+    console.log(`  ${chalk.gray('Installed:')}  ${chalk.white(localVersion)}`);
+    console.log(`  ${chalk.gray('Latest:')}     ${chalk.cyan(latestVersion)}`);
+    console.log(chalk.gray('─'.repeat(50)));
+    
+    const comparison = compareVersions(localVersion, latestVersion);
+    
+    if (comparison < 0) {
+      // Update available
+      console.log(chalk.yellow.bold('\n  📦 Update available!\n'));
+      
+      // Show version diff summary
+      const [localMajor, localMinor] = localVersion.split('.').map(Number);
+      const [latestMajor, latestMinor] = latestVersion.split('.').map(Number);
+      
+      if (latestMajor > localMajor) {
+        console.log(chalk.red('  ⚠️  Major version update - may contain breaking changes'));
+      } else if (latestMinor > localMinor) {
+        console.log(chalk.yellow('  ✨ Minor version update - new features available'));
+      } else {
+        console.log(chalk.green('  🔧 Patch update - bug fixes and improvements'));
+      }
+      
+      // Try to fetch changelog
+      if (!options.check) {
+        const changelogSpinner = ora('Fetching changelog...').start();
+        try {
+          const changelog = await fetchChangelog(localVersion, latestVersion);
+          if (changelog) {
+            changelogSpinner.succeed('Changelog retrieved');
+            console.log(chalk.bold('\n  📋 What\'s New:\n'));
+            console.log(chalk.gray(indent(changelog, 4)));
+          } else {
+            changelogSpinner.info('No changelog available');
+          }
+        } catch {
+          changelogSpinner.info('Could not fetch changelog');
+        }
+      }
+      
+      // Show install instructions or run update
+      console.log('');
+      if (options.install) {
+        const installSpinner = ora('Installing update...').start();
+        try {
+          execSync('npm update -g ultra-dex', { encoding: 'utf-8', stdio: 'pipe' });
+          installSpinner.succeed(chalk.green(`Updated to v${latestVersion}`));
+          console.log(chalk.gray('\n  Run `ultra-dex --version` to verify.\n'));
+        } catch (e) {
+          installSpinner.fail('Installation failed');
+          console.log(chalk.red(`  ${e.message}`));
+          console.log(chalk.gray('\n  Try running manually:'));
+          console.log(chalk.white('    npm install -g ultra-dex@latest\n'));
+        }
+      } else if (!options.check) {
+        console.log(chalk.gray('  To upgrade, run:'));
+        console.log(chalk.white('    npm install -g ultra-dex@latest'));
+        console.log(chalk.gray('  Or use:'));
+        console.log(chalk.white('    ultra-dex upgrade --install\n'));
+      } else {
+        console.log(chalk.gray('  Check complete. Use --install to update.\n'));
+      }
+      
+    } else if (comparison === 0) {
+      // Up to date
+      console.log(chalk.green.bold('\n  ✅ You are running the latest version!\n'));
+    } else {
+      // Local is newer (dev/beta)
+      console.log(chalk.blue.bold('\n  🔬 You are running a development/pre-release version\n'));
+    }
+    
+  } catch (e) {
+    spinner.warn('Could not reach npm registry');
+    console.log(chalk.gray(`  Current version: ${localVersion}`));
+    console.log(chalk.yellow(`\n  ${e.message}`));
+    console.log(chalk.gray('\n  Check your network connection and try again.\n'));
+  }
+}
+
+function getLocalVersion() {
+  try {
+    // Try to get from the CLI's package.json
+    const pkgPath = join(__dirname, '..', '..', 'package.json');
+    if (existsSync(pkgPath)) {
+      const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+      return pkg.version;
+    }
+  } catch { /* fall through */ }
+  
+  // Fallback to hardcoded version
+  return '3.0.0';
+}
+
+async function getLatestVersion() {
+  return new Promise((resolve, reject) => {
+    try {
+      const output = execSync('npm view ultra-dex version 2>/dev/null', { 
+        encoding: 'utf-8',
+        timeout: 10000
+      }).trim();
+      
+      if (output && /^\d+\.\d+\.\d+/.test(output)) {
+        resolve(output);
+      } else {
+        reject(new Error('Invalid version format from registry'));
+      }
+    } catch (e) {
+      // Package might not be published yet
+      reject(new Error('Package not found in npm registry (may not be published yet)'));
+    }
+  });
+}
+
+function compareVersions(v1, v2) {
+  const parts1 = v1.split('.').map(Number);
+  const parts2 = v2.split('.').map(Number);
+  
+  for (let i = 0; i < 3; i++) {
+    const a = parts1[i] || 0;
+    const b = parts2[i] || 0;
+    if (a < b) return -1;
+    if (a > b) return 1;
+  }
+  return 0;
+}
+
+async function fetchChangelog(fromVersion, toVersion) {
+  try {
+    // Try to fetch from GitHub releases API
+    const output = execSync(
+      `curl -s "https://api.github.com/repos/Srujan0798/Ultra-Dex/releases" | head -c 5000`,
+      { encoding: 'utf-8', timeout: 10000 }
+    );
+    
+    const releases = JSON.parse(output);
+    if (!Array.isArray(releases) || releases.length === 0) {
+      return null;
+    }
+    
+    // Get release notes between versions
+    const changelog = [];
+    for (const release of releases.slice(0, 5)) {
+      const releaseVersion = release.tag_name?.replace(/^v/, '') || '';
+      if (compareVersions(releaseVersion, fromVersion) > 0 && 
+          compareVersions(releaseVersion, toVersion) <= 0) {
+        changelog.push(`v${releaseVersion}:`);
+        // Extract first few bullet points from body
+        const body = release.body || '';
+        const lines = body.split('\n')
+          .filter(line => line.trim().startsWith('-') || line.trim().startsWith('*'))
+          .slice(0, 5)
+          .map(line => '  ' + line.trim());
+        changelog.push(...lines);
+        changelog.push('');
+      }
+    }
+    
+    return changelog.length > 0 ? changelog.join('\n') : null;
+  } catch {
+    return null;
+  }
+}
+
+function indent(text, spaces) {
+  const prefix = ' '.repeat(spaces);
+  return text.split('\n').map(line => prefix + line).join('\n');
+}

package/lib/commands/validate.js

@@ -2,12 +2,14 @@ import chalk from 'chalk';
 import fs from 'fs/promises';
 import path from 'path';
 import { validateSafePath } from '../utils/validation.js';
+import { runQualityScan } from '../quality/scanner.js';
 
 export function registerValidateCommand(program) {
   program
     .command('validate')
     .description('Validate project structure against Ultra-Dex standards')
     .option('-d, --dir <directory>', 'Project directory to validate', '.')
+    .option('--scan', 'Run deep code quality scan')
     .action(async (options) => {
       console.log(chalk.cyan('\n✅ Ultra-Dex Structure Validator\n'));
 
@@ -114,6 +116,34 @@ export function registerValidateCommand(program) {
         console.log(chalk.gray('  ⊘  Could not validate IMPLEMENTATION-PLAN.md content'));
       }
 
+      // Deep Code Scan
+      if (options.scan) {
+        console.log(chalk.bold('\nRunning Deep Code Scan (Active State Tracking)...\n'));
+        const scanResults = await runQualityScan(projectDir);
+        
+        if (scanResults.failed > 0) {
+          failed += scanResults.failed;
+          console.log(chalk.red(`  ❌ Code Scan Failed: ${scanResults.failed} critical issues found.`));
+        } else {
+          passed++;
+          console.log(chalk.green(`  ✅ Code Scan Passed (${scanResults.filesScanned} files scanned).`));
+        }
+
+        if (scanResults.warnings > 0) {
+          console.log(chalk.yellow(`  ⚠️  ${scanResults.warnings} code warnings found.`));
+        }
+
+        if (scanResults.details.length > 0) {
+          console.log(chalk.gray('\n  Scan Details:'));
+          scanResults.details.forEach(issue => {
+            const icon = issue.severity === 'error' || issue.severity === 'critical' ? '❌' : '⚠️';
+            console.log(`    ${icon} [${issue.ruleName}] ${issue.file}: ${issue.message}`);
+          });
+        }
+      } else {
+        console.log(chalk.gray('\nℹ️  Run with --scan to enable Deep Code Quality Scan.'));
+      }
+
       console.log('\n' + chalk.bold('─'.repeat(50)));
       console.log(chalk.bold('\nValidation Summary:\n'));
       console.log(chalk.green(`  ✅ Passed: ${passed}`));
@@ -126,6 +156,10 @@ export function registerValidateCommand(program) {
       } else {
         console.log(chalk.bold.yellow('\n⚠️  VALIDATION INCOMPLETE\n'));
         console.log(chalk.gray('Fix required files to meet Ultra-Dex standards.'));
+        if (options.scan && failed > 0) {
+           console.log(chalk.red('Code quality gates failed. Commit rejected (if in pre-commit).'));
+        }
+        process.exit(1);
       }
 
       if (warnings.length > 0) {