ultra-dex 2.2.0 → 3.1.0

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) {

package/lib/commands/verify.js

@@ -0,0 +1,81 @@
+/**
+ * ultra-dex verify command
+ * Executable 21-step verification framework
+ */
+
+import chalk from 'chalk';
+import ora from 'ora';
+import { createProvider, getDefaultProvider } from '../providers/index.js';
+import { runAgentLoop } from './run.js';
+import { loadState } from './plan.js';
+import { projectGraph } from '../mcp/graph.js';
+
+const CHECKLIST = [
+  "Atomic Scope Defined", "Context Loaded", "Architecture Alignment", 
+  "Security Patterns Applied", "Type Safety Check", "Error Handling Strategy",
+  "API Documentation Updated", "Database Schema Verified", "Environment Variables Set",
+  "Implementation Complete", "Console Logs Removed", "Edge Cases Handled",
+  "Performance Check", "Accessibility (A11y) Check", "Cross-browser Check",
+  "Unit Tests Passed", "Integration Tests Passed", "Linting & Formatting",
+  "Code Review Approved", "Migration Scripts Ready", "Deployment Readiness"
+];
+
+export async function verifyCommand(taskName, options) {
+  console.log(chalk.cyan.bold('\n⚖️  Ultra-Dex 21-Step Verification\n'));
+  
+  const providerId = options.provider || getDefaultProvider();
+  const provider = createProvider(providerId);
+  const state = await loadState();
+  
+  const spinner = ora(`@Reviewer is verifying: "${taskName || 'Project'}"...`).start();
+
+  try {
+    // 1. Structural Scan
+    await projectGraph.scan();
+    const graphSummary = projectGraph.getSummary();
+
+    // 2. AI Review
+    const projectContext = {
+        state,
+        graph: graphSummary,
+        context: `Task to verify: ${taskName || 'All completed tasks'}`
+    };
+
+    const prompt = `
+Verify the following task against the 21-Step Verification Framework:
+"${taskName || 'Full Project Readiness'}"
+
+The framework consists of:
+${CHECKLIST.map((s, i) => `${i+1}. ${s}`).join('\n')}
+
+Based on the codebase graph and current state, provide a report in this format:
+[ ] Step Name: [PASS/FAIL/SKIP] - Reasoning
+
+Final Verdict: [APPROVED/REJECTED]
+`;
+
+    const report = await runAgentLoop('reviewer', prompt, provider, projectContext);
+    spinner.succeed('Verification complete.');
+
+    console.log(chalk.bold('\n📋 Verification Report:'));
+    console.log(chalk.white(report));
+
+    if (report.includes('REJECTED')) {
+        console.log(chalk.red.bold('\n❌ Task failed verification. Please address the issues above.'));
+        process.exit(1);
+    } else {
+        console.log(chalk.green.bold('\n✅ Task passed verification!'));
+    }
+
+  } catch (e) {
+    spinner.fail(chalk.red(`Verification failed: ${e.message}`));
+  }
+}
+
+export function registerVerifyCommand(program) {
+    program
+      .command('verify [task]')
+      .description('Run executable 21-step verification on a task or project')
+      .option('-p, --provider <provider>', 'AI provider')
+      .action(verifyCommand);
+}

package/lib/commands/watch.js

@@ -0,0 +1,79 @@
+// cli/lib/commands/watch.js
+import chalk from 'chalk';
+import { watch } from 'fs';
+import { join } from 'path';
+import { existsSync } from 'fs';
+import { updateState, computeState } from './state.js';
+
+async function calculateAlignmentScore() {
+  const state = await computeState();
+  return state.score || 0;
+}
+
+export function watchCommand(options) {
+  console.log(chalk.cyan.bold('\n👁️  Ultra-Dex Watch Mode v3.0\n'));
+  console.log(chalk.gray('Watching for file changes...\n'));
+
+  const interval = options.interval ? parseInt(options.interval, 10) : 500;
+  console.log(chalk.gray(`Debounce interval: ${interval}ms`));
+
+  const watchPaths = [
+    'CONTEXT.md',
+    'IMPLEMENTATION-PLAN.md',
+    'src',
+    'app',
+    'lib'
+  ];
+
+  const validPaths = watchPaths.filter(p => {
+    const fullPath = join(process.cwd(), p);
+    return existsSync(fullPath);
+  });
+
+  console.log(chalk.gray(`Watching: ${validPaths.join(', ')}\n`));
+
+  let debounceTimer = null;
+  let lastScore = null;
+
+  // Initial score display
+  calculateAlignmentScore().then(score => {
+    lastScore = score;
+    console.log(chalk.blue(`📊 Initial alignment score: ${score}%\n`));
+  });
+
+  validPaths.forEach(path => {
+    const fullPath = join(process.cwd(), path);
+    try {
+      watch(fullPath, { recursive: true }, (eventType, filename) => {
+        if (debounceTimer) clearTimeout(debounceTimer);
+        debounceTimer = setTimeout(async () => {
+          const timestamp = new Date().toLocaleTimeString();
+          console.log(chalk.yellow(`\n[${timestamp}] 📝 ${filename || path} changed`));
+          
+          await updateState();
+          
+          const newScore = await calculateAlignmentScore();
+          const scoreDiff = lastScore !== null ? newScore - lastScore : 0;
+          const diffIndicator = scoreDiff > 0 
+            ? chalk.green(`↑ +${scoreDiff}`) 
+            : scoreDiff < 0 
+              ? chalk.red(`↓ ${scoreDiff}`) 
+              : chalk.gray('→ 0');
+          
+          lastScore = newScore;
+          
+          const scoreColor = newScore >= 80 ? 'green' : newScore >= 50 ? 'yellow' : 'red';
+          console.log(chalk[scoreColor](`✅ State updated | Alignment: ${newScore}% ${diffIndicator}`));
+          
+        }, interval);
+      });
+    } catch (e) {
+      console.log(chalk.gray(`  ⚠️  Cannot watch ${path}: ${e.message}`));
+    }
+  });
+
+  console.log(chalk.gray('\nPress Ctrl+C to stop'));
+  
+  // Keep process running
+  process.stdin.resume();
+}

package/lib/mcp/graph.js

@@ -0,0 +1,92 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { glob } from 'glob';
+
+export class CodeGraph {
+  constructor() {
+    this.nodes = new Map(); // file path -> node info
+    this.edges = []; // { from, to, type }
+  }
+
+  async scan() {
+    this.nodes.clear();
+    this.edges = [];
+    
+    // Find all js/ts/jsx/tsx files
+    // Ignoring node_modules, .git, dist, build
+    const files = await glob('**/*.{js,ts,jsx,tsx}', {
+      ignore: ['node_modules/**', '.git/**', 'dist/**', 'build/**', '.next/**'],
+      absolute: false,
+      cwd: process.cwd()
+    });
+
+    for (const file of files) {
+      await this.analyzeFile(file);
+    }
+
+    return this.getSummary();
+  }
+
+  async analyzeFile(filePath) {
+    try {
+      const content = await fs.readFile(path.resolve(process.cwd(), filePath), 'utf8');
+      
+      // Basic Node Info
+      this.nodes.set(filePath, {
+        id: filePath,
+        size: content.length,
+        type: path.extname(filePath).substring(1),
+        // Simple heuristic for "component" vs "utility"
+        isComponent: /^[A-Z]/.test(path.basename(filePath)) || content.includes('React') || content.includes('Component'),
+      });
+
+      // Extract Imports (Regex based for speed/simplicity without AST parsing overhead)
+      const importRegex = /import\s+(?:[\w\s{},*]+)\s+from\s+['"]([^'"]+)['"]/g;
+      let match;
+      
+      while ((match = importRegex.exec(content)) !== null) {
+        const importPath = match[1];
+        
+        // Resolve relative imports
+        if (importPath.startsWith('.')) {
+          const absoluteDir = path.dirname(path.resolve(process.cwd(), filePath));
+          const resolvedAbs = path.resolve(absoluteDir, importPath);
+          const relativeResolved = path.relative(process.cwd(), resolvedAbs);
+          
+          // Add edge
+          this.edges.push({
+            from: filePath,
+            to: relativeResolved, // Note: This might not match exactly if extensions are missing, but good enough for rough graph
+            type: 'depends_on'
+          });
+        } else {
+          // Package import
+          this.edges.push({
+            from: filePath,
+            to: importPath,
+            type: 'package_dependency'
+          });
+        }
+      }
+
+    } catch (e) {
+      console.error(`Failed to analyze ${filePath}:`, e);
+    }
+  }
+
+  getSummary() {
+    return {
+      nodeCount: this.nodes.size,
+      edgeCount: this.edges.length,
+      files: Array.from(this.nodes.keys()),
+      dependencies: this.edges
+    };
+  }
+
+  findRefereces(fileName) {
+    return this.edges.filter(e => e.to.includes(fileName));
+  }
+}
+
+// Singleton instance
+export const projectGraph = new CodeGraph();

package/lib/mcp/memory.js

@@ -0,0 +1,95 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { existsSync } from 'fs';
+
+const MEMORY_DIR = '.ultra';
+const MEMORY_FILE = 'memory.json';
+const MEMORY_PATH = path.resolve(process.cwd(), MEMORY_DIR, MEMORY_FILE);
+
+/**
+ * Ultra-Dex Persistent Memory System
+ * Stores facts, snippets, and context across sessions.
+ */
+export class UltraMemory {
+  constructor() {
+    this.memory = [];
+    this.initialized = false;
+  }
+
+  async init() {
+    if (this.initialized) return;
+    
+    try {
+      if (!existsSync(path.dirname(MEMORY_PATH))) {
+        await fs.mkdir(path.dirname(MEMORY_PATH), { recursive: true });
+      }
+
+      if (existsSync(MEMORY_PATH)) {
+        const data = await fs.readFile(MEMORY_PATH, 'utf-8');
+        this.memory = JSON.parse(data);
+      } else {
+        this.memory = [];
+        await this.saveToFile();
+      }
+      this.initialized = true;
+    } catch (error) {
+      console.error('Failed to initialize memory:', error);
+      this.memory = [];
+    }
+  }
+
+  async saveToFile() {
+    try {
+      await fs.writeFile(MEMORY_PATH, JSON.stringify(this.memory, null, 2));
+    } catch (error) {
+      console.error('Failed to save memory to file:', error);
+    }
+  }
+
+  async remember(text, tags = [], source = 'manual') {
+    await this.init();
+    const entry = {
+      id: crypto.randomUUID(),
+      text,
+      tags,
+      source,
+      timestamp: new Date().toISOString()
+    };
+    this.memory.push(entry);
+    await this.saveToFile();
+    return entry;
+  }
+
+  async search(query, limit = 5) {
+    await this.init();
+    const lowerQuery = query.toLowerCase();
+    
+    // Simple keyword search for now
+    // Future: Vector search / Semantic search
+    return this.memory
+      .filter(entry => 
+        entry.text.toLowerCase().includes(lowerQuery) || 
+        entry.tags.some(t => t.toLowerCase().includes(lowerQuery))
+      )
+      .sort((a, b) => new Date(b.timestamp) - new Date(a.timestamp))
+      .slice(0, limit);
+  }
+
+  async clear(beforeDate = null) {
+    await this.init();
+    if (beforeDate) {
+      const date = new Date(beforeDate);
+      this.memory = this.memory.filter(entry => new Date(entry.timestamp) >= date);
+    } else {
+      this.memory = [];
+    }
+    await this.saveToFile();
+  }
+
+  async getAll() {
+    await this.init();
+    return this.memory;
+  }
+}
+
+export const ultraMemory = new UltraMemory();