agentic-kdd 2.1.7 → 2.1.8

package/bin/akdd.js

@@ -94,4 +94,4 @@ switch (command) {
     console.log(`\n  Unknown command: ${command}`);
     console.log('  Run akdd --help for usage\n');
     process.exit(1);
-}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-kdd",
-  "version": "2.1.7",
+  "version": "2.1.8",
   "description": "Autonomous development pipeline with KDD — aa: · ag: · audit: · Visual Dashboard. Works with Cursor and Claude Code.",
   "main": "src/index.js",
   "bin": {

package/src/graph.js

@@ -29,22 +29,22 @@ async function graph() {
   // Sincronizar primero
   try {
     process.stdout.write(chalk.gray('  Sincronizando memoria... '));
-    execSync(`node "${grafo}" sync`, { stdio: 'pipe', cwd: projectPath });
+    execSync(`node "${grafo}" sync`, { stdio: ['pipe', 'pipe', 'pipe'], cwd: projectPath });
     console.log(chalk.green('✓'));
   } catch (e) {
-    console.log(chalk.yellow('⚠ No se pudo sincronizar'));
+    console.log(chalk.yellow('⚠ ' + e.message.slice(0, 100)));
   }
 
   // Stats
   if (fs.existsSync(dbPath)) {
     try {
-      const output = execSync(`node "${grafo}" stats`, { stdio: 'pipe', cwd: projectPath }).toString();
+      const output = execSync(`node "${grafo}" stats`, { stdio: ['pipe', 'pipe', 'pipe'], cwd: projectPath }).toString();
       console.log(output);
     } catch (e) {
-      console.log(chalk.red('  Error: ' + e.message));
+      console.log(chalk.red('  Error stats: ' + e.stderr?.toString().slice(0, 200)));
     }
   } else {
-    console.log(chalk.gray('  Sin datos aún — usa aa: para empezar\n'));
+    console.log(chalk.yellow(`  DB no encontrada en: ${dbPath}\n`));
   }
 
   // Métricas si hay ciclos

package/src/init.js

@@ -201,7 +201,20 @@ async function init() {
     spinner.text = 'Instalando archivos...';
     copyAgenticFiles(sourcePath, projectPath);
     fs.removeSync(TEMP_DIR);
-    spinner.succeed(chalk.green('Archivos instalados'));
+
+    // Instalar better-sqlite3 para el grafo SQLite
+    spinner.text = 'Instalando dependencias del grafo...';
+    try {
+      require('child_process').execSync('npm install better-sqlite3 --save', {
+        stdio: 'pipe', cwd: projectPath
+      });
+      spinner.succeed(chalk.green('Archivos instalados + better-sqlite3'));
+    } catch(e) {
+      spinner.warn(chalk.yellow('Archivos instalados (sin better-sqlite3)'));
+      console.log(chalk.gray('\n  El grafo usará node:sqlite integrado en Node.js 22+'));
+      console.log(chalk.gray('  Para máximo rendimiento instala las build tools:'));
+      console.log(chalk.gray('  https://visualstudio.microsoft.com/visual-cpp-build-tools/\n'));
+    }
   } catch (err) {
     spinner.fail(chalk.red('Error en la instalación'));
     console.error(chalk.red('\n  ' + err.message + '\n'));

package/templates/.agentic/grafo/grafo.cjs

@@ -12,51 +12,72 @@ const crypto = require('crypto');
 let dbAdapter = null; // 'better-sqlite3' | 'sqljs'
 
 function getDB(dbPath) {
-  // Intentar better-sqlite3 primero
-  if (dbAdapter !== 'sqljs') {
+  // Intentar better-sqlite3 primero (nativo, rápido)
+  if (dbAdapter !== 'node-sqlite' && dbAdapter !== 'sqljs') {
     try {
       const BS3 = require('better-sqlite3');
       const db = new BS3(dbPath);
-      db.pragma('journal_mode = WAL');
-      db.pragma('synchronous = NORMAL');
-      db.pragma('cache_size = -64000');
-      db.pragma('temp_store = MEMORY');
+      db.pragma('journal_mode = DELETE');
+      db.pragma('synchronous = FULL');
       dbAdapter = 'better-sqlite3';
       return { db, type: 'better-sqlite3' };
-    } catch(e) {
-      dbAdapter = 'sqljs';
-    }
+    } catch(e) {}
   }
 
-  // Fallback: sql.js (puro JavaScript, sin compilación, funciona en cualquier Windows)
-  try {
-    const initSqlJs = require('sql.js');
-    // sql.js es async — usamos sync wrapper
-    const SQL = require('sql.js/dist/sql-wasm.js');
-    let buffer = null;
-    if (fs.existsSync(dbPath)) {
-      buffer = fs.readFileSync(dbPath);
-    }
-    const db = new SQL.Database(buffer);
-    dbAdapter = 'sqljs';
-    return { db, type: 'sqljs', path: dbPath };
-  } catch(e) {
-    // Si ninguno está disponible, instalar sql.js automáticamente
-    console.log('  Instalando dependencias del grafo...');
+  // Fallback 1: node:sqlite — integrado en Node.js 22+
+  if (dbAdapter !== 'sqljs') {
     try {
-      require('child_process').execSync('npm install sql.js --save', {
-        stdio: 'pipe', cwd: path.join(__dirname, '..', '..')
-      });
-      const SQL = require('sql.js/dist/sql-wasm.js');
-      let buffer = null;
-      if (fs.existsSync(dbPath)) buffer = fs.readFileSync(dbPath);
-      const db = new SQL.Database(buffer);
-      dbAdapter = 'sqljs';
-      return { db, type: 'sqljs', path: dbPath };
-    } catch(e2) {
-      throw new Error('No se pudo inicializar el grafo SQLite. Corre: npm install sql.js');
+      const { DatabaseSync } = require('node:sqlite');
+      const db = new DatabaseSync(dbPath);
+      dbAdapter = 'node-sqlite';
+      return { db, type: 'node-sqlite' };
+    } catch(e) {}
+  }
+
+  // Fallback 2: sql.js — puro JS, cualquier Node version
+  const projectRoot = path.join(__dirname, '..', '..');
+  const searchPaths = [
+    path.join(projectRoot, 'node_modules', 'sql.js', 'dist', 'sql-wasm.js'),
+    path.join(__dirname, 'node_modules', 'sql.js', 'dist', 'sql-wasm.js'),
+  ];
+
+  for (const sqlPath of searchPaths) {
+    if (fs.existsSync(sqlPath)) {
+      try {
+        // sql.js sync workaround usando Worker
+        const SQL = require(sqlPath);
+        let DbClass = null;
+        if (SQL && SQL.Database) DbClass = SQL.Database;
+        else if (typeof SQL === 'function') {
+          // Intentar llamar sync
+          let resolved = null;
+          SQL({}).then(s => { resolved = s; }).catch(() => {});
+          // Esperar máximo 3 segundos
+          const start = Date.now();
+          while (!resolved && Date.now() - start < 3000) {
+            require('child_process').spawnSync('node', ['-e', ''], { timeout: 10 });
+          }
+          if (resolved && resolved.Database) DbClass = resolved.Database;
+        }
+        if (DbClass) {
+          let buffer = null;
+          if (fs.existsSync(dbPath)) buffer = fs.readFileSync(dbPath);
+          const db = buffer ? new DbClass(buffer) : new DbClass();
+          dbAdapter = 'sqljs';
+          return { db, type: 'sqljs', path: dbPath };
+        }
+      } catch(e) {}
     }
   }
+
+  throw new Error(
+    'No se pudo inicializar el grafo SQLite.\n' +
+    '  Tu versión de Node.js: ' + process.version + '\n' +
+    '  Opciones:\n' +
+    '  1. Usa Node.js 22+ (ya incluye SQLite integrado)\n' +
+    '  2. Corre: npm install sql.js\n' +
+    '  3. Instala Visual Studio Build Tools para better-sqlite3'
+  );
 }
 
 // Wrapper unificado que abstrae las diferencias entre better-sqlite3 y sql.js
@@ -64,19 +85,31 @@ function createAdapter(dbPath) {
   const { db, type, path: sqlPath } = getDB(dbPath);
 
   if (type === 'better-sqlite3') {
-    // API nativa — synchronous, más rápida
     return {
-      exec: (sql) => db.exec(sql),
-      prepare: (sql) => db.prepare(sql),
-      all: (sql, ...params) => db.prepare(sql).all(...params),
-      get: (sql, ...params) => db.prepare(sql).get(...params),
-      run: (sql, ...params) => db.prepare(sql).run(...params),
+      exec: (sql) => { try { db.exec(sql); } catch(e) {} },
+      all:  (sql, ...params) => { try { return db.prepare(sql).all(...params.flat()); } catch(e) { return []; } },
+      get:  (sql, ...params) => { try { return db.prepare(sql).get(...params.flat()); } catch(e) { return null; } },
+      run:  (sql, ...params) => { try { db.prepare(sql).run(...params.flat()); } catch(e) {} },
       transaction: (fn) => db.transaction(fn),
-      pragma: (p) => db.pragma(p),
-      close: () => db.close(),
+      pragma: (p) => { try { db.pragma(p); } catch(e) {} },
+      close: () => { try { db.close(); } catch(e) {} },
       type: 'better-sqlite3'
     };
-  } else {
+  }
+
+  if (type === 'node-sqlite') {
+    // node:sqlite API — similar a better-sqlite3
+    return {
+      exec: (sql) => { try { db.exec(sql); } catch(e) {} },
+      all:  (sql, ...params) => { try { return db.prepare(sql).all(...params.flat()); } catch(e) { return []; } },
+      get:  (sql, ...params) => { try { return db.prepare(sql).get(...params.flat()); } catch(e) { return null; } },
+      run:  (sql, ...params) => { try { db.prepare(sql).run(...params.flat()); } catch(e) {} },
+      transaction: (fn) => (...args) => { try { fn(...args); } catch(e) {} },
+      pragma: () => {},
+      close: () => { try { db.close(); } catch(e) {} },
+      type: 'node-sqlite'
+    };
+  }
     // sql.js API — puro JS, necesita guardar el archivo manualmente
     const saveDB = () => {
       try {
@@ -124,7 +157,6 @@ function createAdapter(dbPath) {
       type: 'sqljs',
       save: saveDB
     };
-  }
 }
 
 const ROOT        = path.join(__dirname, '..', '..');
@@ -135,11 +167,20 @@ const MEMORIA_PATH= path.join(ROOT, '.agentic', 'memoria');
 // ─── INIT ──────────────────────────────────────────────────────────────────────
 function initDB() {
   const adapter = createAdapter(DB_PATH);
-  const schema  = fs.readFileSync(SCHEMA_PATH, 'utf8');
-  // Ejecutar schema línea por línea para compatibilidad con sql.js
-  schema.split(';').map(s => s.trim()).filter(s => s && !s.startsWith('--')).forEach(s => {
-    try { adapter.exec(s + ';'); } catch(e) {}
-  });
+  // Usar exec directo — más confiable que split por ;
+  // porque el schema tiene comentarios -- inline dentro de CREATE TABLE
+  try {
+    const schema = fs.readFileSync(SCHEMA_PATH, 'utf8');
+    adapter.exec(schema);
+  } catch(e) {
+    // Si falla el schema completo, intentar statement por statement
+    const schema = fs.readFileSync(SCHEMA_PATH, 'utf8');
+    // Remover comentarios inline antes de hacer split
+    const clean = schema.replace(/--[^\n]*/g, '').replace(/\n\s*\n/g, '\n');
+    clean.split(';').map(s => s.trim()).filter(s => s.length > 5).forEach(s => {
+      try { adapter.exec(s + ';'); } catch(e) {}
+    });
+  }
   migrateDB(adapter);
   return adapter;
 }
@@ -253,9 +294,11 @@ function sincronizar() {
   }
   if (db.type === 'sqljs' && db.save) db.save();
   detectarRelaciones(db);
+  // Forzar checkpoint WAL para que los datos queden en la DB principal
+  try { db.exec('PRAGMA wal_checkpoint(TRUNCATE)'); } catch(e) {}
   db.close();
   console.log(`\n  Grafo sincronizado — ${total} nodos (${nuevos} nuevos, ${actualizados} actualizados)`);
-  console.log(`  Motor: ${dbAdapter === 'better-sqlite3' ? 'nativo (<5ms)' : 'sql.js (<20ms)'}\n`);
+  console.log(`  Motor: ${dbAdapter === 'better-sqlite3' ? 'nativo (<5ms)' : dbAdapter === 'node-sqlite' ? 'node:sqlite (Node.js 22+)' : 'sql.js (<20ms)'}\n`);
 }
 
 // ─── RELACIONES ────────────────────────────────────────────────────────────────
@@ -311,7 +354,7 @@ function stats() {
   db.close();
 
   console.log('\n  GRAFO DE CONOCIMIENTO — Agentic KDD\n');
-  console.log(`  Motor: ${dbAdapter === 'better-sqlite3' ? 'better-sqlite3 nativo' : 'sql.js (compatible Windows)'}`);
+  console.log(`  Motor: ${dbAdapter === 'better-sqlite3' ? 'better-sqlite3 nativo' : dbAdapter === 'node-sqlite' ? 'node:sqlite (Node.js 22+)' : 'sql.js (compatible Windows)'}`);
   console.log(`  Total nodos: ${totalNodos} | Relaciones: ${totalRels}`);
   if (porTipo.length)  { console.log('\n  Por tipo:');      porTipo.forEach(r => console.log(`    ${r.tipo}: ${r.n}`)); }
   if (porConf.length)  { console.log('\n  Por confianza:'); porConf.forEach(r => console.log(`    ${r.confianza}: ${r.n}`)); }
@@ -500,6 +543,10 @@ const arg2 = process.argv[4];
 
 switch(cmd) {
   case 'sync':     sincronizar(); break;
+  case 'sync-stats':
+    sincronizar();
+    stats();
+    break;
   case 'query':
     const {resultados,trace} = consultar(arg1,arg2);
     console.log(JSON.stringify({resultados,trace},null,2)); break;
@@ -517,8 +564,355 @@ switch(cmd) {
     break;
   case 'snapshot':
     const db2=initDB(); console.log(JSON.stringify(snapshotMemoria(db2),null,2)); db2.close(); break;
+  case 'analizar':
+    analizarProyecto(); break;
   default:
-    console.log('Uso: node grafo.cjs [sync|query|stats|metricas|ciclo|semantico|snapshot]');
+    console.log('Uso: node grafo.cjs [sync|query|stats|metricas|ciclo|semantico|snapshot|analizar]');
+}
+
+
+// ─── ANÁLISIS AUTOMÁTICO DEL PROYECTO ────────────────────────────────────────
+// Recorre el código real y construye el grafo sin esperar ciclos aa:
+// Similar al GRAPH_REPORT.md de Graphify
+
+function analizarProyecto() {
+  console.log('\n  Analizando proyecto...\n');
+
+  const db = initDB();
+  const ignorar = new Set(['node_modules','.git','.next','dist','build','vendor',
+    'coverage','.cache','tmp','temp','.turbo','out','.output','public','static',
+    '__pycache__','.pytest_cache','.mypy_cache']);
+  const extsCodigo = new Set(['.ts','.tsx','.js','.jsx','.php','.py','.vue','.svelte','.rb','.go','.java']);
+  const extsDocs   = new Set(['.md','.txt','.pdf']);
+
+  let archivosAnalizados = 0, nodosPrevios = 0, nodosCreados = 0;
+
+  // Contar nodos previos
+  try { nodosPrevios = (db.get('SELECT COUNT(*) as n FROM nodos') || {}).n || 0; } catch(e) {}
+
+  // ── 1. DETECTAR MÓDULOS desde estructura de carpetas ───────────────────────
+  function detectarModulos(dir, nivel) {
+    if (nivel > 4) return [];
+    let items; try { items = fs.readdirSync(dir); } catch(e) { return []; }
+    const modulos = [];
+
+    for (const item of items) {
+      if (ignorar.has(item) || item.startsWith('.') || item.startsWith('_')) continue;
+      const full = path.join(dir, item);
+      let stat; try { stat = fs.statSync(full); } catch(e) { continue; }
+
+      if (stat.isDirectory()) {
+        // Es módulo si tiene archivos de código dentro
+        let tieneCode = false;
+        try {
+          const sub = fs.readdirSync(full);
+          tieneCode = sub.some(f => extsCodigo.has(path.extname(f).toLowerCase()));
+        } catch(e) {}
+
+        if (tieneCode) {
+          modulos.push({ nombre: item, ruta: full, nivel });
+        }
+        modulos.push(...detectarModulos(full, nivel + 1));
+      }
+    }
+    return modulos;
+  }
+
+  // ── 2. ANALIZAR ARCHIVOS de código ─────────────────────────────────────────
+  function analizarArchivo(filePath) {
+    let content; try { content = fs.readFileSync(filePath, 'utf8'); } catch(e) { return null; }
+    const ext  = path.extname(filePath).toLowerCase();
+    const nombre = path.basename(filePath);
+    const info = { imports: [], exports: [], patrones: [], decisiones: [] };
+
+    // Detectar imports/dependencias
+    const importRegexes = [
+      /import\s+.*?\s+from\s+['"]([^'"]+)['"]/g,  // ES6 import
+      /require\(['"]([^'"]+)['"]\)/g,               // CommonJS require
+      /use\s+([A-Z][a-zA-Z]+)/g,                    // PHP use
+      /import\s+([a-zA-Z.]+)/g,                     // Python import
+    ];
+    importRegexes.forEach(rx => {
+      let m; while ((m = rx.exec(content)) !== null) {
+        if (!m[1].startsWith('.') && !m[1].startsWith('@')) info.imports.push(m[1]);
+      }
+    });
+
+    // Detectar patrones de naming
+    if (/export\s+default\s+function\s+([A-Z][a-zA-Z]+)/.test(content)) info.patrones.push('componente React');
+    if (/\bconst\s+\w+\s*=\s*async\s*\(/.test(content)) info.patrones.push('funciones async/await');
+    if (/\.env\b/.test(content) || /process\.env/.test(content)) info.patrones.push('variables de entorno');
+    if (/createClient|supabase/.test(content)) info.patrones.push('Supabase client');
+    if (/prisma\.|PrismaClient/.test(content)) info.patrones.push('Prisma ORM');
+    if (/SELECT|INSERT|UPDATE|DELETE/i.test(content)) info.patrones.push('queries SQL directas');
+    if (/middleware/.test(nombre.toLowerCase())) info.patrones.push('middleware pattern');
+    if (/\.test\.|\.spec\./.test(nombre)) info.patrones.push('archivo de test');
+    if (/interface\s+[A-Z]|type\s+[A-Z]/.test(content)) info.patrones.push('TypeScript types/interfaces');
+    if (/zod\.|yup\.|joi\./.test(content)) info.patrones.push('validación de schemas');
+    if (/useQuery|useMutation|useEffect/.test(content)) info.patrones.push('React hooks');
+    if (/@Injectable|@Controller|@Module/.test(content)) info.patrones.push('NestJS decorators');
+    if (/artisan|Eloquent|->where/.test(content)) info.patrones.push('Laravel Eloquent');
+
+    // Detectar decisiones arquitectónicas implícitas
+    if (/lib\/|utils\/|helpers\//.test(content)) info.decisiones.push('utilidades centralizadas');
+    if (/only.*server|server.*only/i.test(content) || /use server/.test(content)) info.decisiones.push('Server Components (Next.js)');
+    if (/use client/.test(content)) info.decisiones.push('Client Components (Next.js)');
+
+    archivosAnalizados++;
+    return info;
+  }
+
+  // ── 3. INFERIR ÁREA desde la ruta del archivo ──────────────────────────────
+  function inferirArea(ruta) {
+    const parts = ruta.toLowerCase().split(path.sep);
+    const areaMap = {
+      'auth': 'auth', 'authentication': 'auth', 'login': 'auth',
+      'api': 'api', 'routes': 'api', 'endpoints': 'api', 'controllers': 'api',
+      'components': 'frontend', 'ui': 'frontend', 'pages': 'frontend', 'views': 'frontend',
+      'lib': 'core', 'utils': 'core', 'helpers': 'core', 'shared': 'core',
+      'database': 'database', 'db': 'database', 'models': 'database', 'migrations': 'database',
+      'middleware': 'middleware', 'hooks': 'frontend', 'services': 'services',
+      'payment': 'payments', 'stripe': 'payments', 'billing': 'payments',
+      'email': 'notifications', 'notifications': 'notifications', 'mailer': 'notifications',
+      'tests': 'testing', 'test': 'testing', 'spec': 'testing',
+    };
+    for (const part of parts) {
+      if (areaMap[part]) return areaMap[part];
+    }
+    return 'global';
+  }
+
+  // ── 4. RECORRER EL PROYECTO ────────────────────────────────────────────────
+  const patronesEncontrados = {};  // patrón → { count, areas }
+  const decisionesEncontradas = {};
+  const areasConCodigo = new Set();
+
+  function recorrer(dir, nivel) {
+    if (nivel > 5) return;
+    let items; try { items = fs.readdirSync(dir); } catch(e) { return; }
+
+    for (const item of items) {
+      if (ignorar.has(item) || item.startsWith('.')) continue;
+      const full = path.join(dir, item);
+      let stat; try { stat = fs.statSync(full); } catch(e) { continue; }
+
+      if (stat.isDirectory()) {
+        recorrer(full, nivel + 1);
+      } else if (stat.isFile()) {
+        const ext = path.extname(item).toLowerCase();
+        if (!extsCodigo.has(ext)) continue;
+
+        const info = analizarArchivo(full);
+        if (!info) continue;
+
+        const area = inferirArea(full);
+        areasConCodigo.add(area);
+
+        info.patrones.forEach(p => {
+          if (!patronesEncontrados[p]) patronesEncontrados[p] = { count: 0, areas: new Set() };
+          patronesEncontrados[p].count++;
+          patronesEncontrados[p].areas.add(area);
+        });
+
+        info.decisiones.forEach(d => {
+          if (!decisionesEncontradas[d]) decisionesEncontradas[d] = { count: 0, areas: new Set() };
+          decisionesEncontradas[d].count++;
+          decisionesEncontradas[d].areas.add(area);
+        });
+      }
+    }
+  }
+
+  recorrer(ROOT, 0);
+
+  // ── 5. DETECTAR STACK desde package.json / composer.json ──────────────────
+  const stackInfo = {};
+  const pkgPath = path.join(ROOT, 'package.json');
+  if (fs.existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+      const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+      if (deps['next'])           { stackInfo['Next.js'] = Object.keys(deps['next']||{}).length > 0; }
+      if (deps['react'])          stackInfo['React'] = true;
+      if (deps['@supabase/supabase-js']) stackInfo['Supabase'] = true;
+      if (deps['prisma'] || deps['@prisma/client']) stackInfo['Prisma'] = true;
+      if (deps['express'])        stackInfo['Express'] = true;
+      if (deps['typescript'])     stackInfo['TypeScript'] = true;
+      if (deps['tailwindcss'])    stackInfo['Tailwind CSS'] = true;
+      if (deps['zustand'])        stackInfo['Zustand'] = true;
+      if (deps['zod'])            stackInfo['Zod'] = true;
+      if (deps['stripe'])         stackInfo['Stripe'] = true;
+      if (deps['resend'] || deps['nodemailer']) stackInfo['Email service'] = true;
+    } catch(e) {}
+  }
+
+  // ── 6. GUARDAR EN MEMORIA ──────────────────────────────────────────────────
+  const fecha = new Date().toISOString().split('T')[0];
+
+  // Guardar patrones detectados (solo los que aparecen 2+ veces)
+  Object.entries(patronesEncontrados).forEach(([patron, data]) => {
+    if (data.count < 1) return;
+    const area = data.areas.size === 1 ? [...data.areas][0] : 'global';
+    const confianza = data.count >= 5 ? 'MEDIA' : 'BAJA';
+    const titulo = `[AUTO] ${patron}`;
+    const contenido = `## ${fecha} [AUTO] ${patron}
+Área: ${area}
+Confianza: ${confianza}
+Aplicado: ${data.count}
+Útil: 0
+Estado: ACTIVO
+Última validación: ${fecha}
+Creado: ${fecha}
+Origen: akdd analyze — detectado en ${data.count} archivos
+Regla: Patrón usado consistentemente en el proyecto
+Áreas: ${[...data.areas].join(', ')}`;
+
+    try {
+      const ex = db.get('SELECT id FROM nodos WHERE tipo=? AND titulo=?', 'patron', titulo);
+      if (!ex) {
+        db.run("INSERT INTO nodos (tipo,titulo,contenido,area,confianza,aplicado,util,estado,ultima_validacion,fecha_update) VALUES (?,?,?,?,?,?,?,?,?,datetime('now'))",
+          'patron', titulo, contenido, area, confianza, data.count, 0, 'ACTIVO', fecha);
+        nodosCreados++;
+      }
+    } catch(e) {}
+  });
+
+  // Guardar decisiones detectadas
+  Object.entries(decisionesEncontradas).forEach(([decision, data]) => {
+    if (data.count < 1) return;
+    const area = data.areas.size === 1 ? [...data.areas][0] : 'global';
+    const titulo = `[AUTO] ${decision}`;
+    const contenido = `## ${fecha} [AUTO] ${decision}
+Área: ${area}
+Confianza: BAJA
+Estado: ACTIVO
+Última validación: ${fecha}
+Creado: ${fecha}
+Origen: akdd analyze — inferido del código (${data.count} referencias)
+Decisión: ${decision}
+Razón: Detectado automáticamente — verificar con el equipo
+Áreas: ${[...data.areas].join(', ')}`;
+
+    try {
+      const ex = db.get('SELECT id FROM nodos WHERE tipo=? AND titulo=?', 'decision', titulo);
+      if (!ex) {
+        db.run("INSERT INTO nodos (tipo,titulo,contenido,area,confianza,aplicado,util,estado,ultima_validacion,fecha_update) VALUES (?,?,?,?,?,?,?,?,?,datetime('now'))",
+          'decision', titulo, contenido, area, 'BAJA', 0, 0, 'ACTIVO', fecha);
+        nodosCreados++;
+      }
+    } catch(e) {}
+  });
+
+  // Guardar stack como decisiones
+  Object.keys(stackInfo).forEach(tech => {
+    const titulo = `[AUTO] Stack: ${tech}`;
+    const contenido = `## ${fecha} [AUTO] Stack: ${tech}
+Área: global
+Confianza: MEDIA
+Estado: ACTIVO
+Última validación: ${fecha}
+Creado: ${fecha}
+Origen: akdd analyze — detectado en package.json
+Decisión: El proyecto usa ${tech}
+Razón: Dependencia confirmada en package.json`;
+
+    try {
+      const ex = db.get('SELECT id FROM nodos WHERE tipo=? AND titulo=?', 'decision', titulo);
+      if (!ex) {
+        db.run("INSERT INTO nodos (tipo,titulo,contenido,area,confianza,aplicado,util,estado,ultima_validacion,fecha_update) VALUES (?,?,?,?,?,?,?,?,?,datetime('now'))",
+          'decision', titulo, contenido, 'global', 'MEDIA', 0, 0, 'ACTIVO', fecha);
+        nodosCreados++;
+      }
+    } catch(e) {}
+  });
+
+  // Detectar relaciones entre nodos nuevos
+  detectarRelaciones(db);
+  if (db.type === 'sqljs' && db.save) db.save();
+
+  // Actualizar archivos .md de memoria con lo detectado
+  actualizarMemoriaMd(patronesEncontrados, decisionesEncontradas, stackInfo, fecha);
+
+  const totalNodos = (db.get('SELECT COUNT(*) as n FROM nodos') || {}).n || 0;
+  db.close();
+
+  // ── OUTPUT ─────────────────────────────────────────────────────────────────
+  console.log(`  Archivos analizados: ${archivosAnalizados}`);
+  console.log(`  Areas detectadas:    ${[...areasConCodigo].join(', ') || 'ninguna'}`);
+  console.log(`\n  Stack detectado:`);
+  Object.keys(stackInfo).forEach(t => console.log(`    ✓ ${t}`));
+  console.log(`\n  Patrones encontrados: ${Object.keys(patronesEncontrados).length}`);
+  Object.entries(patronesEncontrados)
+    .sort((a,b) => b[1].count - a[1].count)
+    .slice(0,8)
+    .forEach(([p,d]) => console.log(`    [${d.count}x] ${p}`));
+  console.log(`\n  Decisiones inferidas: ${Object.keys(decisionesEncontradas).length}`);
+  Object.keys(decisionesEncontradas).forEach(d => console.log(`    ~ ${d}`));
+  console.log(`\n  Nodos nuevos en grafo: ${nodosCreados} (total: ${totalNodos})`);
+  console.log(`\n  Dashboard actualizado — corre: node dashboard.cjs\n`);
+}
+
+// ── Actualizar archivos .md de memoria con lo detectado ────────────────────
+function actualizarMemoriaMd(patrones, decisiones, stack, fecha) {
+  try {
+    // Actualizar patrones.md
+    const patronesPath = path.join(MEMORIA_PATH, 'patrones.md');
+    let patronesContent = fs.existsSync(patronesPath) ? fs.readFileSync(patronesPath, 'utf8') : '# Patrones — Agentic KDD\n\n';
+
+    Object.entries(patrones)
+      .filter(([p]) => !patronesContent.includes(`[AUTO] ${p}`))
+      .sort((a,b) => b[1].count - a[1].count)
+      .slice(0, 10)
+      .forEach(([patron, data]) => {
+        const area = data.areas.size === 1 ? [...data.areas][0] : 'global';
+        patronesContent += `\n## ${fecha} [AUTO] ${patron}
+Área: ${area}
+Confianza: ${data.count >= 5 ? 'MEDIA' : 'BAJA'}
+Aplicado: ${data.count}
+Útil: 0
+Estado: ACTIVO
+Última validación: ${fecha}
+Creado: ${fecha}
+Origen: akdd analyze
+Regla: Patrón detectado automáticamente en ${data.count} archivos\n`;
+      });
+    fs.writeFileSync(patronesPath, patronesContent);
+
+    // Actualizar decisiones.md
+    const decisionesPath = path.join(MEMORIA_PATH, 'decisiones.md');
+    let decisionesContent = fs.existsSync(decisionesPath) ? fs.readFileSync(decisionesPath, 'utf8') : '# Decisiones — Agentic KDD\n\n';
+
+    // Stack como decisiones
+    Object.keys(stack)
+      .filter(t => !decisionesContent.includes(`Stack: ${t}`))
+      .forEach(tech => {
+        decisionesContent += `\n## ${fecha} [AUTO] Stack: ${tech}
+Área: global
+Confianza: MEDIA
+Estado: ACTIVO
+Última validación: ${fecha}
+Creado: ${fecha}
+Origen: akdd analyze
+Decisión: El proyecto usa ${tech}
+Razón: Dependencia confirmada en package.json\n`;
+      });
+
+    Object.entries(decisiones)
+      .filter(([d]) => !decisionesContent.includes(`[AUTO] ${d}`))
+      .forEach(([decision, data]) => {
+        const area = data.areas.size === 1 ? [...data.areas][0] : 'global';
+        decisionesContent += `\n## ${fecha} [AUTO] ${decision}
+Área: ${area}
+Confianza: BAJA
+Estado: ACTIVO
+Última validación: ${fecha}
+Creado: ${fecha}
+Origen: akdd analyze
+Decisión: ${decision}
+Razón: Inferido del código — verificar con el equipo\n`;
+      });
+    fs.writeFileSync(decisionesPath, decisionesContent);
+  } catch(e) {}
 }
 
-module.exports = { sincronizar, consultar, stats, metricas, registrarCiclo, buscarSemantico, snapshotMemoria };
+module.exports = { sincronizar, consultar, stats, metricas, registrarCiclo, buscarSemantico, snapshotMemoria, analizarProyecto };