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

package/src/hive-mind/core/DatabaseManager.ts

@@ -5,7 +5,6 @@
  * using SQLite as the persistence layer.
  */
 
-import Database from 'better-sqlite3';
 import path from 'path';
 import fs from 'fs/promises';
 import { EventEmitter } from 'events';
@@ -15,11 +14,25 @@ import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
+// Dynamic import for SQLite wrapper
+let createDatabase: any;
+let isSQLiteAvailable: any;
+let isWindows: any;
+
+async function loadSQLiteWrapper() {
+  const module = await import('../../memory/sqlite-wrapper.js');
+  createDatabase = module.createDatabase;
+  isSQLiteAvailable = module.isSQLiteAvailable;
+  isWindows = module.isWindows;
+}
+
 export class DatabaseManager extends EventEmitter {
   private static instance: DatabaseManager;
-  private db: Database.Database;
-  private statements: Map<string, Database.Statement>;
+  private db: any; // Database instance or in-memory fallback
+  private statements: Map<string, any>;
   private dbPath: string;
+  private isInMemory: boolean = false;
+  private memoryStore: any = null;
 
   private constructor() {
     super();
@@ -41,24 +54,70 @@ export class DatabaseManager extends EventEmitter {
    * Initialize database
    */
   async initialize(): Promise<void> {
-    // Ensure data directory exists
-    const dataDir = path.join(process.cwd(), 'data');
-    await fs.mkdir(dataDir, { recursive: true });
+    // Load SQLite wrapper functions
+    await loadSQLiteWrapper();
+    
+    // Check if SQLite is available
+    const sqliteAvailable = await isSQLiteAvailable();
+    
+    if (!sqliteAvailable) {
+      console.warn('SQLite not available, using in-memory storage for Hive Mind');
+      this.initializeInMemoryFallback();
+      return;
+    }
 
-    // Set database path
-    this.dbPath = path.join(dataDir, 'hive-mind.db');
+    try {
+      // Ensure data directory exists
+      const dataDir = path.join(process.cwd(), 'data');
+      await fs.mkdir(dataDir, { recursive: true });
 
-    // Open database
-    this.db = new Database(this.dbPath);
+      // Set database path
+      this.dbPath = path.join(dataDir, 'hive-mind.db');
 
-    // Enable foreign keys
-    this.db.pragma('foreign_keys = ON');
+      // Open database
+      this.db = await createDatabase(this.dbPath);
 
-    // Load schema
-    await this.loadSchema();
+      // Enable foreign keys
+      this.db.pragma('foreign_keys = ON');
 
-    // Prepare statements
-    this.prepareStatements();
+      // Load schema
+      await this.loadSchema();
+
+      // Prepare statements
+      this.prepareStatements();
+
+      this.emit('initialized');
+    } catch (error) {
+      console.error('Failed to initialize SQLite database:', error);
+      console.warn('Falling back to in-memory storage');
+      this.initializeInMemoryFallback();
+    }
+  }
+
+  /**
+   * Initialize in-memory fallback
+   */
+  private initializeInMemoryFallback(): void {
+    this.isInMemory = true;
+    this.memoryStore = {
+      swarms: new Map(),
+      agents: new Map(),
+      tasks: new Map(),
+      memory: new Map(),
+      communications: new Map(),
+      performance_metrics: new Map(),
+      consensus: new Map()
+    };
+
+    // Create mock statement methods
+    this.statements = new Map();
+    
+    if (isWindows && isWindows()) {
+      console.info(`
+Note: Hive Mind data will not persist between runs on Windows without SQLite.
+For persistent storage options, see: https://github.com/ruvnet/claude-code-flow/docs/windows-installation.md
+`);
+    }
 
     this.emit('initialized');
   }

package/src/memory/backends/sqlite.ts

@@ -2,7 +2,6 @@
  * SQLite backend implementation for memory storage
  */
 
-import Database from 'better-sqlite3';
 import { promises as fs } from 'fs';
 import path from 'path';
 import type { IMemoryBackend } from './base.js';
@@ -10,11 +9,16 @@ import type { MemoryEntry, MemoryQuery } from '../../utils/types.js';
 import type { ILogger } from '../../core/logger.js';
 import { MemoryBackendError } from '../../utils/errors.js';
 
+// Dynamic imports for SQLite
+let createDatabase: any;
+let isSQLiteAvailable: any;
+
 /**
  * SQLite-based memory backend
  */
 export class SQLiteBackend implements IMemoryBackend {
-  private db?: Database.Database;
+  private db?: any;
+  private sqliteLoaded: boolean = false;
 
   constructor(
     private dbPath: string,
@@ -25,12 +29,26 @@ export class SQLiteBackend implements IMemoryBackend {
     this.logger.info('Initializing SQLite backend', { dbPath: this.dbPath });
 
     try {
+      // Load SQLite wrapper if not loaded
+      if (!this.sqliteLoaded) {
+        const module = await import('../sqlite-wrapper.js');
+        createDatabase = module.createDatabase;
+        isSQLiteAvailable = module.isSQLiteAvailable;
+        this.sqliteLoaded = true;
+      }
+
+      // Check if SQLite is available
+      const sqliteAvailable = await isSQLiteAvailable();
+      if (!sqliteAvailable) {
+        throw new Error('SQLite module not available');
+      }
+
       // Ensure directory exists
       const dir = path.dirname(this.dbPath);
       await fs.mkdir(dir, { recursive: true });
 
       // Open SQLite connection
-      this.db = new Database(this.dbPath);
+      this.db = await createDatabase(this.dbPath);
 
       // Enable WAL mode for better performance
       this.db.pragma('journal_mode = WAL');

package/src/memory/fallback-store.js

@@ -5,6 +5,7 @@
 
 import { SqliteMemoryStore } from './sqlite-store.js';
 import { InMemoryStore } from './in-memory-store.js';
+import { isSQLiteAvailable, getLoadError, isWindows } from './sqlite-wrapper.js';
 
 class FallbackMemoryStore {
   constructor(options = {}) {
@@ -19,7 +20,27 @@ class FallbackMemoryStore {
     if (this.initializationAttempted) return;
     this.initializationAttempted = true;
 
-    // First, try to initialize SQLite store
+    // Check if SQLite is available before attempting initialization
+    const sqliteAvailable = await isSQLiteAvailable();
+    
+    if (!sqliteAvailable) {
+      // Skip SQLite initialization if module can't be loaded
+      const loadError = getLoadError();
+      console.error(
+        `[${new Date().toISOString()}] WARN [fallback-store] SQLite module not available:`,
+        loadError?.message || 'Unknown error',
+      );
+      
+      // Use in-memory store directly
+      this.fallbackStore = new InMemoryStore(this.options);
+      await this.fallbackStore.initialize();
+      this.useFallback = true;
+      
+      this._logFallbackUsage();
+      return;
+    }
+
+    // Try to initialize SQLite store
     try {
       this.primaryStore = new SqliteMemoryStore(this.options);
       await this.primaryStore.initialize();
@@ -29,7 +50,7 @@ class FallbackMemoryStore {
       this.useFallback = false;
     } catch (error) {
       console.error(
-        `[${new Date().toISOString()}] WARN [fallback-store] SQLite initialization failed, falling back to in-memory store:`,
+        `[${new Date().toISOString()}] WARN [fallback-store] SQLite initialization failed:`,
         error.message,
       );
 
@@ -38,9 +59,20 @@ class FallbackMemoryStore {
       await this.fallbackStore.initialize();
       this.useFallback = true;
 
+      this._logFallbackUsage();
+    }
+  }
+
+  _logFallbackUsage() {
+    console.error(
+      `[${new Date().toISOString()}] INFO [fallback-store] Using in-memory store (data will not persist across sessions)`,
+    );
+    
+    if (isWindows()) {
       console.error(
-        `[${new Date().toISOString()}] INFO [fallback-store] Using in-memory store (data will not persist across sessions)`,
+        `[${new Date().toISOString()}] INFO [fallback-store] Windows detected. For persistent storage options, see: https://github.com/ruvnet/claude-code-flow/docs/windows-installation.md`,
       );
+    } else {
       console.error(
         `[${new Date().toISOString()}] INFO [fallback-store] To enable persistent storage, install the package locally: npm install claude-flow@alpha`,
       );

package/src/memory/sqlite-store.js

@@ -3,12 +3,11 @@
  * Provides persistent storage that works with both local and remote npx execution
  */
 
-// @ts-ignore
-import Database from 'better-sqlite3';
 import path from 'path';
 import { promises as fs } from 'fs';
 import { fileURLToPath } from 'url';
 import os from 'os';
+import { createDatabase } from './sqlite-wrapper.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -54,7 +53,7 @@ class SqliteMemoryStore {
 
       // Open database
       const dbPath = path.join(this.options.directory, this.options.dbName);
-      this.db = new Database(dbPath);
+      this.db = await createDatabase(dbPath);
 
       // Enable WAL mode for better concurrency
       this.db.pragma('journal_mode = WAL');

package/src/memory/sqlite-wrapper.js

@@ -0,0 +1,173 @@
+/**
+ * SQLite Wrapper with Windows Fallback Support
+ * Provides graceful fallback when better-sqlite3 fails to load
+ */
+
+import { createRequire } from 'module';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+let Database = null;
+let sqliteAvailable = false;
+let loadError = null;
+
+/**
+ * Try to load better-sqlite3 with comprehensive error handling
+ */
+function tryLoadSQLite() {
+  try {
+    // Try ES module import
+    const module = import('better-sqlite3');
+    return module.then(m => {
+      Database = m.default;
+      sqliteAvailable = true;
+      return true;
+    }).catch(err => {
+      loadError = err;
+      return false;
+    });
+  } catch (err) {
+    // Fallback to CommonJS require
+    try {
+      const require = createRequire(import.meta.url);
+      Database = require('better-sqlite3');
+      sqliteAvailable = true;
+      return Promise.resolve(true);
+    } catch (requireErr) {
+      loadError = requireErr;
+      
+      // Check for specific Windows errors
+      if (requireErr.message.includes('was compiled against a different Node.js version') ||
+          requireErr.message.includes('Could not locate the bindings file') ||
+          requireErr.message.includes('The specified module could not be found') ||
+          requireErr.code === 'MODULE_NOT_FOUND') {
+        
+        console.warn(`
+╔══════════════════════════════════════════════════════════════════════════════╗
+║                     Windows SQLite Installation Issue                         ║
+╠══════════════════════════════════════════════════════════════════════════════╣
+║                                                                              ║
+║  The native SQLite module failed to load. This is common on Windows when    ║
+║  using 'npx' or when node-gyp build tools are not available.               ║
+║                                                                              ║
+║  Claude Flow will continue with in-memory storage (non-persistent).         ║
+║                                                                              ║
+║  To enable persistent storage on Windows:                                    ║
+║                                                                              ║
+║  Option 1 - Install Windows Build Tools:                                    ║
+║  > npm install --global windows-build-tools                                 ║
+║  > npm install claude-flow@alpha                                           ║
+║                                                                              ║
+║  Option 2 - Use Pre-built Binaries:                                        ║
+║  > npm config set python python3                                           ║
+║  > npm install claude-flow@alpha --build-from-source=false                 ║
+║                                                                              ║
+║  Option 3 - Use WSL (Windows Subsystem for Linux):                         ║
+║  Install WSL and run Claude Flow inside a Linux environment                 ║
+║                                                                              ║
+╚══════════════════════════════════════════════════════════════════════════════╝
+`);
+      }
+      
+      return Promise.resolve(false);
+    }
+  }
+}
+
+/**
+ * Check if SQLite is available
+ */
+export async function isSQLiteAvailable() {
+  if (sqliteAvailable !== null) {
+    return sqliteAvailable;
+  }
+  
+  await tryLoadSQLite();
+  return sqliteAvailable;
+}
+
+/**
+ * Get SQLite Database constructor or null
+ */
+export async function getSQLiteDatabase() {
+  if (!sqliteAvailable && loadError === null) {
+    await tryLoadSQLite();
+  }
+  
+  return Database;
+}
+
+/**
+ * Get the load error if any
+ */
+export function getLoadError() {
+  return loadError;
+}
+
+/**
+ * Create a SQLite database instance with fallback
+ */
+export async function createDatabase(dbPath) {
+  const DB = await getSQLiteDatabase();
+  
+  if (!DB) {
+    throw new Error('SQLite is not available. Use fallback storage instead.');
+  }
+  
+  try {
+    return new DB(dbPath);
+  } catch (err) {
+    // Additional Windows-specific error handling
+    if (err.message.includes('EPERM') || err.message.includes('access denied')) {
+      throw new Error(`Cannot create database at ${dbPath}. Permission denied. Try using a different directory or running with administrator privileges.`);
+    }
+    throw err;
+  }
+}
+
+/**
+ * Check if running on Windows
+ */
+export function isWindows() {
+  return process.platform === 'win32';
+}
+
+/**
+ * Get platform-specific storage recommendations
+ */
+export function getStorageRecommendations() {
+  if (isWindows()) {
+    return {
+      recommended: 'in-memory',
+      reason: 'Windows native module compatibility',
+      alternatives: [
+        'Install Windows build tools for SQLite support',
+        'Use WSL (Windows Subsystem for Linux)',
+        'Use Docker container with Linux'
+      ]
+    };
+  }
+  
+  return {
+    recommended: 'sqlite',
+    reason: 'Best performance and persistence',
+    alternatives: ['in-memory for testing']
+  };
+}
+
+// Pre-load SQLite on module import
+tryLoadSQLite().catch(() => {
+  // Silently handle initial load failure
+});
+
+export default {
+  isSQLiteAvailable,
+  getSQLiteDatabase,
+  getLoadError,
+  createDatabase,
+  isWindows,
+  getStorageRecommendations
+};