claude-flow 2.0.0-alpha.45 → 2.0.0-alpha.49

package/src/memory/enhanced-memory.js.bak

@@ -0,0 +1,348 @@
+/**
+ * Enhanced Memory Functions for Comprehensive Swarm Coordination
+ */
+
+import { FallbackMemoryStore } from './fallback-store.js';
+
+export class EnhancedMemory extends FallbackMemoryStore {
+  constructor(options = {}) {
+    super(options);
+  }
+
+  async initialize() {
+    await super.initialize();
+    // Apply enhanced schema
+    try {
+      const { readFileSync } = await import('fs');
+      const schemaPath = new URL('./enhanced-schema.sql', import.meta.url);
+      const schema = readFileSync(schemaPath, 'utf-8');
+      this.db.exec(schema);
+    } catch (error) {
+      console.error(`[${new Date().toISOString()}] ERROR [enhanced-memory] Failed to apply enhanced schema:`, error);
+      // Continue with basic schema only
+    }
+  }
+
+  // === SESSION MANAGEMENT ===
+  
+  async saveSessionState(sessionId, state) {
+    const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO session_state 
+      (session_id, user_id, project_path, active_branch, last_activity, state, context, environment)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    
+    return stmt.run(
+      sessionId,
+      state.userId || process.env.USER,
+      state.projectPath || process.cwd(),
+      state.activeBranch || 'main',
+      Date.now(),
+      state.state || 'active',
+      JSON.stringify(state.context || {}),
+      JSON.stringify(state.environment || process.env)
+    );
+  }
+
+  async resumeSession(sessionId) {
+    const stmt = this.db.prepare('SELECT * FROM session_state WHERE session_id = ?');
+    const session = stmt.get(sessionId);
+    if (session) {
+      session.context = JSON.parse(session.context);
+      session.environment = JSON.parse(session.environment);
+    }
+    return session;
+  }
+
+  async getActiveSessions() {
+    const stmt = this.db.prepare('SELECT * FROM active_sessions');
+    return stmt.all();
+  }
+
+  // === MCP TOOL TRACKING ===
+  
+  async trackToolUsage(toolName, args, result, executionTime, success = true, error = null) {
+    const stmt = this.db.prepare(`
+      INSERT INTO mcp_tool_usage 
+      (tool_name, session_id, arguments, result_summary, execution_time_ms, success, error_message)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `);
+    
+    return stmt.run(
+      toolName,
+      this.currentSessionId,
+      JSON.stringify(args),
+      result ? JSON.stringify(result).substring(0, 500) : null,
+      executionTime,
+      success ? 1 : 0,
+      error
+    );
+  }
+
+  async getToolStats() {
+    const stmt = this.db.prepare('SELECT * FROM tool_effectiveness');
+    return stmt.all();
+  }
+
+  // === TRAINING DATA ===
+  
+  async recordTrainingExample(patternType, inputContext, actionTaken, outcome, score, feedback = null) {
+    const stmt = this.db.prepare(`
+      INSERT INTO training_data 
+      (pattern_type, input_context, action_taken, outcome, success_score, model_version, feedback)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `);
+    
+    return stmt.run(
+      patternType,
+      JSON.stringify(inputContext),
+      JSON.stringify(actionTaken),
+      JSON.stringify(outcome),
+      score,
+      this.modelVersion || '1.0',
+      feedback
+    );
+  }
+
+  async getTrainingData(patternType, limit = 100) {
+    const stmt = this.db.prepare(`
+      SELECT * FROM training_data 
+      WHERE pattern_type = ? 
+      ORDER BY success_score DESC, timestamp DESC 
+      LIMIT ?
+    `);
+    return stmt.all(patternType, limit);
+  }
+
+  // === CODE PATTERNS ===
+  
+  async recordCodePattern(filePath, patternName, content, language) {
+    const stmt = this.db.prepare(`
+      INSERT INTO code_patterns (file_path, pattern_name, pattern_content, language, last_used)
+      VALUES (?, ?, ?, ?, ?)
+      ON CONFLICT(file_path, pattern_name) DO UPDATE SET
+        frequency = frequency + 1,
+        last_used = ?
+    `);
+    
+    const now = Date.now();
+    return stmt.run(filePath, patternName, content, language, now, now);
+  }
+
+  async findSimilarPatterns(language, limit = 10) {
+    const stmt = this.db.prepare(`
+      SELECT * FROM code_patterns 
+      WHERE language = ? 
+      ORDER BY effectiveness_score DESC, frequency DESC 
+      LIMIT ?
+    `);
+    return stmt.all(language, limit);
+  }
+
+  // === AGENT COLLABORATION ===
+  
+  async recordAgentInteraction(sourceAgent, targetAgent, messageType, content, taskId) {
+    const stmt = this.db.prepare(`
+      INSERT INTO agent_interactions 
+      (source_agent, target_agent, message_type, content, task_id, correlation_id)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `);
+    
+    const correlationId = `${taskId}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    return stmt.run(sourceAgent, targetAgent, messageType, JSON.stringify(content), taskId, correlationId);
+  }
+
+  async getAgentConversation(taskId) {
+    const stmt = this.db.prepare(`
+      SELECT * FROM agent_interactions 
+      WHERE task_id = ? 
+      ORDER BY timestamp ASC
+    `);
+    return stmt.all(taskId);
+  }
+
+  // === KNOWLEDGE GRAPH ===
+  
+  async addKnowledgeEntity(entityType, entityName, entityPath, relationships = [], metadata = {}) {
+    const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO knowledge_graph 
+      (entity_type, entity_name, entity_path, relationships, metadata, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `);
+    
+    return stmt.run(
+      entityType,
+      entityName,
+      entityPath,
+      JSON.stringify(relationships),
+      JSON.stringify(metadata),
+      Date.now()
+    );
+  }
+
+  async findRelatedEntities(entityName, depth = 1) {
+    // Simple implementation - could be enhanced with recursive CTEs
+    const stmt = this.db.prepare(`
+      SELECT * FROM knowledge_graph 
+      WHERE entity_name = ? OR relationships LIKE ?
+    `);
+    return stmt.all(entityName, `%"${entityName}"%`);
+  }
+
+  // === ERROR LEARNING ===
+  
+  async recordError(errorType, errorMessage, stackTrace, context, resolution = null) {
+    const stmt = this.db.prepare(`
+      INSERT INTO error_patterns 
+      (error_type, error_message, stack_trace, context, resolution)
+      VALUES (?, ?, ?, ?, ?)
+      ON CONFLICT(error_type, error_message) DO UPDATE SET
+        occurrence_count = occurrence_count + 1,
+        last_seen = strftime('%s', 'now'),
+        resolution = COALESCE(?, resolution)
+    `);
+    
+    return stmt.run(
+      errorType,
+      errorMessage,
+      stackTrace,
+      JSON.stringify(context),
+      resolution,
+      resolution
+    );
+  }
+
+  async getErrorSolutions(errorType) {
+    const stmt = this.db.prepare(`
+      SELECT * FROM error_patterns 
+      WHERE error_type = ? AND resolution IS NOT NULL
+      ORDER BY occurrence_count DESC
+    `);
+    return stmt.all(errorType);
+  }
+
+  // === TASK DEPENDENCIES ===
+  
+  async addTaskDependency(taskId, dependsOn, dependencyType = 'blocking') {
+    const stmt = this.db.prepare(`
+      INSERT INTO task_dependencies 
+      (task_id, depends_on, dependency_type, status)
+      VALUES (?, ?, ?, 'pending')
+    `);
+    
+    return stmt.run(taskId, dependsOn, dependencyType);
+  }
+
+  async updateDependencyStatus(taskId, dependsOn, status) {
+    const stmt = this.db.prepare(`
+      UPDATE task_dependencies 
+      SET status = ? 
+      WHERE task_id = ? AND depends_on = ?
+    `);
+    
+    return stmt.run(status, taskId, dependsOn);
+  }
+
+  async getTaskDependencies(taskId) {
+    const stmt = this.db.prepare(`
+      SELECT * FROM task_dependencies 
+      WHERE task_id = ?
+    `);
+    return stmt.all(taskId);
+  }
+
+  // === PERFORMANCE TRACKING ===
+  
+  async recordPerformance(operationType, details, duration, memoryUsed, cpuPercent) {
+    const stmt = this.db.prepare(`
+      INSERT INTO performance_benchmarks 
+      (operation_type, operation_details, duration_ms, memory_used_mb, cpu_percent, session_id)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `);
+    
+    return stmt.run(
+      operationType,
+      JSON.stringify(details),
+      duration,
+      memoryUsed,
+      cpuPercent,
+      this.currentSessionId
+    );
+  }
+
+  async getPerformanceTrends(operationType, days = 7) {
+    const stmt = this.db.prepare(`
+      SELECT DATE(timestamp, 'unixepoch') as date,
+             AVG(duration_ms) as avg_duration,
+             AVG(memory_used_mb) as avg_memory,
+             COUNT(*) as operation_count
+      FROM performance_benchmarks
+      WHERE operation_type = ? 
+        AND timestamp > strftime('%s', 'now', '-' || ? || ' days')
+      GROUP BY date
+      ORDER BY date DESC
+    `);
+    return stmt.all(operationType, days);
+  }
+
+  // === USER PREFERENCES ===
+  
+  async learnPreference(key, value, category, source = 'inferred', confidence = 0.8) {
+    const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO user_preferences 
+      (preference_key, preference_value, category, learned_from, confidence_score)
+      VALUES (?, ?, ?, ?, ?)
+    `);
+    
+    return stmt.run(key, value, category, source, confidence);
+  }
+
+  async getPreferences(category = null) {
+    if (category) {
+      const stmt = this.db.prepare('SELECT * FROM user_preferences WHERE category = ?');
+      return stmt.all(category);
+    } else {
+      const stmt = this.db.prepare('SELECT * FROM user_preferences');
+      return stmt.all();
+    }
+  }
+
+  // === UTILITY METHODS ===
+  
+  async getDatabaseStats() {
+    const tables = [
+      'memory_entries', 'session_state', 'mcp_tool_usage', 'training_data',
+      'code_patterns', 'agent_interactions', 'knowledge_graph', 'error_patterns',
+      'task_dependencies', 'performance_benchmarks', 'user_preferences'
+    ];
+    
+    const stats = {};
+    for (const table of tables) {
+      try {
+        const result = this.db.prepare(`SELECT COUNT(*) as count FROM ${table}`).get();
+        stats[table] = result.count;
+      } catch (e) {
+        stats[table] = 0;
+      }
+    }
+    
+    return stats;
+  }
+
+  async exportSessionData(sessionId) {
+    const data = {
+      session: await this.resumeSession(sessionId),
+      tools: this.db.prepare('SELECT * FROM mcp_tool_usage WHERE session_id = ?').all(sessionId),
+      performance: this.db.prepare('SELECT * FROM performance_benchmarks WHERE session_id = ?').all(sessionId),
+      interactions: this.db.prepare('SELECT * FROM agent_interactions WHERE correlation_id LIKE ?').all(`${sessionId}%`),
+      timestamp: new Date().toISOString()
+    };
+    
+    return data;
+  }
+}
+
+// Singleton instance
+export const enhancedMemory = new EnhancedMemory();
+
+export default EnhancedMemory;

package/src/memory/fallback-store.js

@@ -0,0 +1,93 @@
+/**
+ * Fallback memory store that tries SQLite first, then falls back to in-memory storage
+ * Designed to handle npx environments where native modules may fail to load
+ */
+
+import { SqliteMemoryStore } from './sqlite-store.js';
+import { InMemoryStore } from './in-memory-store.js';
+
+class FallbackMemoryStore {
+  constructor(options = {}) {
+    this.options = options;
+    this.primaryStore = null;
+    this.fallbackStore = null;
+    this.useFallback = false;
+    this.initializationAttempted = false;
+  }
+
+  async initialize() {
+    if (this.initializationAttempted) return;
+    this.initializationAttempted = true;
+
+    // First, try to initialize SQLite store
+    try {
+      this.primaryStore = new SqliteMemoryStore(this.options);
+      await this.primaryStore.initialize();
+      console.error(`[${new Date().toISOString()}] INFO [fallback-store] Successfully initialized SQLite store`);
+      this.useFallback = false;
+    } catch (error) {
+      console.error(`[${new Date().toISOString()}] WARN [fallback-store] SQLite initialization failed, falling back to in-memory store:`, error.message);
+      
+      // Fall back to in-memory store
+      this.fallbackStore = new InMemoryStore(this.options);
+      await this.fallbackStore.initialize();
+      this.useFallback = true;
+      
+      console.error(`[${new Date().toISOString()}] INFO [fallback-store] Using in-memory store (data will not persist across sessions)`);
+      console.error(`[${new Date().toISOString()}] INFO [fallback-store] To enable persistent storage, install the package locally: npm install claude-flow@alpha`);
+    }
+  }
+
+  get activeStore() {
+    return this.useFallback ? this.fallbackStore : this.primaryStore;
+  }
+
+  async store(key, value, options = {}) {
+    await this.initialize();
+    return this.activeStore.store(key, value, options);
+  }
+
+  async retrieve(key, options = {}) {
+    await this.initialize();
+    return this.activeStore.retrieve(key, options);
+  }
+
+  async list(options = {}) {
+    await this.initialize();
+    return this.activeStore.list(options);
+  }
+
+  async delete(key, options = {}) {
+    await this.initialize();
+    return this.activeStore.delete(key, options);
+  }
+
+  async search(pattern, options = {}) {
+    await this.initialize();
+    return this.activeStore.search(pattern, options);
+  }
+
+  async cleanup() {
+    await this.initialize();
+    return this.activeStore.cleanup();
+  }
+
+  close() {
+    if (this.primaryStore) {
+      this.primaryStore.close();
+    }
+    if (this.fallbackStore) {
+      this.fallbackStore.close();
+    }
+  }
+
+  isUsingFallback() {
+    return this.useFallback;
+  }
+}
+
+// Export a singleton instance for MCP server
+export const memoryStore = new FallbackMemoryStore();
+
+export { FallbackMemoryStore };
+export default FallbackMemoryStore;

package/src/memory/in-memory-store.js

@@ -0,0 +1,210 @@
+/**
+ * In-memory store for environments where SQLite is not available
+ * Provides the same API as SQLite store but data is not persistent
+ */
+
+class InMemoryStore {
+  constructor(options = {}) {
+    this.options = options;
+    this.data = new Map(); // namespace -> Map(key -> entry)
+    this.isInitialized = false;
+    this.cleanupInterval = null;
+  }
+
+  async initialize() {
+    if (this.isInitialized) return;
+
+    // Initialize default namespace
+    this.data.set('default', new Map());
+    
+    // Start cleanup interval for expired entries
+    this.cleanupInterval = setInterval(() => {
+      this.cleanup().catch(err => 
+        console.error(`[${new Date().toISOString()}] ERROR [in-memory-store] Cleanup failed:`, err)
+      );
+    }, 60000); // Run cleanup every minute
+
+    this.isInitialized = true;
+    console.error(`[${new Date().toISOString()}] INFO [in-memory-store] Initialized in-memory store`);
+  }
+
+  _getNamespaceMap(namespace) {
+    if (!this.data.has(namespace)) {
+      this.data.set(namespace, new Map());
+    }
+    return this.data.get(namespace);
+  }
+
+  async store(key, value, options = {}) {
+    await this.initialize();
+    
+    const namespace = options.namespace || 'default';
+    const namespaceMap = this._getNamespaceMap(namespace);
+    
+    const now = Date.now();
+    const ttl = options.ttl || null;
+    const expiresAt = ttl ? now + (ttl * 1000) : null;
+    const valueStr = typeof value === 'string' ? value : JSON.stringify(value);
+    
+    const entry = {
+      key,
+      value: valueStr,
+      namespace,
+      metadata: options.metadata || null,
+      createdAt: namespaceMap.has(key) ? namespaceMap.get(key).createdAt : now,
+      updatedAt: now,
+      accessedAt: now,
+      accessCount: namespaceMap.has(key) ? namespaceMap.get(key).accessCount + 1 : 1,
+      ttl,
+      expiresAt
+    };
+
+    namespaceMap.set(key, entry);
+
+    return {
+      success: true,
+      id: `${namespace}:${key}`,
+      size: valueStr.length
+    };
+  }
+
+  async retrieve(key, options = {}) {
+    await this.initialize();
+    
+    const namespace = options.namespace || 'default';
+    const namespaceMap = this._getNamespaceMap(namespace);
+    
+    const entry = namespaceMap.get(key);
+    
+    if (!entry) {
+      return null;
+    }
+
+    // Check if expired
+    if (entry.expiresAt && entry.expiresAt < Date.now()) {
+      namespaceMap.delete(key);
+      return null;
+    }
+
+    // Update access stats
+    entry.accessedAt = Date.now();
+    entry.accessCount++;
+
+    // Try to parse as JSON, fall back to raw string
+    try {
+      return JSON.parse(entry.value);
+    } catch {
+      return entry.value;
+    }
+  }
+
+  async list(options = {}) {
+    await this.initialize();
+    
+    const namespace = options.namespace || 'default';
+    const limit = options.limit || 100;
+    const namespaceMap = this._getNamespaceMap(namespace);
+    
+    const entries = Array.from(namespaceMap.values())
+      .filter(entry => !entry.expiresAt || entry.expiresAt > Date.now())
+      .sort((a, b) => b.updatedAt - a.updatedAt)
+      .slice(0, limit);
+
+    return entries.map(entry => ({
+      key: entry.key,
+      value: this._tryParseJson(entry.value),
+      namespace: entry.namespace,
+      metadata: entry.metadata,
+      createdAt: new Date(entry.createdAt),
+      updatedAt: new Date(entry.updatedAt),
+      accessCount: entry.accessCount
+    }));
+  }
+
+  async delete(key, options = {}) {
+    await this.initialize();
+    
+    const namespace = options.namespace || 'default';
+    const namespaceMap = this._getNamespaceMap(namespace);
+    
+    return namespaceMap.delete(key);
+  }
+
+  async search(pattern, options = {}) {
+    await this.initialize();
+    
+    const namespace = options.namespace || 'default';
+    const limit = options.limit || 50;
+    const namespaceMap = this._getNamespaceMap(namespace);
+    
+    const searchLower = pattern.toLowerCase();
+    const results = [];
+
+    for (const [key, entry] of namespaceMap.entries()) {
+      // Skip expired entries
+      if (entry.expiresAt && entry.expiresAt < Date.now()) {
+        continue;
+      }
+
+      // Search in key and value
+      if (key.toLowerCase().includes(searchLower) || 
+          entry.value.toLowerCase().includes(searchLower)) {
+        results.push({
+          key: entry.key,
+          value: this._tryParseJson(entry.value),
+          namespace: entry.namespace,
+          score: entry.accessCount,
+          updatedAt: new Date(entry.updatedAt)
+        });
+      }
+
+      if (results.length >= limit) {
+        break;
+      }
+    }
+
+    // Sort by score (access count) and updated time
+    return results.sort((a, b) => {
+      if (a.score !== b.score) return b.score - a.score;
+      return b.updatedAt - a.updatedAt;
+    });
+  }
+
+  async cleanup() {
+    await this.initialize();
+    
+    let cleaned = 0;
+    const now = Date.now();
+
+    for (const [namespace, namespaceMap] of this.data.entries()) {
+      for (const [key, entry] of namespaceMap.entries()) {
+        if (entry.expiresAt && entry.expiresAt <= now) {
+          namespaceMap.delete(key);
+          cleaned++;
+        }
+      }
+    }
+
+    return cleaned;
+  }
+
+  _tryParseJson(value) {
+    try {
+      return JSON.parse(value);
+    } catch {
+      return value;
+    }
+  }
+
+  close() {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = null;
+    }
+    this.data.clear();
+    this.isInitialized = false;
+  }
+}
+
+export { InMemoryStore };
+export default InMemoryStore;

package/dist/__tests__/features/mocks/MockFeatureManager.d.ts

@@ -1,26 +0,0 @@
-/**
- * Mock FeatureManager for testing
- * Provides a mock implementation of the FeatureManager
- */
-export declare class MockFeatureManager {
-    private features;
-    private activeFeatures;
-    private activationOrder;
-    private deactivationOrder;
-    register: jest.Mock<any, any, any>;
-    activate: jest.Mock<any, any, any>;
-    deactivate: jest.Mock<any, any, any>;
-    configure: jest.Mock<any, any, any>;
-    getFeature: jest.Mock<any, any, any>;
-    isActive: jest.Mock<any, any, any>;
-    listFeatures: jest.Mock<any, any, any>;
-    getMetadata: jest.Mock<any, any, any>;
-    getActivationOrder(): string[];
-    getDeactivationOrder(): string[];
-    reset(): void;
-    private getDependentFeatures;
-    private wasActiveBeforeOperation;
-    private validateConfigMock;
-}
-export declare function createMockFeatureManager(): MockFeatureManager;
-//# sourceMappingURL=MockFeatureManager.d.ts.map

package/dist/__tests__/features/mocks/MockFeatureManager.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"MockFeatureManager.d.ts","sourceRoot":"","sources":["../../../../src/__tests__/features/mocks/MockFeatureManager.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,QAAQ,CAAmC;IACnD,OAAO,CAAC,cAAc,CAA0B;IAChD,OAAO,CAAC,eAAe,CAAgB;IACvC,OAAO,CAAC,iBAAiB,CAAgB;IAGzC,QAAQ,2BAeL;IAEH,QAAQ,2BAwCL;IAEH,UAAU,2BA2BP;IAEH,SAAS,2BAiBN;IAEH,UAAU,2BAEP;IAEH,QAAQ,2BAEL;IAEH,YAAY,2BAYT;IAEH,WAAW,2BAeR;IAGH,kBAAkB,IAAI,MAAM,EAAE;IAI9B,oBAAoB,IAAI,MAAM,EAAE;IAIhC,KAAK,IAAI,IAAI;IASb,OAAO,CAAC,oBAAoB;IAY5B,OAAO,CAAC,wBAAwB;IAMhC,OAAO,CAAC,kBAAkB;CAuC3B;AAGD,wBAAgB,wBAAwB,IAAI,kBAAkB,CAE7D"}