ac-framework 1.6.0 → 1.8.0

package/src/commands/spec.js

@@ -1,7 +1,8 @@
 /**
  * spec.js — `acfm spec` command group.
  *
- * Replaces the external `openspec` CLI with built-in commands.
+ * AC Framework Spec-Driven Development Workflow
+ * Supports both .acfm/ (new) and openspec/ (legacy) directories for backward compatibility.
  * All commands support --json for machine-readable output (used by skills).
  */
 
@@ -35,26 +36,36 @@ function output(data, json) {
  */
 export function specCommand() {
   const spec = new Command('spec')
-    .description('Spec-driven development workflow (replaces openspec CLI)');
+    .description('AC Framework spec-driven development workflow');
 
   // ─── acfm spec init ──────────────────────────────────────────────────────
 
   spec
     .command('init')
-    .description('Initialize openspec/ directory structure in the current project')
+    .description('Initialize spec directory (.acfm/) in the current project')
     .option('--schema <schema>', 'Default workflow schema', 'spec-driven')
+    .option('--json', 'Output as JSON')
     .action(async (opts) => {
       try {
         const result = await initProject(process.cwd(), opts.schema);
+        if (opts.json) {
+          output(result, true);
+          return;
+        }
         if (result.created) {
-          console.log(chalk.green('Initialized openspec/ directory'));
+          console.log(chalk.green(`Initialized ${result.dirName}/ directory`));
           console.log(chalk.dim(`  Schema: ${opts.schema}`));
           console.log(chalk.dim(`  Path:   ${result.path}`));
+          console.log(chalk.dim(`\n  Legacy openspec/ directories are also supported for backward compatibility.`));
         } else {
-          console.log(chalk.yellow('openspec/ already initialized'));
+          console.log(chalk.yellow(`${result.dirName}/ already initialized`));
           console.log(chalk.dim(`  Path: ${result.path}`));
         }
       } catch (err) {
+        if (opts.json) {
+          output({ error: err.message }, true);
+          process.exit(1);
+        }
         console.error(chalk.red(`Error: ${err.message}`));
         process.exit(1);
       }
@@ -66,14 +77,23 @@ export function specCommand() {
     .command('new <name>')
     .description('Create a new change with scaffolded artifact files')
     .option('--schema <schema>', 'Workflow schema to use (overrides project default)')
+    .option('--json', 'Output as JSON')
     .action(async (name, opts) => {
       try {
         const result = await createChange(name, process.cwd(), opts.schema);
+        if (opts.json) {
+          output(result, true);
+          return;
+        }
         console.log(chalk.green(`Created change "${name}"`));
         console.log(chalk.dim(`  Schema:    ${result.schemaName}`));
         console.log(chalk.dim(`  Path:      ${result.changeDir}`));
         console.log(chalk.dim(`  Artifacts: ${result.artifacts.join(', ')}`));
       } catch (err) {
+        if (opts.json) {
+          output({ error: err.message }, true);
+          process.exit(1);
+        }
         console.error(chalk.red(`Error: ${err.message}`));
         process.exit(1);
       }
@@ -119,11 +139,14 @@ export function specCommand() {
             return;
           }
           if (!status.initialized) {
-            console.log(chalk.yellow('OpenSpec not initialized'));
+            console.log(chalk.yellow('Spec directory not initialized'));
             console.log(chalk.dim('Run: acfm spec init'));
+            console.log(chalk.dim('\nNote: Legacy openspec/ directories are automatically detected.'));
             return;
           }
-          console.log(chalk.bold('OpenSpec Status'));
+          const dirName = status.dirName || '.acfm';
+          console.log(chalk.bold('Spec Status'));
+          console.log(chalk.dim(`Directory: ${dirName}/`));
           console.log(chalk.dim(`Schema: ${status.schema}`));
           console.log(chalk.dim(`Active changes: ${status.activeChanges}`));
           if (status.changes.length > 0) {
@@ -241,12 +264,21 @@ export function specCommand() {
   spec
     .command('archive <name>')
     .description('Archive a completed change')
-    .action(async (name) => {
+    .option('--json', 'Output as JSON')
+    .action(async (name, opts) => {
       try {
         const result = await archiveChange(name, process.cwd());
+        if (opts.json) {
+          output(result, true);
+          return;
+        }
         console.log(chalk.green(`Archived "${name}"`));
         console.log(chalk.dim(`  Moved to: ${result.archivedTo}`));
       } catch (err) {
+        if (opts.json) {
+          output({ error: err.message }, true);
+          process.exit(1);
+        }
         console.error(chalk.red(`Error: ${err.message}`));
         process.exit(1);
       }

package/src/config/constants.js

@@ -9,20 +9,25 @@ export const GITHUB_CONFIG = {
 };
 
 // Modules that are always installed regardless of user selection.
-export const ALWAYS_INSTALL = ['openspec'];
+// Note: The spec-driven workflow is now built into acfm CLI.
+// Users run `acfm spec init` to create the spec directory (default: .acfm/)
+// Legacy openspec/ directories are still supported for backward compatibility.
+export const ALWAYS_INSTALL = [];
 
 // When a key module is selected, its bundled companions are auto-installed.
 export const BUNDLED = {
   '.cline': ['.clinerules'],
+  '.antigravity': ['.agent'],  // Antigravity uses .agent/skills/ directory
 };
 
 // Folders that should never appear in the selection list because they are
 // installed automatically as part of a bundled assistant.
-export const HIDDEN_FOLDERS = new Set(Object.values(BUNDLED).flat());
+export const HIDDEN_FOLDERS = new Set([...Object.values(BUNDLED).flat(), '.agent']);
 
 // Human-readable descriptions for each module, used in the selection UI.
 export const DESCRIPTIONS = {
   '.agent': 'Generic Agent Framework',
+  '.antigravity': 'Google Antigravity IDE (Agent-First)',
   '.amazonq': 'AWS Amazon Q',
   '.augment': 'Augment Code Assistant',
   '.claude': 'Anthropic Claude Code',
@@ -38,6 +43,7 @@ export const DESCRIPTIONS = {
   '.github': 'GitHub Copilot',
   '.iflow': 'iFlow Assistant',
   '.kilocode': 'Kilo Code',
+  '.kimi': 'Kimi Code Assistant',
   '.opencode': 'OpenCode Framework',
   '.qoder': 'Qoder Assistant',
   '.qwen': 'Qwen (Alibaba Cloud)',
@@ -50,6 +56,7 @@ export const DESCRIPTIONS = {
 // Icons for each assistant, used in the selection UI.
 export const ASSISTANT_ICONS = {
   '.agent': '⊡',
+  '.antigravity': '◉',
   '.amazonq': '◈',
   '.augment': '◇',
   '.claude': '◉',
@@ -65,6 +72,7 @@ export const ASSISTANT_ICONS = {
   '.github': '◈',
   '.iflow': '▹',
   '.kilocode': '◎',
+  '.kimi': '◉',
   '.opencode': '⊡',
   '.qoder': '◇',
   '.qwen': '◈',

package/src/config/ide-mapping.js

@@ -20,6 +20,7 @@ export const IDE_MD_MAP = {
   '.github': 'copilot-instructions.md',
   '.iflow': 'AGENTS.md',
   '.kilocode': 'AGENTS.md',
+  '.kimi': 'AGENTS.md',
   '.opencode': 'AGENTS.md',
   '.qoder': 'AGENTS.md',
   '.qwen': 'QWEN.md',

package/src/index.js

@@ -18,3 +18,49 @@ export {
   readProjectConfig,
   isInitialized,
 } from './services/spec-engine.js';
+
+// Memory System Exports
+export {
+  // Database
+  initDatabase,
+  getDatabase,
+  closeDatabase,
+  isDatabaseInitialized,
+  
+  // Core Engine
+  saveMemory,
+  searchMemories,
+  getContext,
+  getTimeline,
+  getMemory,
+  updateMemory,
+  deleteMemory,
+  startSession,
+  endSession,
+  getStats,
+  findPatterns,
+  getConnections,
+  anticipateNeeds,
+  exportMemories,
+  importMemories,
+  pruneMemories,
+  
+  // Auto-save
+  AutoSaveManager,
+  createAutoSaveHook,
+  WorkflowHooks,
+  
+  // Utils
+  redactPrivateContent,
+  extractKeywords,
+  textSimilarity,
+  truncate,
+  isCodeContent,
+  detectLanguage,
+  generateSummary,
+  sanitizeFTSQuery,
+  
+  // Constants
+  MEMORY_TYPES,
+  IMPORTANCE_LEVELS
+} from './memory/index.js';

package/src/memory/autosave.js

@@ -0,0 +1,382 @@
+/**
+ * autosave.js — Sistema de auto-guardado autónomo
+ * 
+ * Detecta automáticamente qué información es valiosa
+ * y la guarda sin intervención humana.
+ */
+
+import { saveMemory, searchMemories } from './engine.js';
+import { extractKeywords, isCodeContent, textSimilarity } from './utils.js';
+
+/**
+ * Manager de auto-save que se integra con el workflow
+ */
+export class AutoSaveManager {
+  constructor(options = {}) {
+    this.sessionId = options.sessionId;
+    this.projectPath = options.projectPath;
+    this.changeName = options.changeName;
+    this.author = options.author || 'ac-agent';
+    this.minConfidence = options.minConfidence || 0.5;
+    this.enabled = options.enabled !== false;
+    
+    // Buffer de contexto para análisis
+    this.contextBuffer = [];
+    this.maxBufferSize = 10;
+  }
+
+  /**
+   * Evalúa si un contenido debe ser guardado
+   */
+  shouldSave(content, context = {}) {
+    if (!this.enabled) return { shouldSave: false, reason: 'disabled' };
+    if (!content || content.length < 20) return { shouldSave: false, reason: 'too_short' };
+    
+    const score = this.calculateSaveScore(content, context);
+    
+    return {
+      shouldSave: score >= this.minConfidence,
+      confidence: score,
+      reason: score >= this.minConfidence ? 'valuable_content' : 'low_score'
+    };
+  }
+
+  /**
+   * Calcula qué tan valioso es guardar este contenido
+   */
+  calculateSaveScore(content, context = {}) {
+    let score = 0.5;
+    const lowerContent = content.toLowerCase();
+    
+    // Decisiones explícitas
+    if (/decidimos|elegimos|optamos|vamos a usar|mejor usar|recomendamos/i.test(lowerContent)) {
+      score += 0.25;
+    }
+    
+    // Soluciones a problemas
+    if (/solución|fix|resuelve|solucionado|corregido|arreglado/i.test(lowerContent)) {
+      score += 0.2;
+    }
+    
+    // Problemas/evitación
+    if (/error|bug|issue|problema|cuidado con|evitar|no usar/i.test(lowerContent)) {
+      score += 0.15;
+    }
+    
+    // Optimizaciones
+    if (/optimización|mejora|más rápido|performance|lento/i.test(lowerContent)) {
+      score += 0.15;
+    }
+    
+    // Arquitectura
+    if (/arquitectura|diseño|estructura|pattern|patrón/i.test(lowerContent)) {
+      score += 0.2;
+    }
+    
+    // Seguridad
+    if (/seguridad|security|vulnerabilidad|auth|autenticación/i.test(lowerContent)) {
+      score += 0.25;
+    }
+    
+    // Contiene código valioso
+    if (isCodeContent(content) && /ejemplo|example|snippet/i.test(lowerContent)) {
+      score += 0.1;
+    }
+    
+    // Contiene workaround
+    if (/workaround|temporal|mientras tanto|hack/i.test(lowerContent)) {
+      score += 0.15;
+    }
+    
+    // Contexto temporal (más tiempo = más valioso)
+    if (context.timeSpent) {
+      if (context.timeSpent > 30) score += 0.15;
+      else if (context.timeSpent > 10) score += 0.1;
+    }
+    
+    // Viene después de error
+    if (context.afterError) score += 0.1;
+    
+    // Es repetición de intentos
+    if (context.attemptCount && context.attemptCount > 2) score += 0.1;
+    
+    // Penalizaciones
+    
+    // Muy corto
+    if (content.length < 50) score -= 0.2;
+    
+    // Muy específico (IDs, nombres únicos)
+    if (/\b[0-9a-f]{8,}\b/i.test(content)) score -= 0.15; // UUIDs, hashes
+    if (/\buser_\d+|id_\d+\b/i.test(content)) score -= 0.1; // IDs específicos
+    
+    // Solo código sin explicación
+    if (isCodeContent(content) && !/[.!?]/.test(content)) score -= 0.1;
+    
+    // Contiene TODO/FIXME (temporal)
+    if (/TODO|FIXME|HACK|XXX/i.test(content)) score -= 0.2;
+    
+    return Math.max(0, Math.min(0.95, score));
+  }
+
+  /**
+   * Determina el tipo de memoria basado en contenido
+   */
+  detectType(content, context = {}) {
+    const lower = content.toLowerCase();
+    
+    if (context.typeHint) return context.typeHint;
+    
+    if (/bug|error|fix|corregido|arreglado|solucionado/i.test(lower)) {
+      if (/seguridad|security|vulnerabilidad/i.test(lower)) return 'security_fix';
+      return 'bugfix_pattern';
+    }
+    
+    if (/decidimos|elegimos|optamos|arquitectura|diseño/i.test(lower)) {
+      return 'architectural_decision';
+    }
+    
+    if (/refactor|reestructurar|limpiar|simplificar/i.test(lower)) {
+      return 'refactor_technique';
+    }
+    
+    if (/performance|lento|rápido|optimización|mejora/i.test(lower)) {
+      return 'performance_insight';
+    }
+    
+    if (/api|endpoint|route|controller/i.test(lower)) {
+      return 'api_pattern';
+    }
+    
+    if (/dependencia|package|librería|npm|install/i.test(lower)) {
+      return 'dependency_note';
+    }
+    
+    if (/workaround|temporal|mientras tanto/i.test(lower)) {
+      return 'workaround';
+    }
+    
+    if (/convención|estilo|nomenclatura|naming/i.test(lower)) {
+      return 'convention';
+    }
+    
+    if (/no debe|nunca|siempre|evitar|cuidado/i.test(lower)) {
+      return 'context_boundary';
+    }
+    
+    return 'general_insight';
+  }
+
+  /**
+   * Guarda una memoria si pasa el filtro de confianza
+   */
+  async autoSave(content, context = {}) {
+    const decision = this.shouldSave(content, context);
+    
+    if (!decision.shouldSave) {
+      return { saved: false, reason: decision.reason, confidence: decision.confidence };
+    }
+    
+    const type = this.detectType(content, context);
+    const tags = context.tags || extractKeywords(content);
+    
+    const result = saveMemory({
+      content,
+      type,
+      projectPath: this.projectPath,
+      changeName: this.changeName,
+      sessionId: this.sessionId,
+      author: this.author,
+      confidence: decision.confidence,
+      tags,
+      codeSnippet: context.codeSnippet,
+      errorMessage: context.errorMessage,
+      solution: context.solution,
+      shareable: context.shareable !== false
+    });
+    
+    return {
+      saved: true,
+      id: result.id,
+      operation: result.operation,
+      type,
+      confidence: decision.confidence
+    };
+  }
+
+  /**
+   * Guarda en buffer para análisis posterior
+   */
+  bufferContext(context) {
+    this.contextBuffer.push({
+      ...context,
+      timestamp: Date.now()
+    });
+    
+    if (this.contextBuffer.length > this.maxBufferSize) {
+      this.contextBuffer.shift();
+    }
+  }
+
+  /**
+   * Analiza buffer para detectar patrones
+   */
+  analyzeBuffer() {
+    if (this.contextBuffer.length < 3) return null;
+    
+    const recent = this.contextBuffer.slice(-3);
+    
+    // Detectar patrón de error -> fix
+    const hasError = recent.some(c => c.type === 'error' || c.hasError);
+    const hasFix = recent.some(c => c.type === 'fix' || c.isFix);
+    
+    if (hasError && hasFix) {
+      return {
+        pattern: 'error_to_fix',
+        confidence: 0.8,
+        context: recent
+      };
+    }
+    
+    return null;
+  }
+
+  /**
+   * Recupera contexto relevante antes de empezar tarea
+   */
+  async recallForTask(task, options = {}) {
+    const keywords = extractKeywords(task, 8);
+    const query = keywords.join(' OR ');
+    
+    const results = searchMemories(query, {
+      projectPath: this.projectPath,
+      limit: options.limit || 5,
+      minConfidence: 0.6,
+      sessionId: this.sessionId
+    });
+    
+    return results;
+  }
+
+  /**
+   * Sugiere memorias relacionadas a una existente
+   */
+  suggestRelated(memoryId, content) {
+    const keywords = extractKeywords(content, 5);
+    return searchMemories(keywords.join(' OR '), {
+      limit: 3,
+      sessionId: this.sessionId
+    }).filter(m => m.id !== memoryId);
+  }
+}
+
+/**
+ * Crea un hook de auto-save para un evento específico
+ */
+export function createAutoSaveHook(event, handler) {
+  return {
+    event,
+    handler: async (data, context) => {
+      const manager = context.autoSaveManager;
+      if (!manager) return handler(data, context);
+      
+      const result = await handler(data, context);
+      
+      // Si el handler retorna contenido para guardar
+      if (result && result.memoryContent) {
+        const saveResult = await manager.autoSave(result.memoryContent, {
+          typeHint: result.memoryType,
+          ...result.memoryContext
+        });
+        
+        return { ...result, autoSave: saveResult };
+      }
+      
+      return result;
+    }
+  };
+}
+
+// Hooks predefinidos para workflow spec-driven
+export const WorkflowHooks = {
+  /**
+   * Hook post-proposal: guarda decisiones arquitectónicas
+   */
+  afterProposal: (manager) => async (proposalData) => {
+    const content = `Arquitectura decidida: ${proposalData.title || 'N/A'}. ${proposalData.description || ''}`;
+    
+    return {
+      memoryContent: content,
+      memoryType: 'architectural_decision',
+      memoryContext: {
+        importance: 'high',
+        tags: ['proposal', 'architecture']
+      }
+    };
+  },
+
+  /**
+   * Hook post-design: guarda patrones técnicos
+   */
+  afterDesign: (manager) => async (designData) => {
+    const content = `Patrón de diseño: ${designData.approach || 'N/A'}. ${designData.rationale || ''}`;
+    
+    return {
+      memoryContent: content,
+      memoryType: 'architectural_decision',
+      memoryContext: {
+        importance: 'high',
+        tags: ['design', 'pattern']
+      }
+    };
+  },
+
+  /**
+   * Hook post-bugfix: guarda solución
+   */
+  afterBugfix: (manager) => async (bugfixData) => {
+    const content = `Bug resuelto: ${bugfixData.description}. Solución: ${bugfixData.solution}`;
+    
+    return {
+      memoryContent: content,
+      memoryType: bugfixData.security ? 'security_fix' : 'bugfix_pattern',
+      memoryContext: {
+        errorMessage: bugfixData.error,
+        solution: bugfixData.solution,
+        codeSnippet: bugfixData.codeSnippet,
+        importance: 'high'
+      }
+    };
+  },
+
+  /**
+   * Hook post-refactor: guarda técnica
+   */
+  afterRefactor: (manager) => async (refactorData) => {
+    const content = `Refactor: ${refactorData.description}. Beneficio: ${refactorData.benefit}`;
+    
+    return {
+      memoryContent: content,
+      memoryType: 'refactor_technique',
+      memoryContext: {
+        codeSnippet: refactorData.beforeAfter,
+        importance: 'medium'
+      }
+    };
+  },
+
+  /**
+   * Hook post-optimization: guarda insight de performance
+   */
+  afterOptimization: (manager) => async (optData) => {
+    const content = `Optimización: ${optData.description}. Mejora: ${optData.improvement}`;
+    
+    return {
+      memoryContent: content,
+      memoryType: 'performance_insight',
+      memoryContext: {
+        importance: 'medium',
+        tags: ['performance', 'optimization']
+      }
+    };
+  }
+};