claude-flow 2.0.0-alpha.62 → 2.0.0-alpha.64

package/src/cli/simple-commands/hive-mind/session-manager.js

@@ -3,25 +3,77 @@
  * Handles session persistence and resume functionality for swarms
  */
 
-import Database from 'better-sqlite3';
 import path from 'path';
 import { existsSync, mkdirSync } from 'fs';
 import { readFile, writeFile } from 'fs/promises';
 import chalk from 'chalk';
 import { cwd } from '../../node-compat.js';
+import { createDatabase, isSQLiteAvailable, isWindows } from '../../../memory/sqlite-wrapper.js';
 
 export class HiveMindSessionManager {
   constructor(hiveMindDir = null) {
     this.hiveMindDir = hiveMindDir || path.join(cwd(), '.hive-mind');
     this.sessionsDir = path.join(this.hiveMindDir, 'sessions');
     this.dbPath = path.join(this.hiveMindDir, 'hive.db');
+    this.db = null;
+    this.isInMemory = false;
+    this.memoryStore = null;
 
     // Ensure directories exist
     this.ensureDirectories();
 
     // Initialize database connection
-    this.db = new Database(this.dbPath);
-    this.initializeSchema();
+    this.initializeDatabase();
+  }
+
+  /**
+   * Initialize database with fallback support
+   */
+  async initializeDatabase() {
+    try {
+      const sqliteAvailable = await isSQLiteAvailable();
+      
+      if (!sqliteAvailable) {
+        console.warn('SQLite not available, using in-memory session storage');
+        this.initializeInMemoryFallback();
+        return;
+      }
+
+      this.db = await createDatabase(this.dbPath);
+      this.initializeSchema();
+    } catch (error) {
+      console.error('Failed to create SQLite database:', error.message);
+      console.warn('Falling back to in-memory session storage');
+      this.initializeInMemoryFallback();
+    }
+  }
+
+  /**
+   * Ensure database is initialized before use
+   */
+  async ensureInitialized() {
+    if (this.db === null && !this.isInMemory) {
+      await this.initializeDatabase();
+    }
+  }
+
+  /**
+   * Initialize in-memory fallback for session storage
+   */
+  initializeInMemoryFallback() {
+    this.isInMemory = true;
+    this.memoryStore = {
+      sessions: new Map(),
+      checkpoints: new Map(),
+      logs: new Map()
+    };
+    
+    if (isWindows()) {
+      console.info(`
+Note: Session data will not persist between runs on Windows without SQLite.
+To enable persistence, see: https://github.com/ruvnet/claude-code-flow/docs/windows-installation.md
+`);
+    }
   }
 
   /**
@@ -110,18 +162,38 @@ export class HiveMindSessionManager {
   /**
    * Create a new session for a swarm
    */
-  createSession(swarmId, swarmName, objective, metadata = {}) {
+  async createSession(swarmId, swarmName, objective, metadata = {}) {
+    await this.ensureInitialized();
+    
     const sessionId = `session-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
 
-    const stmt = this.db.prepare(`
-      INSERT INTO sessions (id, swarm_id, swarm_name, objective, metadata, parent_pid)
-      VALUES (?, ?, ?, ?, ?, ?)
-    `);
-
-    stmt.run(sessionId, swarmId, swarmName, objective, JSON.stringify(metadata), process.pid);
+    if (this.isInMemory) {
+      // Use in-memory storage
+      const sessionData = {
+        id: sessionId,
+        swarm_id: swarmId,
+        swarm_name: swarmName,
+        objective,
+        status: 'active',
+        created_at: new Date().toISOString(),
+        updated_at: new Date().toISOString(),
+        metadata: JSON.stringify(metadata),
+        parent_pid: process.pid,
+        child_pids: '[]'
+      };
+      this.memoryStore.sessions.set(sessionId, sessionData);
+    } else {
+      // Use SQLite
+      const stmt = this.db.prepare(`
+        INSERT INTO sessions (id, swarm_id, swarm_name, objective, metadata, parent_pid)
+        VALUES (?, ?, ?, ?, ?, ?)
+      `);
+
+      stmt.run(sessionId, swarmId, swarmName, objective, JSON.stringify(metadata), process.pid);
+    }
 
     // Log session creation
-    this.logSessionEvent(sessionId, 'info', 'Session created', null, {
+    await this.logSessionEvent(sessionId, 'info', 'Session created', null, {
       swarmId,
       swarmName,
       objective,
@@ -135,24 +207,49 @@ export class HiveMindSessionManager {
    * Save session checkpoint
    */
   async saveCheckpoint(sessionId, checkpointName, checkpointData) {
+    await this.ensureInitialized();
+    
     const checkpointId = `checkpoint-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
 
-    // Save to database
-    const stmt = this.db.prepare(`
-      INSERT INTO session_checkpoints (id, session_id, checkpoint_name, checkpoint_data)
-      VALUES (?, ?, ?, ?)
-    `);
-
-    stmt.run(checkpointId, sessionId, checkpointName, JSON.stringify(checkpointData));
-
-    // Update session checkpoint data and timestamp
-    const updateStmt = this.db.prepare(`
-      UPDATE sessions 
-      SET checkpoint_data = ?, updated_at = CURRENT_TIMESTAMP
-      WHERE id = ?
-    `);
-
-    updateStmt.run(JSON.stringify(checkpointData), sessionId);
+    if (this.isInMemory) {
+      // Use in-memory storage
+      const checkpointEntry = {
+        id: checkpointId,
+        session_id: sessionId,
+        checkpoint_name: checkpointName,
+        checkpoint_data: JSON.stringify(checkpointData),
+        created_at: new Date().toISOString()
+      };
+      
+      if (!this.memoryStore.checkpoints.has(sessionId)) {
+        this.memoryStore.checkpoints.set(sessionId, []);
+      }
+      this.memoryStore.checkpoints.get(sessionId).push(checkpointEntry);
+      
+      // Update session data
+      const session = this.memoryStore.sessions.get(sessionId);
+      if (session) {
+        session.checkpoint_data = JSON.stringify(checkpointData);
+        session.updated_at = new Date().toISOString();
+      }
+    } else {
+      // Save to database
+      const stmt = this.db.prepare(`
+        INSERT INTO session_checkpoints (id, session_id, checkpoint_name, checkpoint_data)
+        VALUES (?, ?, ?, ?)
+      `);
+
+      stmt.run(checkpointId, sessionId, checkpointName, JSON.stringify(checkpointData));
+
+      // Update session checkpoint data and timestamp
+      const updateStmt = this.db.prepare(`
+        UPDATE sessions 
+        SET checkpoint_data = ?, updated_at = CURRENT_TIMESTAMP
+        WHERE id = ?
+      `);
+
+      updateStmt.run(JSON.stringify(checkpointData), sessionId);
+    }
 
     // Save checkpoint file for backup
     const checkpointFile = path.join(this.sessionsDir, `${sessionId}-${checkpointName}.json`);
@@ -171,7 +268,7 @@ export class HiveMindSessionManager {
       ),
     );
 
-    this.logSessionEvent(sessionId, 'info', `Checkpoint saved: ${checkpointName}`, null, {
+    await this.logSessionEvent(sessionId, 'info', `Checkpoint saved: ${checkpointName}`, null, {
       checkpointId,
     });
 
@@ -181,38 +278,91 @@ export class HiveMindSessionManager {
   /**
    * Get active sessions
    */
-  getActiveSessions() {
-    const stmt = this.db.prepare(`
-      SELECT s.*, 
-             COUNT(DISTINCT a.id) as agent_count,
-             COUNT(DISTINCT t.id) as task_count,
-             SUM(CASE WHEN t.status = 'completed' THEN 1 ELSE 0 END) as completed_tasks
-      FROM sessions s
-      LEFT JOIN agents a ON s.swarm_id = a.swarm_id
-      LEFT JOIN tasks t ON s.swarm_id = t.swarm_id
-      WHERE s.status = 'active' OR s.status = 'paused'
-      GROUP BY s.id
-      ORDER BY s.updated_at DESC
-    `);
-
-    const sessions = stmt.all();
-
-    // Parse JSON fields
-    return sessions.map((session) => ({
-      ...session,
-      metadata: session.metadata ? JSON.parse(session.metadata) : {},
-      checkpoint_data: session.checkpoint_data ? JSON.parse(session.checkpoint_data) : null,
-      completion_percentage:
-        session.task_count > 0
-          ? Math.round((session.completed_tasks / session.task_count) * 100)
-          : 0,
-    }));
+  async getActiveSessions() {
+    await this.ensureInitialized();
+    
+    if (this.isInMemory) {
+      // Use in-memory storage
+      const sessions = [];
+      for (const [sessionId, session] of this.memoryStore.sessions) {
+        if (session.status === 'active' || session.status === 'paused') {
+          sessions.push({
+            ...session,
+            metadata: session.metadata ? JSON.parse(session.metadata) : {},
+            checkpoint_data: session.checkpoint_data ? JSON.parse(session.checkpoint_data) : null,
+            agent_count: 0, // Not tracked in memory mode
+            task_count: 0,  // Not tracked in memory mode
+            completed_tasks: 0, // Not tracked in memory mode
+            completion_percentage: 0
+          });
+        }
+      }
+      return sessions.sort((a, b) => new Date(b.updated_at) - new Date(a.updated_at));
+    } else {
+      // Use SQLite
+      const stmt = this.db.prepare(`
+        SELECT s.*, 
+               COUNT(DISTINCT a.id) as agent_count,
+               COUNT(DISTINCT t.id) as task_count,
+               SUM(CASE WHEN t.status = 'completed' THEN 1 ELSE 0 END) as completed_tasks
+        FROM sessions s
+        LEFT JOIN agents a ON s.swarm_id = a.swarm_id
+        LEFT JOIN tasks t ON s.swarm_id = t.swarm_id
+        WHERE s.status = 'active' OR s.status = 'paused'
+        GROUP BY s.id
+        ORDER BY s.updated_at DESC
+      `);
+
+      const sessions = stmt.all();
+
+      // Parse JSON fields
+      return sessions.map((session) => ({
+        ...session,
+        metadata: session.metadata ? JSON.parse(session.metadata) : {},
+        checkpoint_data: session.checkpoint_data ? JSON.parse(session.checkpoint_data) : null,
+        completion_percentage:
+          session.task_count > 0
+            ? Math.round((session.completed_tasks / session.task_count) * 100)
+            : 0,
+      }));
+    }
   }
 
   /**
    * Get session by ID with full details
    */
-  getSession(sessionId) {
+  async getSession(sessionId) {
+    await this.ensureInitialized();
+    
+    if (this.isInMemory) {
+      // Use in-memory storage
+      const session = this.memoryStore.sessions.get(sessionId);
+      if (!session) {
+        return null;
+      }
+      
+      // Return simplified session data for in-memory mode
+      return {
+        ...session,
+        metadata: session.metadata ? JSON.parse(session.metadata) : {},
+        checkpoint_data: session.checkpoint_data ? JSON.parse(session.checkpoint_data) : null,
+        swarm: null, // Not available in memory mode
+        agents: [], // Not available in memory mode
+        tasks: [], // Not available in memory mode
+        checkpoints: this.memoryStore.checkpoints.get(sessionId) || [],
+        recentLogs: this.memoryStore.logs.get(sessionId) || [],
+        statistics: {
+          totalAgents: 0,
+          activeAgents: 0,
+          totalTasks: 0,
+          completedTasks: 0,
+          pendingTasks: 0,
+          inProgressTasks: 0,
+          completionPercentage: session.completion_percentage || 0,
+        },
+      };
+    }
+
     const session = this.db
       .prepare(
         `
@@ -307,28 +457,45 @@ export class HiveMindSessionManager {
   /**
    * Pause a session
    */
-  pauseSession(sessionId) {
-    const stmt = this.db.prepare(`
-      UPDATE sessions 
-      SET status = 'paused', paused_at = CURRENT_TIMESTAMP, updated_at = CURRENT_TIMESTAMP
-      WHERE id = ?
-    `);
-
-    const result = stmt.run(sessionId);
-
-    if (result.changes > 0) {
-      this.logSessionEvent(sessionId, 'info', 'Session paused');
-
-      // Update swarm status
-      const session = this.db.prepare('SELECT swarm_id FROM sessions WHERE id = ?').get(sessionId);
+  async pauseSession(sessionId) {
+    await this.ensureInitialized();
+    
+    if (this.isInMemory) {
+      // Use in-memory storage
+      const session = this.memoryStore.sessions.get(sessionId);
       if (session) {
-        this.db
-          .prepare('UPDATE swarms SET status = ? WHERE id = ?')
-          .run('paused', session.swarm_id);
+        session.status = 'paused';
+        session.paused_at = new Date().toISOString();
+        session.updated_at = new Date().toISOString();
+        
+        await this.logSessionEvent(sessionId, 'info', 'Session paused');
+        return true;
+      }
+      return false;
+    } else {
+      // Use SQLite
+      const stmt = this.db.prepare(`
+        UPDATE sessions 
+        SET status = 'paused', paused_at = CURRENT_TIMESTAMP, updated_at = CURRENT_TIMESTAMP
+        WHERE id = ?
+      `);
+
+      const result = stmt.run(sessionId);
+
+      if (result.changes > 0) {
+        await this.logSessionEvent(sessionId, 'info', 'Session paused');
+
+        // Update swarm status
+        const session = this.db.prepare('SELECT swarm_id FROM sessions WHERE id = ?').get(sessionId);
+        if (session) {
+          this.db
+            .prepare('UPDATE swarms SET status = ? WHERE id = ?')
+            .run('paused', session.swarm_id);
+        }
       }
-    }
 
-    return result.changes > 0;
+      return result.changes > 0;
+    }
   }
 
   /**
@@ -452,13 +619,35 @@ export class HiveMindSessionManager {
   /**
    * Log session event
    */
-  logSessionEvent(sessionId, logLevel, message, agentId = null, data = null) {
-    const stmt = this.db.prepare(`
-      INSERT INTO session_logs (session_id, log_level, message, agent_id, data)
-      VALUES (?, ?, ?, ?, ?)
-    `);
-
-    stmt.run(sessionId, logLevel, message, agentId, data ? JSON.stringify(data) : null);
+  async logSessionEvent(sessionId, logLevel, message, agentId = null, data = null) {
+    await this.ensureInitialized();
+    
+    if (this.isInMemory) {
+      // Use in-memory storage for logs
+      const logId = `log-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+      const logEntry = {
+        id: logId,
+        session_id: sessionId,
+        timestamp: new Date().toISOString(),
+        log_level: logLevel,
+        message,
+        agent_id: agentId,
+        data: data ? JSON.stringify(data) : null
+      };
+      
+      if (!this.memoryStore.logs.has(sessionId)) {
+        this.memoryStore.logs.set(sessionId, []);
+      }
+      this.memoryStore.logs.get(sessionId).push(logEntry);
+    } else {
+      // Use SQLite
+      const stmt = this.db.prepare(`
+        INSERT INTO session_logs (session_id, log_level, message, agent_id, data)
+        VALUES (?, ?, ?, ?, ?)
+      `);
+
+      stmt.run(sessionId, logLevel, message, agentId, data ? JSON.stringify(data) : null);
+    }
   }
 
   /**
@@ -483,14 +672,26 @@ export class HiveMindSessionManager {
   /**
    * Update session progress
    */
-  updateSessionProgress(sessionId, completionPercentage) {
-    const stmt = this.db.prepare(`
-      UPDATE sessions 
-      SET completion_percentage = ?, updated_at = CURRENT_TIMESTAMP
-      WHERE id = ?
-    `);
-
-    stmt.run(completionPercentage, sessionId);
+  async updateSessionProgress(sessionId, completionPercentage) {
+    await this.ensureInitialized();
+    
+    if (this.isInMemory) {
+      // Use in-memory storage
+      const session = this.memoryStore.sessions.get(sessionId);
+      if (session) {
+        session.completion_percentage = completionPercentage;
+        session.updated_at = new Date().toISOString();
+      }
+    } else {
+      // Use SQLite
+      const stmt = this.db.prepare(`
+        UPDATE sessions 
+        SET completion_percentage = ?, updated_at = CURRENT_TIMESTAMP
+        WHERE id = ?
+      `);
+
+      stmt.run(completionPercentage, sessionId);
+    }
   }
 
   /**
@@ -652,33 +853,42 @@ export class HiveMindSessionManager {
   /**
    * Get all child PIDs for a session
    */
-  getChildPids(sessionId) {
-    const session = this.db.prepare('SELECT child_pids FROM sessions WHERE id = ?').get(sessionId);
-    if (!session || !session.child_pids) return [];
-
-    return JSON.parse(session.child_pids);
+  async getChildPids(sessionId) {
+    await this.ensureInitialized();
+    
+    if (this.isInMemory) {
+      // Use in-memory storage
+      const session = this.memoryStore.sessions.get(sessionId);
+      if (!session || !session.child_pids) return [];
+      return JSON.parse(session.child_pids);
+    } else {
+      // Use SQLite
+      const session = this.db.prepare('SELECT child_pids FROM sessions WHERE id = ?').get(sessionId);
+      if (!session || !session.child_pids) return [];
+      return JSON.parse(session.child_pids);
+    }
   }
 
   /**
    * Stop a session and terminate all child processes
    */
   async stopSession(sessionId) {
-    const session = this.getSession(sessionId);
+    const session = await this.getSession(sessionId);
     if (!session) {
       throw new Error(`Session ${sessionId} not found`);
     }
 
     // Get child PIDs
-    const childPids = this.getChildPids(sessionId);
+    const childPids = await this.getChildPids(sessionId);
 
     // Terminate child processes
     for (const pid of childPids) {
       try {
         process.kill(pid, 'SIGTERM');
-        this.logSessionEvent(sessionId, 'info', 'Child process terminated', null, { pid });
+        await this.logSessionEvent(sessionId, 'info', 'Child process terminated', null, { pid });
       } catch (err) {
         // Process might already be dead
-        this.logSessionEvent(sessionId, 'warning', 'Failed to terminate child process', null, {
+        await this.logSessionEvent(sessionId, 'warning', 'Failed to terminate child process', null, {
           pid,
           error: err.message,
         });
@@ -686,18 +896,28 @@ export class HiveMindSessionManager {
     }
 
     // Update session status
-    const stmt = this.db.prepare(`
-      UPDATE sessions 
-      SET status = 'stopped', updated_at = CURRENT_TIMESTAMP
-      WHERE id = ?
-    `);
+    if (this.isInMemory) {
+      // Use in-memory storage
+      const sessionData = this.memoryStore.sessions.get(sessionId);
+      if (sessionData) {
+        sessionData.status = 'stopped';
+        sessionData.updated_at = new Date().toISOString();
+      }
+    } else {
+      // Use SQLite
+      const stmt = this.db.prepare(`
+        UPDATE sessions 
+        SET status = 'stopped', updated_at = CURRENT_TIMESTAMP
+        WHERE id = ?
+      `);
 
-    stmt.run(sessionId);
+      stmt.run(sessionId);
 
-    // Update swarm status
-    this.db.prepare('UPDATE swarms SET status = ? WHERE id = ?').run('stopped', session.swarm_id);
+      // Update swarm status
+      this.db.prepare('UPDATE swarms SET status = ? WHERE id = ?').run('stopped', session.swarm_id);
+    }
 
-    this.logSessionEvent(sessionId, 'info', 'Session stopped');
+    await this.logSessionEvent(sessionId, 'info', 'Session stopped');
 
     return true;
   }
@@ -766,7 +986,9 @@ export class HiveMindSessionManager {
    * Clean up and close database connection
    */
   close() {
-    this.db.close();
+    if (this.db && !this.isInMemory) {
+      this.db.close();
+    }
   }
 }