ultra-dex 2.2.1 → 3.1.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();

package/lib/mcp/resources.js

@@ -0,0 +1,152 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { loadState, generateMarkdown } from '../commands/plan.js';
+import { projectGraph } from './graph.js';
+
+export function registerResources(server) {
+  // Resource: Graph Summary
+  server.resource(
+    "graph",
+    "ultradex://graph/summary",
+    async (uri) => {
+      if (projectGraph.nodes.size === 0) {
+        await projectGraph.scan();
+      }
+      return {
+        contents: [{
+          uri: uri.href,
+          text: JSON.stringify(projectGraph.getSummary(), null, 2)
+        }]
+      };
+    }
+  );
+
+  // Resource: Project Context
+  server.resource(
+    "context",
+    "ultradex://context",
+    async (uri) => {
+      try {
+        const content = await fs.readFile(path.resolve(process.cwd(), 'CONTEXT.md'), 'utf8');
+        return {
+          contents: [{
+            uri: uri.href,
+            text: content
+          }]
+        };
+      } catch (error) {
+        return {
+          contents: [{
+            uri: uri.href,
+            text: "_No CONTEXT.md found. Run `ultra-dex init` to create one._"
+          }]
+        };
+      }
+    }
+  );
+
+  // Resource: Implementation Plan
+  server.resource(
+    "plan",
+    "ultradex://plan",
+    async (uri) => {
+      try {
+        // Try to load state first for dynamic plan
+        const state = await loadState();
+        let content = "";
+        if (state) {
+          content = generateMarkdown(state);
+        } else {
+          // Fallback to file
+          content = await fs.readFile(path.resolve(process.cwd(), 'IMPLEMENTATION-PLAN.md'), 'utf8');
+        }
+        return {
+          contents: [{
+            uri: uri.href,
+            text: content
+          }]
+        };
+      } catch (error) {
+        return {
+          contents: [{
+            uri: uri.href,
+            text: "_No IMPLEMENTATION-PLAN.md found._"
+          }]
+        };
+      }
+    }
+  );
+
+  // Resource: Agents Index
+  server.resource(
+    "agents",
+    "ultradex://agents",
+    async (uri) => {
+      try {
+        const content = await fs.readFile(path.resolve(process.cwd(), 'agents/00-AGENT_INDEX.md'), 'utf8');
+        return {
+          contents: [{
+            uri: uri.href,
+            text: content
+          }]
+        };
+      } catch (error) {
+        return {
+          contents: [{
+            uri: uri.href,
+            text: "_No agent index found._"
+          }]
+        };
+      }
+    }
+  );
+
+  // Resource: Machine State
+  server.resource(
+    "state",
+    "ultradex://state",
+    async (uri) => {
+      try {
+        const state = await loadState();
+        return {
+          contents: [{
+            uri: uri.href,
+            text: JSON.stringify(state, null, 2)
+          }]
+        };
+      } catch (error) {
+        return {
+          contents: [{
+            uri: uri.href,
+            text: JSON.stringify({ error: "No state found" })
+          }]
+        };
+      }
+    }
+  );
+
+  // Resource: Code Property Graph (GOD MODE)
+  server.resource(
+    "graph",
+    "ultradex://graph",
+    async (uri) => {
+      try {
+        const { buildGraph } = await import('../utils/graph.js');
+        const graph = await buildGraph();
+        return {
+          contents: [{
+            uri: uri.href,
+            text: JSON.stringify(graph, null, 2)
+          }]
+        };
+      } catch (error) {
+        return {
+          contents: [{
+            uri: uri.href,
+            text: JSON.stringify({ error: `Graph build failed: ${error.message}` })
+          }]
+        };
+      }
+    }
+  );
+}

package/lib/mcp/server.js

@@ -0,0 +1,34 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { registerResources } from "./resources.js";
+import { registerTools } from "./tools.js";
+import { projectGraph } from "./graph.js";
+
+export async function startMcpServer() {
+  // Initialize Graph
+  console.error("Initializing Ultra-Dex Active Kernel...");
+  try {
+    await projectGraph.scan();
+    console.error(`Graph loaded: ${projectGraph.nodes.size} nodes, ${projectGraph.edges.length} edges.`);
+  } catch (e) {
+    console.error("Graph initialization warning:", e.message);
+  }
+
+  // Create server instance
+  const server = new McpServer({
+    name: "Ultra-Dex Active Kernel",
+    version: "2.2.0"
+  });
+
+  // Register features
+  registerResources(server);
+  registerTools(server);
+
+  // Connect transport
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  
+  // Note: Stdio transport takes over stdin/stdout, so no logging to console.log here!
+  // Any logging must go to stderr
+  console.error("Ultra-Dex MCP Server running on Stdio...");
+}