agentic-kdd 3.0.1 → 3.0.3

package/bin/akdd.js

@@ -6,6 +6,7 @@ const { update }    = require('../src/update');
 const { graph }     = require('../src/graph');
 const { dashboard } = require('../src/dashboard');
 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');
@@ -61,6 +62,13 @@ const HELP = `
     akdd trail <ciclo_id>  Full trail of a specific cycle
     akdd trail why <f>     Why does this file/entity exist?
 
+  Collaborative Mode (Legion):
+    akdd collab init       Activate collaborative mode — creates shared DB automatically
+    akdd collab join <url> <token>   Join an existing team's shared memory
+    akdd collab push       Push your learnings to the team
+    akdd collab pull       Pull team's latest learnings
+    akdd collab status     Check collaborative sync status
+
   Intelligence v2.2:
     akdd git-context       Analyze git diff + risk assessment
     akdd predict           Predictive risk patterns from episodic memory
@@ -73,9 +81,10 @@ const HELP = `
   Dashboard:
     akdd dashboard         Open visual dashboard in browser
 
-  MCP Server (Cursor / Claude Code):
-    node .agentic/grafo/mcp-server.cjs
-    See: github.com/Adrianlpz211/Agentic-KDD-MCP
+  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
 
   akdd --version / akdd --help
 `;
@@ -96,11 +105,7 @@ function runGrafo(cmd, extra) {
 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,' ');
+  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); }
 }
@@ -111,14 +116,14 @@ switch (command) {
   case 'update':  update(); break;
   case 'analyze': analyze(); break;
 
-  // ── v3.0: Health ────────────────────────────────────────────────────────
+  // ── v3.0: Health ──────────────────────────────────────────────────────
   case 'health': {
     const fixFlag = args.includes('--fix') ? '--fix' : '';
     runModule('health-check.cjs', fixFlag);
     break;
   }
 
-  // ── Core memory ────────────────────────────────────────────────────────
+  // ── Core memory ───────────────────────────────────────────────────────
   case 'sync':    runGrafo('sync'); break;
   case 'graph':   graph(); break;
   case 'stats':   runGrafo('stats'); break;
@@ -136,7 +141,7 @@ switch (command) {
     runGrafo('impacto', `"${arg1}"`);
     break;
 
-  // ── v3.0: Memory Audit ─────────────────────────────────────────────────
+  // ── v3.0: Memory Audit ────────────────────────────────────────────────
   case 'audit': runModule('memory-audit.cjs', 'report'); break;
 
   case 'forget': {
@@ -147,11 +152,11 @@ switch (command) {
     break;
   }
 
-  // ── v3.0: AST ──────────────────────────────────────────────────────────
+  // ── v3.0: AST ─────────────────────────────────────────────────────────
   case 'ast': {
     const sub = arg1 || 'index';
     const tgt = arg2 || '';
-    if (sub === 'stats')   runModule('ast-indexer.cjs', 'stats');
+    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}"`);
@@ -171,17 +176,17 @@ switch (command) {
     runModule('decision-trail.cjs', 'why', `"${arg1}"`);
     break;
 
-  // ── v3.0: Specs ────────────────────────────────────────────────────────
+  // ── v3.0: Specs ───────────────────────────────────────────────────────
   case 'spec': {
     const sub = arg1;
     const mod = arg2;
-    if (!sub || sub === 'list')       runModule('spec-manager.cjs', 'list');
+    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 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;
   }
@@ -191,7 +196,7 @@ switch (command) {
     runModule('spec-manager.cjs', 'create', `"${arg1}"${args.includes('--bugfix') ? ' --bugfix' : ''}`);
     break;
 
-  // ── v3.0: Knowledge ────────────────────────────────────────────────────
+  // ── v3.0: Knowledge ───────────────────────────────────────────────────
   case 'adr':
     runModule('adr-ingestor.cjs', 'ingest', arg1 || 'docs/adr');
     break;
@@ -200,24 +205,45 @@ switch (command) {
     runModule('knowledge-ingestor.cjs', 'ingest', arg1 || '');
     break;
 
-  // ── v3.0: Metrics ──────────────────────────────────────────────────────
+  // ── v3.0: Metrics ─────────────────────────────────────────────────────
   case 'metrics':
     runModule('metrics.cjs', arg1 || 'summary');
     break;
 
-  // ── v3.0: Decision Trail ───────────────────────────────────────────────
+  // ── 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}"`);
+    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;
+  }
+
+  // ── v3.0: Collaborative Mode (Legion) ────────────────────────────────
+  case 'collab': {
+    const sub = arg1 || 'status';
+    if (sub === 'init') {
+      runModule('collab-manager.cjs', 'init');
+    } else if (sub === 'join') {
+      if (!arg2 || !args[3]) {
+        console.log('\n  Uso: akdd collab join <url> <token>\n');
+        break;
+      }
+      runModule('collab-manager.cjs', 'join', `"${arg2}" "${args[3]}"`);
+    } else if (sub === 'push') {
+      runModule('collab-manager.cjs', 'push');
+    } else if (sub === 'pull') {
+      runModule('collab-manager.cjs', 'pull');
+    } else {
+      runModule('collab-manager.cjs', 'status');
+    }
     break;
   }
 
-  // ── Dashboard ──────────────────────────────────────────────────────────
+  // ── Dashboard ─────────────────────────────────────────────────────────
   case 'dashboard': dashboard(); break;
 
-  // ── v2.2: Intelligence ─────────────────────────────────────────────────
+  // ── 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;
@@ -242,6 +268,15 @@ switch (command) {
     break;
   }
 
+  // ── 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;
+  }
+
   case '--version': case '-v':
     console.log(pkg.version); break;
 

package/collab-manager.cjs

@@ -0,0 +1,403 @@
+/**
+ * Agentic KDD — Collab Manager v2.0
+ * Modo colaborativo automático via Turso + Cloudflare Worker.
+ *
+ * El usuario solo corre: akdd collab init
+ * El sistema crea la DB en Turso automáticamente.
+ * El usuario nunca sabe que Turso existe.
+ *
+ * Uso:
+ *   node .agentic/grafo/collab-manager.cjs init
+ *   node .agentic/grafo/collab-manager.cjs push
+ *   node .agentic/grafo/collab-manager.cjs pull
+ *   node .agentic/grafo/collab-manager.cjs status
+ *   node .agentic/grafo/collab-manager.cjs join <url> <token>
+ */
+
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+const os   = require('os');
+const { execSync } = require('child_process');
+
+// URL de tu Cloudflare Worker — actualizar después de deploy
+const PROVISIONER_URL = 'https://agentic-collab.adrianlpz-game.workers.dev';
+
+const COLLAB_CONFIG_PATH = '.agentic/collab.json';
+
+const SYNC_TABLES = [
+  'nodos',
+  'relaciones_semanticas',
+  'episodios',
+  'knowledge_docs',
+  'ast_symbols',
+  'ast_edges',
+];
+
+// ─── DB LOCAL ──────────────────────────────────────────────────────────────────
+
+function openLocalDB(projectRoot) {
+  const dbPath = path.join(projectRoot, '.agentic/memoria.db');
+  try { return new (require('better-sqlite3'))(dbPath); } catch {}
+  try { const { DatabaseSync } = require('node:sqlite'); return new DatabaseSync(dbPath); } catch {}
+  throw new Error('No SQLite driver disponible');
+}
+
+// ─── CONFIG ───────────────────────────────────────────────────────────────────
+
+function loadConfig(projectRoot) {
+  const configPath = path.join(projectRoot, COLLAB_CONFIG_PATH);
+  if (!fs.existsSync(configPath)) return null;
+  try { return JSON.parse(fs.readFileSync(configPath, 'utf8')); } catch { return null; }
+}
+
+function saveConfig(projectRoot, config) {
+  const configPath = path.join(projectRoot, COLLAB_CONFIG_PATH);
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+
+  // Asegurar que collab.json está en .gitignore
+  const gitignorePath = path.join(projectRoot, '.gitignore');
+  if (fs.existsSync(gitignorePath)) {
+    const gi = fs.readFileSync(gitignorePath, 'utf8');
+    if (!gi.includes('collab.json')) {
+      fs.appendFileSync(gitignorePath, '\n# Agentic KDD collab credentials\n.agentic/collab.json\n');
+    }
+  }
+}
+
+// ─── GENERAR PROJECT ID ───────────────────────────────────────────────────────
+
+function getProjectId(projectRoot) {
+  // Usar el nombre del directorio + un hash corto para que sea único y legible
+  const dirName = path.basename(projectRoot).toLowerCase().replace(/[^a-z0-9]/g, '-');
+  const hash = require('crypto')
+    .createHash('md5')
+    .update(projectRoot)
+    .digest('hex')
+    .substring(0, 6);
+  return `${dirName}-${hash}`;
+}
+
+// ─── INIT — PROVISIONAR DB AUTOMÁTICAMENTE ───────────────────────────────────
+
+async function collabInit(projectRoot) {
+  console.log('\n[COLLAB] Activando modo colaborativo...\n');
+
+  // Verificar si ya está configurado
+  const existing = loadConfig(projectRoot);
+  if (existing?.enabled && existing?.url) {
+    console.log('[COLLAB] Ya configurado. URL:', existing.url);
+    console.log('[COLLAB] Para re-configurar: borrar .agentic/collab.json y correr de nuevo.');
+    return existing;
+  }
+
+  const projectId = getProjectId(projectRoot);
+  console.log(`[COLLAB] Project ID: ${projectId}`);
+  console.log('[COLLAB] Creando base de datos compartida...');
+
+  // Llamar al Cloudflare Worker para provisionar la DB
+  let provisionResult;
+  try {
+    const response = await fetch(PROVISIONER_URL, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ projectId }),
+    });
+
+    if (!response.ok) {
+      const err = await response.text();
+      throw new Error(`Provisioner error: ${err}`);
+    }
+
+    provisionResult = await response.json();
+  } catch (e) {
+    console.error('[COLLAB] Error conectando con el servidor de provisión:', e.message);
+    console.error('[COLLAB] Verificar que el Cloudflare Worker está activo.');
+    process.exit(1);
+  }
+
+  if (!provisionResult.ok) {
+    console.error('[COLLAB] Error creando DB:', provisionResult.error);
+    process.exit(1);
+  }
+
+  // Guardar credenciales localmente
+  const config = {
+    enabled: true,
+    url: provisionResult.url,
+    token: provisionResult.token,
+    db: provisionResult.db,
+    project_id: projectId,
+    member_id: os.userInfo().username,
+    sync_on_cycle_end: true,
+    last_sync: null,
+    created_at: new Date().toISOString(),
+  };
+
+  saveConfig(projectRoot, config);
+
+  console.log('\n[COLLAB] ✅ Modo colaborativo activado.');
+  console.log(`[COLLAB] DB: ${provisionResult.db}`);
+  console.log('[COLLAB] Credenciales guardadas en .agentic/collab.json (gitignored)');
+  console.log('\n[COLLAB] Para que otros miembros del equipo se unan:');
+  console.log(`  Compárteles: URL y token de .agentic/collab.json`);
+  console.log(`  Ellos corren: akdd collab join <url> <token>\n`);
+
+  // Primer push
+  console.log('[COLLAB] Sincronizando memoria local → compartida...');
+  await syncUp(projectRoot);
+
+  return config;
+}
+
+// ─── JOIN — PARA EL DEV QUE SE UNE AL EQUIPO ─────────────────────────────────
+
+async function collabJoin(projectRoot, url, token) {
+  console.log('\n[COLLAB] Uniéndose al equipo...\n');
+
+  const config = {
+    enabled: true,
+    url,
+    token,
+    member_id: os.userInfo().username,
+    sync_on_cycle_end: true,
+    last_sync: null,
+    joined_at: new Date().toISOString(),
+  };
+
+  saveConfig(projectRoot, config);
+
+  console.log('[COLLAB] ✅ Conectado al equipo.');
+  console.log('[COLLAB] Descargando memoria del equipo...');
+
+  await syncDown(projectRoot);
+
+  console.log('[COLLAB] ✅ Listo. Ya tienes toda la memoria del equipo.\n');
+}
+
+// ─── SYNC UP (local → Turso) ──────────────────────────────────────────────────
+
+async function syncUp(projectRoot) {
+  const config = loadConfig(projectRoot);
+  if (!config?.enabled) {
+    console.log('[COLLAB] Modo colaborativo no activado. Correr: akdd collab init');
+    return { synced: false };
+  }
+
+  let client;
+  try {
+    const { createClient } = require('@libsql/client');
+    client = createClient({ url: config.url, authToken: config.token });
+  } catch {
+    console.log('[COLLAB] @libsql/client no instalado. Correr: npm install @libsql/client');
+    return { synced: false };
+  }
+
+  const localDB = openLocalDB(projectRoot);
+  const lastSync = config.last_sync || '1970-01-01T00:00:00.000Z';
+  let totalRows = 0;
+
+  // Schema push — crear tablas en remoto si no existen
+  await pushSchema(client, localDB);
+
+  for (const table of SYNC_TABLES) {
+    try {
+      // Solo filas nuevas/modificadas desde el último sync
+      const dateField = getDateField(table);
+      const rows = localDB.prepare(
+        `SELECT * FROM ${table} WHERE ${dateField} > ? LIMIT 500`
+      ).all(lastSync);
+
+      if (rows.length === 0) continue;
+
+      console.log(`[COLLAB] ${table}: ${rows.length} filas a sincronizar`);
+
+      for (const row of rows) {
+        const keys = Object.keys(row);
+        const vals = Object.values(row);
+        const placeholders = keys.map(() => '?').join(', ');
+        try {
+          await client.execute({
+            sql: `INSERT OR REPLACE INTO ${table} (${keys.join(', ')}) VALUES (${placeholders})`,
+            args: vals,
+          });
+          totalRows++;
+        } catch {}
+      }
+    } catch {}
+  }
+
+  // Actualizar last_sync
+  config.last_sync = new Date().toISOString();
+  saveConfig(projectRoot, config);
+
+  console.log(`[COLLAB] ✅ Sync up: ${totalRows} filas enviadas.`);
+  return { synced: true, rows: totalRows };
+}
+
+// ─── SYNC DOWN (Turso → local) ────────────────────────────────────────────────
+
+async function syncDown(projectRoot) {
+  const config = loadConfig(projectRoot);
+  if (!config?.enabled) return { synced: false };
+
+  let client;
+  try {
+    const { createClient } = require('@libsql/client');
+    client = createClient({ url: config.url, authToken: config.token });
+  } catch {
+    console.log('[COLLAB] @libsql/client no instalado. Correr: npm install @libsql/client');
+    return { synced: false };
+  }
+
+  const localDB = openLocalDB(projectRoot);
+  let totalRows = 0;
+
+  for (const table of SYNC_TABLES) {
+    try {
+      const dateField = getDateField(table);
+      const lastSync = config.last_sync || '1970-01-01T00:00:00.000Z';
+
+      const rs = await client.execute(
+        `SELECT * FROM ${table} WHERE ${dateField} > ? LIMIT 1000`,
+        [lastSync]
+      );
+
+      if (!rs.rows?.length) continue;
+
+      console.log(`[COLLAB] ${table}: recibiendo ${rs.rows.length} filas`);
+
+      for (const row of rs.rows) {
+        const keys = Object.keys(row);
+        const vals = keys.map(k => row[k]);
+        const placeholders = keys.map(() => '?').join(', ');
+
+        // Estrategia por tabla:
+        // episodios → INSERT OR IGNORE (son aditivos, no sobrescribir locales)
+        // resto     → INSERT OR REPLACE (toma la versión más reciente)
+        const strategy = table === 'episodios' ? 'OR IGNORE' : 'OR REPLACE';
+
+        try {
+          localDB.prepare(
+            `INSERT ${strategy} INTO ${table} (${keys.join(', ')}) VALUES (${placeholders})`
+          ).run(vals);
+          totalRows++;
+        } catch {}
+      }
+    } catch {}
+  }
+
+  // Actualizar last_sync
+  config.last_sync = new Date().toISOString();
+  saveConfig(projectRoot, config);
+
+  console.log(`[COLLAB] ✅ Sync down: ${totalRows} filas recibidas.`);
+  return { synced: true, rows: totalRows };
+}
+
+// ─── SCHEMA PUSH ──────────────────────────────────────────────────────────────
+// Crea las tablas en la DB remota si no existen (primera vez)
+
+async function pushSchema(client, localDB) {
+  const tables = localDB.prepare(
+    "SELECT name, sql FROM sqlite_master WHERE type='table' AND sql IS NOT NULL"
+  ).all();
+
+  for (const table of tables) {
+    if (!SYNC_TABLES.includes(table.name)) continue;
+    try {
+      await client.execute(
+        table.sql.replace('CREATE TABLE', 'CREATE TABLE IF NOT EXISTS')
+      );
+    } catch {}
+  }
+}
+
+// ─── STATUS ───────────────────────────────────────────────────────────────────
+
+async function status(projectRoot) {
+  const config = loadConfig(projectRoot);
+
+  console.log('\n[COLLAB] Estado del modo colaborativo:\n');
+
+  if (!config?.enabled) {
+    console.log('  ❌ No activado.');
+    console.log('  Correr: akdd collab init\n');
+    return;
+  }
+
+  console.log(`  ✅ Activado`);
+  console.log(`  DB:          ${config.db || config.url}`);
+  console.log(`  Miembro:     ${config.member_id}`);
+  console.log(`  Último sync: ${config.last_sync || 'nunca'}`);
+  console.log(`  Auto-sync:   ${config.sync_on_cycle_end ? 'sí (al final de cada aa:)' : 'no'}`);
+
+  // Test de conexión
+  try {
+    const { createClient } = require('@libsql/client');
+    const client = createClient({ url: config.url, authToken: config.token });
+    await client.execute('SELECT 1');
+    console.log('  Conexión:    ✅ OK\n');
+  } catch {
+    console.log('  Conexión:    ❌ Error — verificar credenciales\n');
+  }
+}
+
+// ─── HELPER ───────────────────────────────────────────────────────────────────
+
+function getDateField(table) {
+  const fields = {
+    nodos: 'fecha_update',
+    episodios: 'fecha',
+    relaciones_semanticas: 'valid_at',
+    knowledge_docs: 'last_indexed',
+    ast_symbols: 'last_indexed',
+    ast_edges: 'last_indexed',
+  };
+  return fields[table] || 'rowid';
+}
+
+// ─── CLI ──────────────────────────────────────────────────────────────────────
+
+if (require.main === module) {
+  const [,, cmd, arg1, arg2] = process.argv;
+  const projectRoot = process.cwd();
+
+  switch (cmd) {
+    case 'init':
+      collabInit(projectRoot).catch(console.error);
+      break;
+    case 'join':
+      if (!arg1 || !arg2) {
+        console.error('Uso: collab-manager.cjs join <url> <token>');
+        process.exit(1);
+      }
+      collabJoin(projectRoot, arg1, arg2).catch(console.error);
+      break;
+    case 'push':
+      syncUp(projectRoot).then(r => {
+        process.exit(r.synced ? 0 : 1);
+      }).catch(console.error);
+      break;
+    case 'pull':
+      syncDown(projectRoot).then(r => {
+        process.exit(r.synced ? 0 : 1);
+      }).catch(console.error);
+      break;
+    case 'status':
+      status(projectRoot).catch(console.error);
+      break;
+    default:
+      console.log('Uso: node collab-manager.cjs [init | join <url> <token> | push | pull | status]');
+  }
+}
+
+module.exports = {
+  collabInit,
+  collabJoin,
+  syncUp,
+  syncDown,
+  status,
+  loadConfig,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-kdd",
-  "version": "3.0.1",
+  "version": "3.0.3",
   "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": {

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 };