ultra-dex 2.2.0 → 2.2.1

package/lib/commands/agents.js

@@ -3,6 +3,7 @@ import fs from 'fs/promises';
 import path from 'path';
 import { ASSETS_ROOT, ROOT_FALLBACK } from '../config/paths.js';
 import { githubBlobUrl } from '../config/urls.js';
+import { readWithFallback } from '../utils/fallback.js';
 
 export const AGENTS = [
   { name: 'cto', description: 'Architecture & tech decisions', file: '1-leadership/cto.md', tier: 'Leadership' },
@@ -24,12 +25,8 @@ export const AGENTS = [
 
 async function readAgentPrompt(agent) {
   const agentPath = path.join(ASSETS_ROOT, 'agents', agent.file);
-  try {
-    return await fs.readFile(agentPath, 'utf-8');
-  } catch (err) {
-    const fallbackPath = path.join(ROOT_FALLBACK, 'agents', agent.file);
-    return await fs.readFile(fallbackPath, 'utf-8');
-  }
+  const fallbackPath = path.join(ROOT_FALLBACK, 'agents', agent.file);
+  return readWithFallback(agentPath, fallbackPath, 'utf-8');
 }
 
 export function registerAgentsCommand(program) {

package/lib/commands/init.js

@@ -207,12 +207,10 @@ ${answers.ideaWhat} for ${answers.ideaFor}.
           const cursorRulesPath = path.join(ASSETS_ROOT, 'cursor-rules');
           const fallbackRulesPath = path.join(ROOT_FALLBACK, 'cursor-rules');
           try {
-            const ruleFiles = await listWithFallback(cursorRulesPath, fallbackRulesPath);
-            const sourcePath = ruleFiles ? cursorRulesPath : fallbackRulesPath;
+            const { files: ruleFiles, sourcePath } = await listWithFallback(cursorRulesPath, fallbackRulesPath);
             for (const file of ruleFiles.filter(f => f.endsWith('.mdc'))) {
-              await copyWithFallback(
+              await fs.copyFile(
                 path.join(sourcePath, file),
-                null,
                 path.join(rulesDir, file)
               );
             }
@@ -330,7 +328,7 @@ ${answers.ideaWhat} for ${answers.ideaFor}.
         console.log(chalk.blue(`  ${githubWebUrl()}`));
       } catch (error) {
         spinner.fail(chalk.red('Failed to create project'));
-        console.error(error);
+        console.error(`[init] ${error?.message ?? error}`);
         process.exit(1);
       }
     });

package/lib/commands/serve.js

@@ -1,17 +1,69 @@
 import chalk from 'chalk';
-import fs from 'fs/promises';
 import http from 'http';
-import { validateSafePath } from '../utils/validation.js';
+import fs from 'fs/promises';
+import path from 'path';
+import { readFileSafe } from '../utils/files.js';
 
-async function readFileSafe(filePath, label) {
+// State management helpers
+async function loadState() {
   try {
-    const content = await fs.readFile(filePath, 'utf-8');
-    return { label, content };
+    const content = await fs.readFile(path.resolve(process.cwd(), '.ultra/state.json'), 'utf8');
+    return JSON.parse(content);
   } catch {
-    return { label, content: '' };
+    return null;
+  }
+}
+
+async function computeState() {
+  const state = {
+    version: '2.1.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 };
+    } 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;
 }
 
+const BUILD_AGENTS = [
+  { name: 'planner', tier: 'architect', task: 'Break down requirements into tasks' },
+  { name: 'cto', tier: 'architect', task: 'Technical decisions & architecture' },
+  { name: 'backend', tier: 'core', task: 'API, business logic, services' },
+  { name: 'frontend', tier: 'core', task: 'UI components, pages, styling' },
+  { name: 'database', tier: 'core', task: 'Schema design, migrations, queries' },
+  { name: 'auth', tier: 'specialist', task: 'Authentication & authorization' },
+  { name: 'security', tier: 'specialist', task: 'Security audit & hardening' },
+  { name: 'testing', tier: 'specialist', task: 'Test strategy & implementation' },
+  { name: 'reviewer', tier: 'quality', task: 'Code review & best practices' },
+  { name: 'devops', tier: 'quality', task: 'CI/CD, deployment, infrastructure' }
+];
+
 export function registerServeCommand(program) {
   program
     .command('serve')
@@ -25,13 +77,24 @@ export function registerServeCommand(program) {
       }
 
       const server = http.createServer(async (req, res) => {
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        
         if (!req.url || req.url === '/') {
-          res.writeHead(200, { 'Content-Type': 'text/plain' });
-          res.end('Ultra-Dex MCP Server\n');
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({
+            name: 'Ultra-Dex MCP Server',
+            version: '2.1.0',
+            endpoints: ['/context', '/state', '/score', '/agents', '/agent/:name', '/refresh']
+          }));
           return;
         }
 
         if (req.url === '/context') {
+          const meta = {
+            protocol: 'mcp-lite',
+            version: '0.1',
+            generatedAt: new Date().toISOString(),
+          };
           const [context, plan, quickStart] = await Promise.all([
             readFileSafe('CONTEXT.md', 'CONTEXT.md'),
             readFileSafe('IMPLEMENTATION-PLAN.md', 'IMPLEMENTATION-PLAN.md'),
@@ -39,7 +102,54 @@ export function registerServeCommand(program) {
           ]);
 
           res.writeHead(200, { 'Content-Type': 'application/json' });
-          res.end(JSON.stringify({ files: [context, plan, quickStart] }));
+          res.end(JSON.stringify({ meta, files: [context, plan, quickStart] }));
+          return;
+        }
+
+        // /state - returns .ultra/state.json
+        if (req.url === '/state') {
+          let state = await loadState();
+          if (!state) state = await computeState();
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify(state));
+          return;
+        }
+
+        // /score - quick alignment score
+        if (req.url === '/score') {
+          const state = await computeState();
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ score: state.score, sections: state.sections.completed, total: 34 }));
+          return;
+        }
+
+        // /agents - list available agents
+        if (req.url === '/agents') {
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ agents: BUILD_AGENTS }));
+          return;
+        }
+
+        // /agent/:name - get specific agent prompt
+        if (req.url.startsWith('/agent/')) {
+          const agentName = req.url.replace('/agent/', '');
+          try {
+            const agentPath = path.resolve(process.cwd(), `agents/${agentName}.md`);
+            const content = await fs.readFile(agentPath, 'utf8');
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ agent: agentName, prompt: content }));
+          } catch {
+            res.writeHead(404, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: `Agent ${agentName} not found` }));
+          }
+          return;
+        }
+
+        // /refresh - force state refresh
+        if (req.url === '/refresh') {
+          const state = await computeState();
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ refreshed: true, score: state.score }));
           return;
         }
 
@@ -49,8 +159,15 @@ export function registerServeCommand(program) {
 
       server.listen(port, () => {
         console.log(chalk.green(`\n✅ Ultra-Dex MCP server running on http://localhost:${port}`));
-        console.log(chalk.gray('  GET /context -> CONTEXT.md, IMPLEMENTATION-PLAN.md, QUICK-START.md'));
-        console.log(chalk.gray('  GET / -> health check\n'));
+        console.log(chalk.bold('\n📡 Endpoints:'));
+        console.log(chalk.gray('  GET /          → Server info & endpoint list'));
+        console.log(chalk.gray('  GET /context   → All context files'));
+        console.log(chalk.gray('  GET /state     → Full project state'));
+        console.log(chalk.gray('  GET /score     → Quick alignment score'));
+        console.log(chalk.gray('  GET /agents    → List available agents'));
+        console.log(chalk.gray('  GET /agent/:n  → Get specific agent prompt'));
+        console.log(chalk.gray('  GET /refresh   → Force state refresh'));
+        console.log(chalk.cyan('\n💡 Connect your AI tool to this server for live context.\n'));
       });
     });
 }

package/lib/commands/sync.js

@@ -0,0 +1,35 @@
+import chalk from 'chalk';
+import path from 'path';
+import { snapshotContext } from '../utils/sync.js';
+
+export function registerSyncCommand(program) {
+  program
+    .command('sync')
+    .description('Auto-sync CONTEXT.md with current codebase')
+    .option('-d, --dir <directory>', 'Project directory', '.')
+    .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);
+        process.exit(1);
+      }
+    });
+}

package/lib/templates/context.js

@@ -1,4 +1,4 @@
-import { githubBlobUrl, githubTreeUrl } from '../config/urls.js';
+import { githubBlobUrl, githubWebUrl } from '../config/urls.js';
 
 export const CONTEXT_TEMPLATE = `# {{PROJECT_NAME}} - Context
 
@@ -21,6 +21,6 @@ export const CONTEXT_TEMPLATE = `# {{PROJECT_NAME}} - Context
 Setting up the implementation plan.
 
 ## Resources
-- [Ultra-Dex Template](${githubTreeUrl('')})
+- [Ultra-Dex Template](${githubWebUrl()})
 - [TaskFlow Example](${githubBlobUrl('@%20Ultra%20DeX/Saas%20plan/Examples/TaskFlow-Complete.md')})
 `;

package/lib/utils/fallback.js

@@ -26,11 +26,13 @@ export async function copyWithFallback(primaryPath, fallbackPath, destinationPat
 
 export async function listWithFallback(primaryPath, fallbackPath) {
   try {
-    return await fs.readdir(primaryPath);
+    const files = await fs.readdir(primaryPath);
+    return { files, sourcePath: primaryPath };
   } catch (primaryError) {
     if (!fallbackPath) {
       throw primaryError;
     }
-    return await fs.readdir(fallbackPath);
+    const files = await fs.readdir(fallbackPath);
+    return { files, sourcePath: fallbackPath };
   }
 }

package/lib/utils/files.js

@@ -21,47 +21,6 @@ export async function pathExists(targetPath, type = 'file') {
   }
 }
 
-export async function copyWithFallback({ primary, fallback, destination, onPrimaryMissing }) {
-  try {
-    await fs.copyFile(primary, destination);
-    return 'primary';
-  } catch (primaryError) {
-    if (onPrimaryMissing) {
-      onPrimaryMissing(primaryError);
-    }
-    if (!fallback) {
-      throw primaryError;
-    }
-    await fs.copyFile(fallback, destination);
-    return 'fallback';
-  }
-}
-
-export async function readWithFallback({ primary, fallback, encoding = 'utf-8' }) {
-  try {
-    return await fs.readFile(primary, encoding);
-  } catch (primaryError) {
-    if (!fallback) {
-      throw primaryError;
-    }
-    return await fs.readFile(fallback, encoding);
-  }
-}
-
 export function resolveAssetPath(basePath, relativePath) {
   return path.join(basePath, relativePath);
 }
-
-export async function copyDirectory(srcDir, destDir) {
-  await fs.mkdir(destDir, { recursive: true });
-  const entries = await fs.readdir(srcDir, { withFileTypes: true });
-  for (const entry of entries) {
-    const srcPath = path.join(srcDir, entry.name);
-    const destPath = path.join(destDir, entry.name);
-    if (entry.isDirectory()) {
-      await copyDirectory(srcPath, destPath);
-    } else if (entry.isFile()) {
-      await fs.copyFile(srcPath, destPath);
-    }
-  }
-}

package/lib/utils/sync.js

@@ -0,0 +1,216 @@
+import fs from 'fs/promises';
+import path from 'path';
+
+const IGNORED_DIRS = new Set([
+  '.git',
+  'node_modules',
+  '.next',
+  'dist',
+  'build',
+  'out',
+  '.turbo',
+  '.cache',
+  '.ultra-dex',
+  '.cursor',
+  '.agents',
+  'coverage',
+  '.idea',
+  '.vscode',
+]);
+const IGNORED_FILES = new Set(['CONTEXT.md', '.DS_Store']);
+const SNAPSHOT_DIR = '.ultra-dex';
+const SNAPSHOT_FILE = 'context-snapshot.json';
+const AUTO_SYNC_HEADER = '## Auto-Sync Snapshot';
+const SCHEMA_PATTERNS = [
+  /schema\.prisma$/i,
+  /drizzle\/schema/i,
+  /supabase\/migrations/i,
+  /migrations\/.*\.(sql|ts|js)$/i,
+  /db\/schema/i,
+];
+
+async function listFilesRecursive(rootDir, baseDir = rootDir) {
+  let results = [];
+  const entries = await fs.readdir(rootDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (IGNORED_DIRS.has(entry.name)) continue;
+    const fullPath = path.join(rootDir, entry.name);
+    const relativePath = path.relative(baseDir, fullPath);
+    if (entry.isDirectory()) {
+      results = results.concat(await listFilesRecursive(fullPath, baseDir));
+    } else if (entry.isFile()) {
+      if (IGNORED_FILES.has(entry.name)) continue;
+      results.push(relativePath);
+    }
+  }
+  return results;
+}
+
+function inferStackFromFiles(fileList) {
+  if (fileList.some((file) => file.includes('package.json'))) {
+    if (fileList.some((file) => file.includes('next.config'))) return 'Next.js';
+    if (fileList.some((file) => file.includes('remix.config'))) return 'Remix';
+    if (fileList.some((file) => file.includes('svelte.config'))) return 'SvelteKit';
+    return 'Node.js';
+  }
+  if (fileList.some((file) => file.includes('pyproject.toml') || file.includes('requirements.txt'))) {
+    return 'Python';
+  }
+  return 'Unknown';
+}
+
+function classifyFilePaths(files) {
+  const appFiles = [];
+  const apiFiles = [];
+  const schemaFiles = [];
+  const configFiles = [];
+
+  for (const file of files) {
+    if (SCHEMA_PATTERNS.some((pattern) => pattern.test(file))) {
+      schemaFiles.push(file);
+      continue;
+    }
+    if (/^app\/api\//i.test(file) || /api\/.*\.(ts|js)$/i.test(file)) {
+      apiFiles.push(file);
+      continue;
+    }
+    if (/\.(tsx|jsx|svelte|vue)$/i.test(file) || /^app\//i.test(file)) {
+      appFiles.push(file);
+      continue;
+    }
+    if (/(config|\.config)\.(js|ts|json)$/i.test(file) || /\.(env|toml|yaml|yml)$/i.test(file)) {
+      configFiles.push(file);
+    }
+  }
+
+  return { appFiles, apiFiles, schemaFiles, configFiles };
+}
+
+function buildAutoSyncSection(summary) {
+  const lines = [];
+  lines.push(AUTO_SYNC_HEADER);
+  lines.push('');
+  lines.push(`- Last synced: ${summary.generatedAt}`);
+  lines.push(`- Project root: ${summary.root}`);
+  lines.push(`- Stack guess: ${summary.stack}`);
+  lines.push(`- Total files scanned: ${summary.fileCount}`);
+  lines.push(`- App/UI files: ${summary.appCount}`);
+  lines.push(`- API files: ${summary.apiCount}`);
+  lines.push(`- Schema files: ${summary.schemaCount}`);
+  lines.push(`- Config files: ${summary.configCount}`);
+  lines.push('');
+  if (summary.appFiles.length > 0) {
+    lines.push('### App/UI Files');
+    lines.push(...summary.appFiles.map((file) => `- ${file}`));
+    lines.push('');
+  }
+  if (summary.apiFiles.length > 0) {
+    lines.push('### API Files');
+    lines.push(...summary.apiFiles.map((file) => `- ${file}`));
+    lines.push('');
+  }
+  if (summary.schemaFiles.length > 0) {
+    lines.push('### Schema Files');
+    lines.push(...summary.schemaFiles.map((file) => `- ${file}`));
+    lines.push('');
+  }
+  if (summary.configFiles.length > 0) {
+    lines.push('### Config Files');
+    lines.push(...summary.configFiles.map((file) => `- ${file}`));
+    lines.push('');
+  }
+
+  return lines.join('\n').trim();
+}
+
+function summarizeDiff(previous, next) {
+  if (!previous) {
+    return {
+      added: next.fileCount,
+      removed: 0,
+    };
+  }
+  const previousSet = new Set(previous.fileList || []);
+  const nextSet = new Set(next.fileList || []);
+  let added = 0;
+  let removed = 0;
+  for (const file of nextSet) {
+    if (!previousSet.has(file)) added++;
+  }
+  for (const file of previousSet) {
+    if (!nextSet.has(file)) removed++;
+  }
+  return { added, removed };
+}
+
+export async function snapshotContext(rootDir) {
+  const files = await listFilesRecursive(rootDir);
+  const { appFiles, apiFiles, schemaFiles, configFiles } = classifyFilePaths(files);
+  const summary = {
+    generatedAt: new Date().toISOString(),
+    root: rootDir,
+    fileCount: files.length,
+    appCount: appFiles.length,
+    apiCount: apiFiles.length,
+    schemaCount: schemaFiles.length,
+    configCount: configFiles.length,
+    appFiles: appFiles.slice(0, 25),
+    apiFiles: apiFiles.slice(0, 25),
+    schemaFiles: schemaFiles.slice(0, 25),
+    configFiles: configFiles.slice(0, 25),
+    stack: inferStackFromFiles(files),
+    fileList: files,
+  };
+
+  const snapshotDir = path.join(rootDir, SNAPSHOT_DIR);
+  await fs.mkdir(snapshotDir, { recursive: true });
+  const snapshotPath = path.join(snapshotDir, SNAPSHOT_FILE);
+  let previous = null;
+  try {
+    const previousRaw = await fs.readFile(snapshotPath, 'utf-8');
+    previous = JSON.parse(previousRaw);
+  } catch {
+    previous = null;
+  }
+
+  await fs.writeFile(snapshotPath, JSON.stringify(summary, null, 2));
+
+  const contextPath = path.join(rootDir, 'CONTEXT.md');
+  let contextContent = null;
+  try {
+    contextContent = await fs.readFile(contextPath, 'utf-8');
+  } catch {
+    return {
+      summary,
+      updated: false,
+      missingContext: true,
+      diff: summarizeDiff(previous, summary),
+    };
+  }
+
+  const section = buildAutoSyncSection(summary);
+  let updatedContext = contextContent;
+  if (contextContent.includes(AUTO_SYNC_HEADER)) {
+    const pattern = new RegExp(`${AUTO_SYNC_HEADER}[\\s\\S]*?(?=^##\\s|\\n##\\s|$)`, 'm');
+    updatedContext = contextContent.replace(pattern, `${section}\n\n`);
+  } else {
+    updatedContext = `${contextContent.trim()}\n\n${section}\n`;
+  }
+
+  if (updatedContext !== contextContent) {
+    await fs.writeFile(contextPath, updatedContext);
+    return {
+      summary,
+      updated: true,
+      missingContext: false,
+      diff: summarizeDiff(previous, summary),
+    };
+  }
+
+  return {
+    summary,
+    updated: false,
+    missingContext: false,
+    diff: summarizeDiff(previous, summary),
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ultra-dex",
-  "version": "2.2.0",
+  "version": "2.2.1",
   "description": "CLI for Ultra-Dex SaaS Implementation Framework with AI-Powered Plan Generation, Build Mode, and Code Review",
   "keywords": [
     "saas",