ac-framework 1.7.0 → 1.8.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/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