agentic-kdd 2.2.13 → 3.0.2

package/bin/akdd.js

@@ -1,14 +1,15 @@
 #!/usr/bin/env node
 'use strict';
 
-const { init } = require('../src/init');
-const { update } = require('../src/update');
-const { graph } = require('../src/graph');
+const { init }      = require('../src/init');
+const { update }    = require('../src/update');
+const { graph }     = require('../src/graph');
 const { dashboard } = require('../src/dashboard');
-const { analyze } = require('../src/analyze');
-const pkg = require('../package.json');
+const { analyze }   = require('../src/analyze');
+const { mcpSetup, mcpStatus } = require('../src/mcp-setup');
+const pkg  = require('../package.json');
 const path = require('path');
-const fs = require('fs');
+const fs   = require('fs');
 const { execSync } = require('child_process');
 
 const args    = process.argv.slice(2);
@@ -18,92 +19,115 @@ const arg2    = args[2];
 
 const HELP = `
   Agentic KDD v${pkg.version}
-  Autonomous development pipeline with Knowledge-Driven Development
+  Autonomous development pipeline — one developer, full-department output.
 
-  Usage:
+  Setup:
     akdd init              Install Agentic KDD in the current project
     akdd update            Update agents + engine (memory stays intact)
-    akdd analyze           Analyze project code and auto-build knowledge graph
+    akdd health            System health check — what's configured, what's missing
+    akdd health --fix      Auto-fix common issues
+
+  Memory & Knowledge:
     akdd sync              Sync memory files to SQLite graph
-    akdd graph             Sync memory + show graph stats
+    akdd graph             Sync + show graph stats
     akdd stats             Show graph stats and HIGH rules
-    akdd coala             Show CoALA memory stats (procedural + episodic + semantic)
-    akdd metricas          Show agent KPIs (Goal Attainment, Autonomy, etc.)
-    akdd buscar            Hybrid search across all 3 memory layers
-    akdd impacto           Show impact of touching a module/file
+    akdd coala             Show CoALA memory stats (4 layers)
+    akdd buscar            Hybrid search across all memory layers
+    akdd impacto           Semantic impact of a module/entity
     akdd decay             Apply temporal decay to stale patterns
-    akdd dashboard         Open visual dashboard in browser
+    akdd audit             Memory audit — stale entries, contradictions, proposals
+    akdd forget <id>       Forget a memory entry with documented reason
+
+  AST & Impact Analysis:
+    akdd ast               Index project AST (symbols, imports, call graph, PageRank)
+    akdd ast stats         Show AST index stats
+    akdd ast symbols <f>   Show symbols in a file
+    akdd ast-impact <f>    Full impact analysis of a file/module
+    akdd why <entity>      Explain why something exists (causal chain)
+
+  Specs & Autonomy:
+    akdd spec list         List all module specs
+    akdd spec <module>     Show spec status + next wave
+    akdd spec create <m>   Create feature spec for a module
+    akdd spec create <m> --bugfix  Create bugfix spec
+
+  Knowledge Base:
+    akdd adr               Ingest ADRs from docs/adr/
+    akdd knowledge         Ingest gotchas/conventions from docs/
+
+  Metrics & Observability:
+    akdd metrics           Project KPIs — success rate, rework, autonomy score
+    akdd metrics trend     Show trend of last 10 cycles
+    akdd trail             Recent decision trails (what changed and why)
+    akdd trail <ciclo_id>  Full trail of a specific cycle
+    akdd trail why <f>     Why does this file/entity exist?
 
   Intelligence v2.2:
-    akdd git-context       Analyze git diff + risk assessment from episodic memory
-    akdd predict           Show predictive patterns detected from episodic memory
-    akdd embed-status      Check local embeddings status (all-MiniLM-L6-v2)
-    akdd embed-install     Install local embeddings (~23MB, 100% offline)
-    akdd ci-install        Install GitHub Actions workflow for auto CI/CD memory
-    akdd ci-status         Show last CI/CD reports stored in memory
-    akdd ci-report         Report CI result to memory (called by CI workflow)
-
-  akdd --version           Show version
-  akdd --help              Show this help
-
-  After init, open the project in Cursor or Claude Code and type:
-    aa: [your task]
+    akdd git-context       Analyze git diff + risk assessment
+    akdd predict           Predictive risk patterns from episodic memory
+    akdd embed-status      Local embeddings status
+    akdd embed-install     Install local embeddings (~23MB, offline)
+    akdd jina-install      Install jina-v2-code embeddings (~500MB, code-optimized)
+    akdd ci-install        Install GitHub Actions CI/CD workflow
+    akdd ci-status         Show last CI/CD reports
+
+  Dashboard:
+    akdd dashboard         Open visual dashboard in browser
+
+  MCP Setup (Cursor / Claude Code / VS Code):
+    akdd mcp               Auto-configure MCP in all IDEs (recommended)
+    akdd mcp --global      Configure MCP globally for all projects
+    akdd mcp status        Check MCP configuration status
+    (manual fallback: imprime el JSON exacto con tu ruta real)
+
+  akdd --version / akdd --help
 `;
 
 function findGrafo() {
   const p = path.join(process.cwd(), '.agentic', 'grafo', 'grafo.cjs');
-  if (!fs.existsSync(p)) {
-    console.log('\n  grafo.cjs not found. Run: akdd update\n');
-    process.exit(1);
-  }
+  if (!fs.existsSync(p)) { console.log('\n  grafo.cjs not found. Run: akdd update\n'); process.exit(1); }
   return p;
 }
 
 function runGrafo(cmd, extra) {
   const grafo = findGrafo();
-  try {
-    execSync(`node "${grafo}" ${cmd}${extra ? ' ' + extra : ''}`, {
-      stdio: 'inherit', cwd: process.cwd()
-    });
-  } catch(e) { process.exit(1); }
+  const fullCmd = extra ? `node "${grafo}" ${cmd} ${extra}` : `node "${grafo}" ${cmd}`;
+  try { execSync(fullCmd, { stdio: 'inherit', cwd: process.cwd() }); }
+  catch(e) { process.exit(e.status || 1); }
 }
 
-function runGrafoPipe(cmd, extra) {
-  const grafo = findGrafo();
-  try {
-    return execSync(`node "${grafo}" ${cmd}${extra ? ' ' + extra : ''}`, {
-      stdio: 'pipe', cwd: process.cwd()
-    }).toString();
-  } catch(e) { return ''; }
+function runModule(name, cmd, extra) {
+  const p = path.join(process.cwd(), '.agentic', 'grafo', name);
+  if (!fs.existsSync(p)) { console.log(`\n  ${name} not found. Run: akdd update\n`); process.exit(1); }
+  const fullCmd = [
+    `node "${p}"`,
+    cmd || '',
+    extra || ''
+  ].join(' ').trim().replace(/\s+/g,' ');
+  try { execSync(fullCmd, { stdio: 'inherit', cwd: process.cwd() }); }
+  catch(e) { process.exit(e.status || 1); }
 }
 
 switch (command) {
 
-  // ── Comandos existentes ─────────────────────────────────────────────────────
-  case 'init':
-    init(); break;
-
-  case 'update':
-    update(); break;
-
-  case 'analyze':
-  case 'analizar':
-    analyze(); break;
+  case 'init':    init(); break;
+  case 'update':  update(); break;
+  case 'analyze': analyze(); break;
 
-  case 'graph':
-    graph(); break;
-
-  case 'sync':
-    runGrafo('sync'); break;
-
-  case 'stats':
-    runGrafo('stats'); break;
-
-  case 'coala':
-    runGrafo('coala'); break;
+  // ── v3.0: Health ────────────────────────────────────────────────────────
+  case 'health': {
+    const fixFlag = args.includes('--fix') ? '--fix' : '';
+    runModule('health-check.cjs', fixFlag);
+    break;
+  }
 
-  case 'metricas':
-    runGrafo('metricas'); break;
+  // ── Core memory ────────────────────────────────────────────────────────
+  case 'sync':    runGrafo('sync'); break;
+  case 'graph':   graph(); break;
+  case 'stats':   runGrafo('stats'); break;
+  case 'coala':   runGrafo('coala'); break;
+  case 'metricas': runGrafo('metricas'); break;
+  case 'decay':   runGrafo('decay'); break;
 
   case 'buscar':
     if (!arg1) { console.log('\n  Uso: akdd buscar "query" [area]\n'); break; }
@@ -115,81 +139,130 @@ switch (command) {
     runGrafo('impacto', `"${arg1}"`);
     break;
 
-  case 'decay':
-    runGrafo('decay'); break;
+  // ── v3.0: Memory Audit ─────────────────────────────────────────────────
+  case 'audit': runModule('memory-audit.cjs', 'report'); break;
 
-  case 'dashboard':
-    dashboard(); break;
-
-  // ── v2.2: Intelligence features ────────────────────────────────────────────
+  case 'forget': {
+    if (!arg1) { console.log('\n  Uso: akdd forget <id> "<razón>"\n'); break; }
+    const reason = args.slice(2).join(' ');
+    if (!reason) { console.log('\n  Uso: akdd forget <id> "<razón>"\n'); break; }
+    runModule('memory-audit.cjs', 'forget', `${arg1} "${reason}"`);
+    break;
+  }
 
-  case 'git-context': {
-    if (args.includes('--install-hook')) {
-      runGrafo('git-context', '--install-hook');
-      break;
+  // ── v3.0: AST ──────────────────────────────────────────────────────────
+  case 'ast': {
+    const sub = arg1 || 'index';
+    const tgt = arg2 || '';
+    if (sub === 'stats')   runModule('ast-indexer.cjs', 'stats');
+    else if (sub === 'symbols') {
+      if (!tgt) { console.log('\n  Uso: akdd ast symbols <archivo>\n'); break; }
+      runModule('ast-indexer.cjs', 'symbols', `"${tgt}"`);
+    } else {
+      runModule('ast-indexer.cjs', 'index', tgt);
     }
-    runGrafo('git-context');
     break;
   }
 
-  case 'predict': {
-    runGrafo('predict');
+  case 'ast-impact':
+    if (!arg1) { console.log('\n  Uso: akdd ast-impact <archivo_o_módulo>\n'); break; }
+    runModule('impact-analyzer.cjs', 'analyze', `"${arg1}"`);
     break;
-  }
 
-  case 'embed-status': {
-    runGrafo('embed-status');
+  case 'why':
+    if (!arg1) { console.log('\n  Uso: akdd why <archivo_o_entidad>\n'); break; }
+    runModule('decision-trail.cjs', 'why', `"${arg1}"`);
     break;
-  }
 
-  case 'embed-install': {
-    runGrafo('embed-install');
+  // ── v3.0: Specs ────────────────────────────────────────────────────────
+  case 'spec': {
+    const sub = arg1;
+    const mod = arg2;
+    if (!sub || sub === 'list')       runModule('spec-manager.cjs', 'list');
+    else if (sub === 'create') {
+      if (!mod) { console.log('\n  Uso: akdd spec create <módulo> [--bugfix]\n'); break; }
+      runModule('spec-manager.cjs', 'create', `"${mod}"${args.includes('--bugfix') ? ' --bugfix' : ''}`);
+    }
+    else if (sub === 'waves')     { if (!mod) { console.log('\n  Uso: akdd spec waves <módulo>\n'); break; } runModule('spec-manager.cjs', 'waves', `"${mod}"`); }
+    else if (sub === 'validate')  { if (!mod) { console.log('\n  Uso: akdd spec validate <módulo>\n'); break; } runModule('spec-manager.cjs', 'validate', `"${mod}"`); }
+    else runModule('spec-manager.cjs', 'status', `"${sub}"`);
     break;
   }
 
-  case 'ci-install': {
-    runGrafo('ci-install');
+  case 'spec-create':
+    if (!arg1) { console.log('\n  Uso: akdd spec-create <módulo> [--bugfix]\n'); break; }
+    runModule('spec-manager.cjs', 'create', `"${arg1}"${args.includes('--bugfix') ? ' --bugfix' : ''}`);
+    break;
+
+  // ── v3.0: Knowledge ────────────────────────────────────────────────────
+  case 'adr':
+    runModule('adr-ingestor.cjs', 'ingest', arg1 || 'docs/adr');
+    break;
+
+  case 'knowledge':
+    runModule('knowledge-ingestor.cjs', 'ingest', arg1 || '');
+    break;
+
+  // ── v3.0: Metrics ──────────────────────────────────────────────────────
+  case 'metrics':
+    runModule('metrics.cjs', arg1 || 'summary');
     break;
-  }
 
-  case 'ci-status': {
-    runGrafo('ci-status');
+  // ── v3.0: Decision Trail ───────────────────────────────────────────────
+  case 'trail': {
+    if (!arg1)                   runModule('decision-trail.cjs', 'recent', '5');
+    else if (arg1 === 'why')     { if (!arg2) { console.log('\n  Uso: akdd trail why <entidad>\n'); break; } runModule('decision-trail.cjs', 'why', `"${arg2}"`); }
+    else if (arg1 === 'timeline'){ if (!arg2) { console.log('\n  Uso: akdd trail timeline <módulo>\n'); break; } runModule('decision-trail.cjs', 'timeline', `"${arg2}"`); }
+    else                         runModule('decision-trail.cjs', 'ciclo', `"${arg1}"`);
     break;
   }
 
+  // ── Dashboard ──────────────────────────────────────────────────────────
+  case 'dashboard': dashboard(); break;
+
+  // ── v2.2: Intelligence ─────────────────────────────────────────────────
+  case 'git-context': runGrafo('git-context', args.includes('--install-hook') ? '--install-hook' : ''); break;
+  case 'predict':     runGrafo('predict'); break;
+  case 'embed-status': runGrafo('embed-status'); break;
+  case 'embed-install': runGrafo('embed-install'); break;
+
+  case 'jina-install':
+    runModule('embeddings.cjs', 'install-jina');
+    break;
+
+  case 'ci-install': runGrafo('ci-install'); break;
+  case 'ci-status':  runGrafo('ci-status'); break;
+
   case 'ci-report': {
-    // Llamado por GitHub Actions — no interrumpir el CI si falla
     const grafo = path.join(process.cwd(), '.agentic', 'grafo', 'grafo.cjs');
     if (!fs.existsSync(grafo)) { process.exit(0); }
+    const esExito = args.includes('--success');
+    const outIdx  = args.indexOf('--output');
+    const outFile = outIdx >= 0 ? args[outIdx + 1] : null;
+    const flags   = [esExito ? '--success' : '', outFile ? `--output "${outFile}"` : ''].filter(Boolean).join(' ');
+    try { execSync(`node "${grafo}" ci-report ${flags}`, { stdio: 'inherit', cwd: process.cwd(), timeout: 60000 }); }
+    catch(e) { process.exit(0); }
+    break;
+  }
 
-    const esExito    = args.includes('--success');
-    const outputIdx  = args.indexOf('--output');
-    const outputFile = outputIdx >= 0 ? args[outputIdx + 1] : null;
-
-    const flags = [
-      esExito    ? '--success'          : '',
-      outputFile ? `--output "${outputFile}"` : ''
-    ].filter(Boolean).join(' ');
 
-    try {
-      execSync(`node "${grafo}" ci-report ${flags}`, {
-        stdio: 'inherit', cwd: process.cwd(), timeout: 60000
-      });
-    } catch(e) { process.exit(0); } // no fallar el CI
+  // ── v3.0: MCP Setup ────────────────────────────────────────────────────
+  case 'mcp': {
+    const sub = arg1;
+    const opts = { global: args.includes('--global') };
+    if (sub === 'status') {
+      mcpStatus(process.cwd());
+    } else {
+      mcpSetup(process.cwd(), opts);
+    }
     break;
   }
 
-  // ── Meta ────────────────────────────────────────────────────────────────────
-  case '--version':
-  case '-v':
-    console.log(pkg.version);
-    break;
+  case '--version': case '-v':
+    console.log(pkg.version); break;
 
-  case '--help':
-  case '-h':
-  case undefined:
-    console.log(HELP);
-    break;
+  case '--help': case '-h': case undefined:
+    console.log(HELP); break;
 
   default:
     console.log(`\n  Unknown command: ${command}`);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "agentic-kdd",
-  "version": "2.2.13",
-  "description": "Autonomous development pipeline with KDD — aa: · ag: · audit: · Git Context · Prediction · Local Embeddings · CI/CD. Works with Cursor and Claude Code.",
+  "version": "3.0.2",
+  "description": "Autonomous development pipeline — aa: · ag: · audit: · AST graph · Harness · Specs · Impact analysis · Decision trail · Metrics · MCP server. Works with Cursor and Claude Code.",
   "main": "src/index.js",
   "bin": {
     "akdd": "bin/akdd.js"
@@ -21,7 +21,12 @@
     "knowledge-driven",
     "agentic",
     "sqlite",
-    "dashboard"
+    "dashboard",
+    "mcp",
+    "ast",
+    "harness",
+    "specs",
+    "memory"
   ],
   "author": "Adrianlpz211",
   "license": "MIT",

package/src/init.js

@@ -1,4 +1,5 @@
 'use strict';
+const { mcpSetup } = require('./mcp-setup');
 
 const fs = require('fs-extra');
 const path = require('path');
@@ -278,6 +279,14 @@ Estado: Pendiente aa: configurar
   console.log(chalk.gray('  CLAUDE.md              — activa aa: / ag: / audit:'));
   console.log(chalk.gray('  .cursorrules           — reglas para Cursor'));
 
+  // ── CONFIGURAR MCP AUTOMÁTICAMENTE ─────────────────────────────────────────
+  console.log(chalk.bold("  Configurando MCP server..."));
+  try {
+    await mcpSetup(projectPath, { silent: false });
+  } catch(e) {
+    console.log(chalk.gray("  (MCP: ejecuta akdd mcp para configurarlo manualmente)"));
+  }
+
   // Instrucción final
   console.log('\n' + chalk.dim('  ─────────────────────────────────────────────'));
   console.log(chalk.bold('  Último paso — abre este proyecto en'));

package/src/mcp-setup.js

@@ -0,0 +1,265 @@
+'use strict';
+
+const fs   = require('fs-extra');
+const path = require('path');
+const os   = require('os');
+const { execSync } = require('child_process');
+const chalk = require('chalk');
+
+/**
+ * akdd mcp — Configura el MCP server automáticamente.
+ *
+ * Hace todo lo posible sin intervención del usuario:
+ *   1. Escribe .cursor/mcp.json en el proyecto (Cursor lo lee automáticamente)
+ *   2. Intenta ejecutar `claude mcp add` si el CLI está disponible
+ *   3. Imprime el JSON EXACTO (con ruta real del sistema, no placeholder)
+ *      para los casos que requieran paso manual
+ *
+ * El usuario NUNCA tiene que adivinar la ruta — este comando la resuelve por él.
+ */
+
+async function mcpSetup(projectPath, opts = {}) {
+  projectPath = projectPath || process.cwd();
+
+  // ── Verificar que Agentic está instalado ───────────────────────────────────
+  const serverFile = path.join(projectPath, '.agentic', 'grafo', 'mcp-server.cjs');
+  if (!fs.existsSync(serverFile)) {
+    console.log(chalk.yellow('\n  mcp-server.cjs no encontrado.'));
+    console.log(chalk.gray('  Ejecuta: akdd update\n'));
+    return;
+  }
+
+  // ── Resolver ruta absoluta real (sin placeholders, sin adivinar) ───────────
+  // path.resolve() → ruta exacta del sistema actual, con nombre de usuario correcto
+  const serverPath     = path.resolve(serverFile);
+  const serverPathJson = serverPath.replace(/\\/g, '\\\\'); // escaping para JSON en Windows
+
+  console.log('\n' + chalk.bold.hex('#8b5cf6')('  Agentic KDD — MCP Setup'));
+  console.log(chalk.gray(`  Ruta del servidor: ${serverPath}\n`));
+
+  const results = {
+    cursor_project: false,
+    cursor_global:  false,
+    claude_code:    false,
+  };
+
+  // ══ PASO 1: Cursor — proyecto (automático, siempre funciona) ═══════════════
+  const cursorMcpDir  = path.join(projectPath, '.cursor');
+  const cursorMcpFile = path.join(cursorMcpDir, 'mcp.json');
+
+  try {
+    fs.ensureDirSync(cursorMcpDir);
+
+    let cursorConfig = {};
+    if (fs.existsSync(cursorMcpFile)) {
+      try { cursorConfig = JSON.parse(fs.readFileSync(cursorMcpFile, 'utf8')); } catch {}
+    }
+    if (!cursorConfig.mcpServers) cursorConfig.mcpServers = {};
+
+    cursorConfig.mcpServers['agentic-kdd'] = {
+      command: 'node',
+      args: [serverPath],
+    };
+
+    fs.writeFileSync(cursorMcpFile, JSON.stringify(cursorConfig, null, 2));
+    results.cursor_project = true;
+    console.log(chalk.green('  ✓ Cursor (proyecto)  →  .cursor/mcp.json actualizado'));
+    console.log(chalk.gray('    Reinicia Cursor o recarga la ventana (Ctrl+Shift+P → "Reload Window")'));
+  } catch (e) {
+    console.log(chalk.yellow(`  ⚠ Cursor (proyecto)  →  Error: ${e.message}`));
+  }
+
+  // ══ PASO 2: Claude Code CLI (automático si está instalado) ═════════════════
+  const claudeCliAvailable = isCLIAvailable('claude');
+  if (claudeCliAvailable) {
+    try {
+      // claude mcp add agentic-kdd -- node "/ruta/exacta/mcp-server.cjs"
+      execSync(`claude mcp add agentic-kdd -- node "${serverPath}"`, {
+        stdio: 'pipe',
+        cwd: projectPath,
+      });
+      results.claude_code = true;
+      console.log(chalk.green('  ✓ Claude Code        →  registrado via "claude mcp add"'));
+    } catch (e) {
+      // Puede fallar si ya existe — intentar actualizar
+      try {
+        execSync(`claude mcp remove agentic-kdd`, { stdio: 'pipe', cwd: projectPath });
+        execSync(`claude mcp add agentic-kdd -- node "${serverPath}"`, {
+          stdio: 'pipe', cwd: projectPath,
+        });
+        results.claude_code = true;
+        console.log(chalk.green('  ✓ Claude Code        →  actualizado'));
+      } catch {
+        console.log(chalk.gray('  ~ Claude Code        →  CLI no disponible o ya configurado'));
+      }
+    }
+  } else {
+    console.log(chalk.gray('  ~ Claude Code        →  CLI no detectado (config manual abajo)'));
+  }
+
+  // ══ PASO 3: Cursor global (opcional, solo si --global) ════════════════════
+  if (opts.global) {
+    const globalCursorConfig = getGlobalCursorConfigPath();
+    if (globalCursorConfig) {
+      try {
+        fs.ensureDirSync(path.dirname(globalCursorConfig));
+        let globalConfig = {};
+        if (fs.existsSync(globalCursorConfig)) {
+          try { globalConfig = JSON.parse(fs.readFileSync(globalCursorConfig, 'utf8')); } catch {}
+        }
+        if (!globalConfig.mcpServers) globalConfig.mcpServers = {};
+        globalConfig.mcpServers['agentic-kdd'] = { command: 'node', args: [serverPath] };
+        fs.writeFileSync(globalCursorConfig, JSON.stringify(globalConfig, null, 2));
+        results.cursor_global = true;
+        console.log(chalk.green(`  ✓ Cursor (global)    →  ${globalCursorConfig}`));
+      } catch (e) {
+        console.log(chalk.yellow(`  ⚠ Cursor (global)    →  ${e.message}`));
+      }
+    }
+  }
+
+  // ══ PASO 4: Imprimir configs manuales con ruta EXACTA ═════════════════════
+  console.log('\n' + chalk.bold('  ── Config manual (si necesitas hacerlo tú mismo) ──────────────────'));
+
+  // Cursor manual
+  const cursorJson = JSON.stringify({
+    mcpServers: {
+      'agentic-kdd': {
+        command: 'node',
+        args: [serverPath],
+      }
+    }
+  }, null, 2);
+
+  console.log('\n' + chalk.cyan('  Cursor → .cursor/mcp.json'));
+  console.log(chalk.gray('  (Abre Cursor → Settings → MCP → Add → pega esto:)\n'));
+  console.log(chalk.white(cursorJson.split('\n').map(l => '  ' + l).join('\n')));
+
+  // Claude Code manual
+  console.log('\n' + chalk.cyan('  Claude Code → terminal'));
+  console.log(chalk.white(`  claude mcp add agentic-kdd -- node "${serverPath}"`));
+
+  // VS Code manual
+  console.log('\n' + chalk.cyan('  VS Code → .vscode/settings.json'));
+  const vscodeJson = JSON.stringify({
+    'mcp.servers': {
+      'agentic-kdd': {
+        command: 'node',
+        args: [serverPath],
+        type: 'stdio',
+      }
+    }
+  }, null, 2);
+  console.log(chalk.white(vscodeJson.split('\n').map(l => '  ' + l).join('\n')));
+
+  // ══ RESUMEN ════════════════════════════════════════════════════════════════
+  console.log('\n' + chalk.dim('  ──────────────────────────────────────────────────────'));
+  const autoCount = Object.values(results).filter(Boolean).length;
+  if (autoCount > 0) {
+    console.log(chalk.bold.green(`  ${autoCount} configuración(es) automática(s) completada(s).`));
+  }
+
+  if (results.cursor_project) {
+    console.log(chalk.green('  Cursor listo:') + chalk.gray(' Reload Window → las tools aparecen automáticamente.'));
+  }
+  if (results.claude_code) {
+    console.log(chalk.green('  Claude Code listo:') + chalk.gray(' cierra y abre el proyecto.'));
+  }
+
+  console.log('\n' + chalk.gray('  Para configurar globalmente (todos tus proyectos):'));
+  console.log(chalk.gray('  akdd mcp --global\n'));
+}
+
+// ─── HELPERS ──────────────────────────────────────────────────────────────────
+
+function isCLIAvailable(cmd) {
+  try {
+    execSync(`${cmd} --version`, { stdio: 'pipe', timeout: 5000 });
+    return true;
+  } catch { return false; }
+}
+
+function getGlobalCursorConfigPath() {
+  const platform = os.platform();
+  const home     = os.homedir();
+
+  if (platform === 'win32') {
+    // Windows: %APPDATA%\Cursor\User\globalStorage\mcp.json
+    const appData = process.env.APPDATA || path.join(home, 'AppData', 'Roaming');
+    return path.join(appData, 'Cursor', 'User', 'globalStorage', 'mcp.json');
+  }
+  if (platform === 'darwin') {
+    // macOS: ~/Library/Application Support/Cursor/User/globalStorage/mcp.json
+    return path.join(home, 'Library', 'Application Support', 'Cursor', 'User', 'globalStorage', 'mcp.json');
+  }
+  // Linux: ~/.config/Cursor/User/globalStorage/mcp.json
+  return path.join(home, '.config', 'Cursor', 'User', 'globalStorage', 'mcp.json');
+}
+
+/**
+ * Verifica y muestra el estado actual de la config MCP.
+ * akdd mcp status
+ */
+function mcpStatus(projectPath) {
+  projectPath = projectPath || process.cwd();
+
+  const serverFile    = path.join(projectPath, '.agentic', 'grafo', 'mcp-server.cjs');
+  const cursorProject = path.join(projectPath, '.cursor', 'mcp.json');
+  const globalCursor  = getGlobalCursorConfigPath();
+
+  console.log('\n' + chalk.bold('  Agentic KDD — MCP Status\n'));
+
+  // Server file
+  const hasServer = fs.existsSync(serverFile);
+  console.log(hasServer
+    ? chalk.green('  ✓ mcp-server.cjs     encontrado')
+    : chalk.red('  ✗ mcp-server.cjs     NO encontrado — ejecutar: akdd update'));
+
+  // Cursor project config
+  let cursorProjectOk = false;
+  if (fs.existsSync(cursorProject)) {
+    try {
+      const config = JSON.parse(fs.readFileSync(cursorProject, 'utf8'));
+      cursorProjectOk = !!(config?.mcpServers?.['agentic-kdd']);
+    } catch {}
+  }
+  console.log(cursorProjectOk
+    ? chalk.green('  ✓ Cursor (proyecto)  .cursor/mcp.json configurado')
+    : chalk.yellow('  ~ Cursor (proyecto)  No configurado — ejecutar: akdd mcp'));
+
+  // Cursor global config
+  let cursorGlobalOk = false;
+  if (globalCursor && fs.existsSync(globalCursor)) {
+    try {
+      const config = JSON.parse(fs.readFileSync(globalCursor, 'utf8'));
+      cursorGlobalOk = !!(config?.mcpServers?.['agentic-kdd']);
+    } catch {}
+  }
+  console.log(cursorGlobalOk
+    ? chalk.green('  ✓ Cursor (global)    configurado')
+    : chalk.gray('  ~ Cursor (global)    No configurado — opcional: akdd mcp --global'));
+
+  // Claude Code
+  const claudeAvailable = isCLIAvailable('claude');
+  if (claudeAvailable) {
+    try {
+      const mcpList = execSync('claude mcp list', { stdio: 'pipe' }).toString();
+      const hasAgentic = mcpList.includes('agentic-kdd');
+      console.log(hasAgentic
+        ? chalk.green('  ✓ Claude Code        registrado')
+        : chalk.yellow('  ~ Claude Code        No registrado — ejecutar: akdd mcp'));
+    } catch {
+      console.log(chalk.gray('  ~ Claude Code        CLI disponible pero sin listar MCPs'));
+    }
+  } else {
+    console.log(chalk.gray('  ~ Claude Code CLI    No instalado'));
+  }
+
+  if (hasServer && !cursorProjectOk) {
+    console.log('\n' + chalk.bold('  → Ejecuta: akdd mcp\n'));
+  } else if (hasServer && cursorProjectOk) {
+    console.log('\n' + chalk.green('  Todo configurado. Recarga la ventana en Cursor si es necesario.\n'));
+  }
+}
+
+module.exports = { mcpSetup, mcpStatus };