ac-framework 1.7.0 → 1.9.0

package/src/memory/index.js

@@ -0,0 +1,62 @@
+/**
+ * memory/index.js — API pública del sistema de memoria autónoma
+ * 
+ * Sistema de persistencia de conocimiento para agentes AI.
+ * Guarda automáticamente decisiones, patrones, bugfixes y insights.
+ */
+
+// Database
+export { initDatabase, getDatabase, closeDatabase, isDatabaseInitialized } from './database.js';
+
+// Core Engine
+export {
+  saveMemory,
+  searchMemories,
+  getContext,
+  getTimeline,
+  getMemory,
+  updateMemory,
+  deleteMemory,
+  startSession,
+  endSession,
+  getStats,
+  findPatterns,
+  getConnections,
+  anticipateNeeds,
+  exportMemories,
+  importMemories,
+  pruneMemories
+} from './engine.js';
+
+// Utils
+export {
+  redactPrivateContent,
+  extractKeywords,
+  textSimilarity,
+  truncate,
+  isCodeContent,
+  detectLanguage,
+  generateSummary,
+  sanitizeFTSQuery
+} from './utils.js';
+
+// Auto-save system
+export { createAutoSaveHook, AutoSaveManager } from './autosave.js';
+
+// Tipos de memoria válidos para referencia
+export const MEMORY_TYPES = [
+  'architectural_decision',
+  'bugfix_pattern',
+  'api_pattern',
+  'performance_insight',
+  'security_fix',
+  'refactor_technique',
+  'dependency_note',
+  'workaround',
+  'convention',
+  'context_boundary',
+  'general_insight',
+  'session_summary'
+];
+
+export const IMPORTANCE_LEVELS = ['critical', 'high', 'medium', 'low'];

package/src/memory/utils.js

@@ -0,0 +1,128 @@
+/**
+ * utils.js — Utilidades para el sistema de memoria
+ */
+
+/**
+ * Redacta contenido entre etiquetas <private>
+ */
+export function redactPrivateContent(content) {
+  if (!content) return content;
+  
+  const privateRegex = /<private>[\s\S]*?<\/private>/gi;
+  return content.replace(privateRegex, '[REDACTED PRIVATE CONTENT]');
+}
+
+/**
+ * Extrae palabras clave de un texto
+ */
+export function extractKeywords(text, maxKeywords = 5) {
+  if (!text) return [];
+  
+  const stopWords = new Set([
+    'el', 'la', 'los', 'las', 'un', 'una', 'unos', 'unas', 'de', 'del', 'al',
+    'the', 'a', 'an', 'is', 'are', 'was', 'were', 'be', 'been', 'being',
+    'en', 'y', 'o', 'pero', 'por', 'para', 'con', 'sin', 'sobre', 'entre',
+    'in', 'and', 'or', 'but', 'for', 'with', 'without', 'on', 'between',
+    'que', 'como', 'cuando', 'donde', 'quien', 'cual', 'esto', 'eso',
+    'that', 'what', 'when', 'where', 'who', 'which', 'this', 'that'
+  ]);
+  
+  const wordCounts = text.toLowerCase()
+    .replace(/[^\w\s]/g, ' ')
+    .split(/\s+/)
+    .filter(w => w.length > 3 && !stopWords.has(w))
+    .reduce((acc, word) => {
+      acc[word] = (acc[word] || 0) + 1;
+      return acc;
+    }, {});
+  
+  return Object.entries(wordCounts)
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, maxKeywords)
+    .map(([word]) => word);
+}
+
+/**
+ * Calcula similitud simple entre dos textos (Jaccard)
+ */
+export function textSimilarity(text1, text2) {
+  const set1 = new Set(text1.toLowerCase().split(/\s+/));
+  const set2 = new Set(text2.toLowerCase().split(/\s+/));
+  
+  const intersection = new Set([...set1].filter(x => set2.has(x)));
+  const union = new Set([...set1, ...set2]);
+  
+  return intersection.size / union.size;
+}
+
+/**
+ * Trunca texto con ellipsis
+ */
+export function truncate(text, maxLength = 100) {
+  if (!text || text.length <= maxLength) return text;
+  return text.slice(0, maxLength - 3) + '...';
+}
+
+/**
+ * Detecta si un contenido parece código
+ */
+export function isCodeContent(text) {
+  const codeIndicators = [
+    /function\s+\w+\s*\(/,
+    /const\s+\w+\s*=/,
+    /let\s+\w+\s*=/,
+    /var\s+\w+\s*=/,
+    /import\s+.*\s+from/,
+    /export\s+(default\s+)?/,
+    /class\s+\w+/,
+    /if\s*\(.*\)\s*\{/,
+    /for\s*\(.*\)\s*\{/,
+    /```[\s\S]*```/
+  ];
+  
+  return codeIndicators.some(pattern => pattern.test(text));
+}
+
+/**
+ * Detecta lenguaje de programación
+ */
+export function detectLanguage(text) {
+  if (/\.tsx?/.test(text) || /interface\s+\w+/.test(text) || /:\s*(string|number|boolean)/.test(text)) {
+    return 'typescript';
+  }
+  if (/\.jsx?/.test(text) || /React\./.test(text) || /useState|useEffect/.test(text)) {
+    return 'javascript';
+  }
+  if (/\.py/.test(text) || /def\s+\w+\s*\(/.test(text) || /import\s+\w+/.test(text)) {
+    return 'python';
+  }
+  if (/\.go/.test(text) || /func\s+\w+\s*\(/.test(text) || /package\s+\w+/.test(text)) {
+    return 'go';
+  }
+  if (/\.rs/.test(text) || /fn\s+\w+\s*\(/.test(text) || /let\s+mut/.test(text)) {
+    return 'rust';
+  }
+  return 'unknown';
+}
+
+/**
+ * Genera un resumen automático
+ */
+export function generateSummary(text, maxSentences = 2) {
+  if (!text) return '';
+  
+  const sentences = text.split(/[.!?]+/).filter(s => s.trim().length > 10);
+  return sentences.slice(0, maxSentences).join('. ') + '.';
+}
+
+/**
+ * Sanitiza input para FTS5
+ */
+export function sanitizeFTSQuery(query) {
+  // Escapar caracteres especiales de FTS5
+  return query
+    .replace(/"/g, '""')
+    .replace(/\*/g, '')
+    .replace(/^\^/g, '')
+    .replace(/\$/g, '');
+}

package/src/services/mcp-installer.js

@@ -0,0 +1,194 @@
+/**
+ * mcp-installer.js — MCP config installer for AC Framework
+ *
+ * Detects installed AI assistants and injects the ac-framework-memory
+ * MCP server into their config files.
+ *
+ * Best-practice config format per MCP spec:
+ *   { "mcpServers": { "ac-framework-memory": { "command": "node", "args": [<absPath>] } } }
+ *
+ * Claude Code uses a different top-level key format (mcpServers inside claude.json).
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { homedir, platform } from 'node:os';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+// Absolute path to the MCP server entry point (ESM, referenced by node)
+export function getMCPServerPath() {
+  const srcPath = join(__dirname, '../mcp/server.js');
+  return srcPath;
+}
+
+// ── Supported assistants ──────────────────────────────────────────
+
+const home = homedir();
+const IS_WIN = platform() === 'win32';
+
+/**
+ * Each assistant entry:
+ *   configPath  – absolute path to the JSON config file
+ *   configKey   – top-level key that holds server map ("mcpServers" | "servers")
+ *   detectDir   – directory whose existence signals the assistant is present
+ */
+const ASSISTANTS = [
+  {
+    name: 'opencode',
+    configPath: join(home, '.opencode', 'mcp.json'),
+    configKey: 'mcpServers',
+    detectDir: join(home, '.opencode'),
+  },
+  {
+    name: 'claude',
+    // Claude Code CLI uses ~/.claude.json (mcpServers key)
+    configPath: join(home, '.claude.json'),
+    configKey: 'mcpServers',
+    detectDir: home,
+    detectFile: join(home, '.claude.json'),
+  },
+  {
+    name: 'cursor',
+    configPath: join(home, '.cursor', 'mcp.json'),
+    configKey: 'mcpServers',
+    detectDir: join(home, '.cursor'),
+  },
+  {
+    name: 'windsurf',
+    configPath: join(home, '.windsurf', 'mcp.json'),
+    configKey: 'mcpServers',
+    detectDir: join(home, '.windsurf'),
+  },
+  {
+    name: 'gemini',
+    configPath: join(home, '.gemini', 'mcp.json'),
+    configKey: 'mcpServers',
+    detectDir: join(home, '.gemini'),
+  },
+  {
+    name: 'codex',
+    configPath: join(home, '.codex', 'mcp.json'),
+    configKey: 'mcpServers',
+    detectDir: join(home, '.codex'),
+  },
+];
+
+// ── Detection ─────────────────────────────────────────────────────
+
+export function isAssistantInstalled(assistant) {
+  try {
+    // If a specific file is the detection signal, use that
+    if (assistant.detectFile) return existsSync(assistant.detectFile);
+    return existsSync(assistant.detectDir);
+  } catch {
+    return false;
+  }
+}
+
+// ── Install / Uninstall ───────────────────────────────────────────
+
+export function installMCPForAssistant(assistant) {
+  try {
+    const configDir = dirname(assistant.configPath);
+
+    if (!existsSync(configDir)) {
+      mkdirSync(configDir, { recursive: true });
+    }
+
+    // Read existing config or start fresh
+    let config = {};
+    if (existsSync(assistant.configPath)) {
+      try {
+        config = JSON.parse(readFileSync(assistant.configPath, 'utf8'));
+      } catch {
+        config = {};
+      }
+    }
+
+    // Ensure the server map key exists
+    if (!config[assistant.configKey]) {
+      config[assistant.configKey] = {};
+    }
+
+    // Add / overwrite our server entry
+    config[assistant.configKey]['ac-framework-memory'] = {
+      command: 'node',
+      args: [getMCPServerPath()],
+    };
+
+    writeFileSync(assistant.configPath, JSON.stringify(config, null, 2));
+    return true;
+  } catch (error) {
+    console.error(`  Failed to install MCP for ${assistant.name}: ${error.message}`);
+    return false;
+  }
+}
+
+export function uninstallMCPForAssistant(assistant) {
+  try {
+    if (!existsSync(assistant.configPath)) return true;
+
+    let config = {};
+    try {
+      config = JSON.parse(readFileSync(assistant.configPath, 'utf8'));
+    } catch {
+      return true;
+    }
+
+    if (config[assistant.configKey]?.['ac-framework-memory']) {
+      delete config[assistant.configKey]['ac-framework-memory'];
+      writeFileSync(assistant.configPath, JSON.stringify(config, null, 2));
+    }
+
+    return true;
+  } catch (error) {
+    console.error(`  Failed to uninstall MCP for ${assistant.name}: ${error.message}`);
+    return false;
+  }
+}
+
+// ── Batch helpers ─────────────────────────────────────────────────
+
+/**
+ * Detects which assistants are installed and installs MCPs for them.
+ * Returns { installed, success } counts.
+ */
+export function detectAndInstallMCPs() {
+  let installed = 0;
+  let success = 0;
+
+  for (const assistant of ASSISTANTS) {
+    if (isAssistantInstalled(assistant)) {
+      installed++;
+      if (installMCPForAssistant(assistant)) success++;
+    }
+  }
+
+  return { installed, success, assistants: ASSISTANTS };
+}
+
+/**
+ * Installs MCPs for ALL supported assistants regardless of detection.
+ */
+export function installAllMCPs() {
+  let success = 0;
+  for (const assistant of ASSISTANTS) {
+    if (installMCPForAssistant(assistant)) success++;
+  }
+  return { total: ASSISTANTS.length, success };
+}
+
+/**
+ * Uninstalls MCPs from all detected assistants.
+ */
+export function uninstallAllMCPs() {
+  let success = 0;
+  for (const assistant of ASSISTANTS) {
+    if (isAssistantInstalled(assistant) && uninstallMCPForAssistant(assistant)) success++;
+  }
+  return { success };
+}
+
+export { ASSISTANTS };

package/src/services/spec-engine.js

@@ -9,6 +9,7 @@ import { readFile, readdir, stat, mkdir, rename, access, writeFile } from 'node:
 import { resolve, join, dirname, relative } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import yaml from 'js-yaml';
+import { initDatabase, getContext, AutoSaveManager } from '../memory/index.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const SCHEMAS_DIR = resolve(__dirname, '../schemas');
@@ -475,6 +476,21 @@ export async function getArtifactInstructions(artifactId, changeName, cwd = proc
   // Determine what this artifact unlocks
   const unlocks = artifact.unlocks || [];
 
+  // NUEVO: Recuperar contexto de memoria relevante
+  let relevantMemories = [];
+  try {
+    initDatabase(); // Asegurar DB inicializada
+    relevantMemories = getContext({
+      projectPath: cwd,
+      changeName,
+      limit: 5,
+      lookbackDays: 30
+    });
+  } catch {
+    // Si memory no está inicializado, continuar sin contexto
+    relevantMemories = [];
+  }
+
   return {
     context,
     rules,
@@ -483,6 +499,14 @@ export async function getArtifactInstructions(artifactId, changeName, cwd = proc
     outputPath,
     dependencies,
     unlocks,
+    // NUEVO: Memorias relevantes para el contexto del agente
+    relevantMemories: relevantMemories.map(m => ({
+      id: m.id,
+      type: m.type,
+      content: m.content,
+      importance: m.importance,
+      fromChange: m.changeName
+    }))
   };
 }
 
@@ -583,12 +607,56 @@ export async function getApplyInstructions(changeName, cwd = process.cwd()) {
     instruction = `${remaining} of ${total} tasks remaining. Implement each pending task, following the specs and design. Mark tasks as [x] when complete.`;
   }
 
+  // NUEVO: Recuperar contexto de memoria relevante para implementación
+  let relevantMemories = [];
+  let suggestedPatterns = [];
+  try {
+    initDatabase();
+    
+    // Buscar patrones similares en memorias
+    relevantMemories = getContext({
+      projectPath: cwd,
+      changeName,
+      limit: 5,
+      lookbackDays: 30
+    });
+
+    // Buscar patrones de implementación específicos
+    const pendingTasks = tasks.filter(t => !t.done).map(t => t.task).join(' ');
+    if (pendingTasks) {
+      // Buscar memorias relacionadas con las tareas pendientes
+      const keywords = pendingTasks.toLowerCase().split(/\s+/).filter(w => w.length > 4);
+      if (keywords.length > 0) {
+        const { searchMemories } = await import('../memory/index.js');
+        suggestedPatterns = searchMemories(keywords.slice(0, 5).join(' OR '), {
+          type: 'refactor_technique',
+          limit: 3
+        });
+      }
+    }
+  } catch {
+    // Continuar sin contexto si hay error
+  }
+
   return {
     contextFiles,
     progress: { total, complete, remaining },
     state,
     instruction,
     tasks,
+    // NUEVO: Contexto de memoria para ayudar en implementación
+    relevantMemories: relevantMemories.map(m => ({
+      id: m.id,
+      type: m.type,
+      content: m.content,
+      importance: m.importance,
+      codeSnippet: m.codeSnippet
+    })),
+    suggestedPatterns: suggestedPatterns.map(m => ({
+      id: m.id,
+      content: m.content,
+      type: m.type
+    }))
   };
 }
 
@@ -607,7 +675,7 @@ export async function archiveChange(name, cwd = process.cwd()) {
     throw new Error(`Change "${name}" not found.`);
   }
 
-  const archiveDir = join(changesDir(cwd), 'archive');
+  const archiveDir = join(await changesDir(cwd), 'archive');
   await mkdir(archiveDir, { recursive: true });
 
   const dateStr = new Date().toISOString().slice(0, 10); // YYYY-MM-DD