moflo 4.0.1 → 4.0.3

package/v3/@claude-flow/memory/dist/database-provider.d.ts

@@ -0,0 +1,87 @@
+/**
+ * DatabaseProvider - Platform-aware database selection
+ *
+ * Automatically selects best backend:
+ * - Linux/macOS: better-sqlite3 (native, fast)
+ * - Windows: sql.js (WASM, universal) when native fails
+ * - Fallback: JSON file storage
+ *
+ * @module v3/memory/database-provider
+ */
+import { IMemoryBackend } from './types.js';
+/**
+ * Available database provider types
+ */
+export type DatabaseProvider = 'better-sqlite3' | 'sql.js' | 'json' | 'rvf' | 'auto';
+/**
+ * Database creation options
+ */
+export interface DatabaseOptions {
+    /** Preferred provider (auto = platform-aware selection) */
+    provider?: DatabaseProvider;
+    /** Enable verbose logging */
+    verbose?: boolean;
+    /** Enable WAL mode (better-sqlite3 only) */
+    walMode?: boolean;
+    /** Enable query optimization */
+    optimize?: boolean;
+    /** Default namespace */
+    defaultNamespace?: string;
+    /** Maximum entries before auto-cleanup */
+    maxEntries?: number;
+    /** Auto-persist interval for sql.js (milliseconds) */
+    autoPersistInterval?: number;
+    /** Path to sql.js WASM file */
+    wasmPath?: string;
+}
+/**
+ * Platform detection result
+ */
+interface PlatformInfo {
+    os: string;
+    isWindows: boolean;
+    isMacOS: boolean;
+    isLinux: boolean;
+    recommendedProvider: DatabaseProvider;
+}
+/**
+ * Create a database instance with platform-aware provider selection
+ *
+ * @param path - Database file path (:memory: for in-memory)
+ * @param options - Database configuration options
+ * @returns Initialized database backend
+ *
+ * @example
+ * ```typescript
+ * // Auto-select best provider for platform
+ * const db = await createDatabase('./data/memory.db');
+ *
+ * // Force specific provider
+ * const db = await createDatabase('./data/memory.db', {
+ *   provider: 'sql.js'
+ * });
+ *
+ * // With custom options
+ * const db = await createDatabase('./data/memory.db', {
+ *   verbose: true,
+ *   optimize: true,
+ *   autoPersistInterval: 10000
+ * });
+ * ```
+ */
+export declare function createDatabase(path: string, options?: DatabaseOptions): Promise<IMemoryBackend>;
+/**
+ * Get platform information
+ */
+export declare function getPlatformInfo(): PlatformInfo;
+/**
+ * Check which providers are available
+ */
+export declare function getAvailableProviders(): Promise<{
+    rvf: boolean;
+    betterSqlite3: boolean;
+    sqlJs: boolean;
+    json: boolean;
+}>;
+export {};
+//# sourceMappingURL=database-provider.d.ts.map

package/v3/@claude-flow/memory/dist/database-provider.js

@@ -0,0 +1,410 @@
+/**
+ * DatabaseProvider - Platform-aware database selection
+ *
+ * Automatically selects best backend:
+ * - Linux/macOS: better-sqlite3 (native, fast)
+ * - Windows: sql.js (WASM, universal) when native fails
+ * - Fallback: JSON file storage
+ *
+ * @module v3/memory/database-provider
+ */
+import { platform } from 'node:os';
+import { existsSync } from 'node:fs';
+import { SQLiteBackend } from './sqlite-backend.js';
+import { SqlJsBackend } from './sqljs-backend.js';
+/**
+ * Detect platform and recommend provider
+ */
+function detectPlatform() {
+    const os = platform();
+    const isWindows = os === 'win32';
+    const isMacOS = os === 'darwin';
+    const isLinux = os === 'linux';
+    // Recommend better-sqlite3 for Unix-like systems, sql.js for Windows
+    const recommendedProvider = isWindows ? 'sql.js' : 'better-sqlite3';
+    return {
+        os,
+        isWindows,
+        isMacOS,
+        isLinux,
+        recommendedProvider,
+    };
+}
+/**
+ * Test if RVF backend is available (always true — pure-TS fallback)
+ */
+async function testRvf() {
+    return true;
+}
+/**
+ * Test if better-sqlite3 is available and working
+ */
+async function testBetterSqlite3() {
+    try {
+        const Database = (await import('better-sqlite3')).default;
+        const testDb = new Database(':memory:');
+        testDb.close();
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+}
+/**
+ * Test if sql.js is available and working
+ */
+async function testSqlJs() {
+    try {
+        const initSqlJs = (await import('sql.js')).default;
+        const SQL = await initSqlJs();
+        const testDb = new SQL.Database();
+        testDb.close();
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+}
+/**
+ * Select best available provider
+ */
+async function selectProvider(preferred, verbose = false) {
+    if (preferred && preferred !== 'auto') {
+        if (verbose) {
+            console.log(`[DatabaseProvider] Using explicitly specified provider: ${preferred}`);
+        }
+        return preferred;
+    }
+    const platformInfo = detectPlatform();
+    if (verbose) {
+        console.log(`[DatabaseProvider] Platform detected: ${platformInfo.os}`);
+        console.log(`[DatabaseProvider] Recommended provider: ${platformInfo.recommendedProvider}`);
+    }
+    // Try RVF first (always available via pure-TS fallback, native when @ruvector/rvf installed)
+    if (await testRvf()) {
+        if (verbose) {
+            console.log('[DatabaseProvider] RVF backend available');
+        }
+        return 'rvf';
+    }
+    // Try recommended provider
+    if (platformInfo.recommendedProvider === 'better-sqlite3') {
+        if (await testBetterSqlite3()) {
+            if (verbose) {
+                console.log('[DatabaseProvider] better-sqlite3 available and working');
+            }
+            return 'better-sqlite3';
+        }
+        else if (verbose) {
+            console.log('[DatabaseProvider] better-sqlite3 not available, trying sql.js');
+        }
+    }
+    // Try sql.js as fallback
+    if (await testSqlJs()) {
+        if (verbose) {
+            console.log('[DatabaseProvider] sql.js available and working');
+        }
+        return 'sql.js';
+    }
+    else if (verbose) {
+        console.log('[DatabaseProvider] sql.js not available, using JSON fallback');
+    }
+    // Final fallback to JSON
+    return 'json';
+}
+/**
+ * Create a database instance with platform-aware provider selection
+ *
+ * @param path - Database file path (:memory: for in-memory)
+ * @param options - Database configuration options
+ * @returns Initialized database backend
+ *
+ * @example
+ * ```typescript
+ * // Auto-select best provider for platform
+ * const db = await createDatabase('./data/memory.db');
+ *
+ * // Force specific provider
+ * const db = await createDatabase('./data/memory.db', {
+ *   provider: 'sql.js'
+ * });
+ *
+ * // With custom options
+ * const db = await createDatabase('./data/memory.db', {
+ *   verbose: true,
+ *   optimize: true,
+ *   autoPersistInterval: 10000
+ * });
+ * ```
+ */
+export async function createDatabase(path, options = {}) {
+    const { provider = 'auto', verbose = false, walMode = true, optimize = true, defaultNamespace = 'default', maxEntries = 1000000, autoPersistInterval = 5000, wasmPath, } = options;
+    // Select provider
+    const selectedProvider = await selectProvider(provider, verbose);
+    if (verbose) {
+        console.log(`[DatabaseProvider] Creating database with provider: ${selectedProvider}`);
+        console.log(`[DatabaseProvider] Database path: ${path}`);
+    }
+    let backend;
+    switch (selectedProvider) {
+        case 'better-sqlite3': {
+            const config = {
+                databasePath: path,
+                walMode,
+                optimize,
+                defaultNamespace,
+                maxEntries,
+                verbose,
+            };
+            backend = new SQLiteBackend(config);
+            break;
+        }
+        case 'sql.js': {
+            const config = {
+                databasePath: path,
+                optimize,
+                defaultNamespace,
+                maxEntries,
+                verbose,
+                autoPersistInterval,
+                wasmPath,
+            };
+            backend = new SqlJsBackend(config);
+            break;
+        }
+        case 'rvf': {
+            const { RvfBackend } = await import('./rvf-backend.js');
+            backend = new RvfBackend({
+                databasePath: path.replace(/\.(db|json)$/, '.rvf'),
+                dimensions: 1536,
+                verbose,
+                defaultNamespace,
+                autoPersistInterval,
+            });
+            break;
+        }
+        case 'json': {
+            // Simple JSON file backend (minimal implementation)
+            backend = new JsonBackend(path, verbose);
+            break;
+        }
+        default:
+            throw new Error(`Unknown database provider: ${selectedProvider}`);
+    }
+    // Initialize the backend
+    await backend.initialize();
+    if (verbose) {
+        console.log(`[DatabaseProvider] Database initialized successfully`);
+    }
+    return backend;
+}
+/**
+ * Get platform information
+ */
+export function getPlatformInfo() {
+    return detectPlatform();
+}
+/**
+ * Check which providers are available
+ */
+export async function getAvailableProviders() {
+    return {
+        rvf: true,
+        betterSqlite3: await testBetterSqlite3(),
+        sqlJs: await testSqlJs(),
+        json: true,
+    };
+}
+// ===== JSON Fallback Backend =====
+/**
+ * Simple JSON file backend for when no SQLite is available
+ */
+class JsonBackend {
+    entries = new Map();
+    path;
+    verbose;
+    initialized = false;
+    constructor(path, verbose = false) {
+        this.path = path;
+        this.verbose = verbose;
+    }
+    async initialize() {
+        if (this.initialized)
+            return;
+        // Load from file if exists
+        if (this.path !== ':memory:' && existsSync(this.path)) {
+            try {
+                const fs = await import('node:fs/promises');
+                const data = await fs.readFile(this.path, 'utf-8');
+                const entries = JSON.parse(data);
+                for (const entry of entries) {
+                    // Convert embedding array back to Float32Array
+                    if (entry.embedding) {
+                        entry.embedding = new Float32Array(entry.embedding);
+                    }
+                    this.entries.set(entry.id, entry);
+                }
+                if (this.verbose) {
+                    console.log(`[JsonBackend] Loaded ${this.entries.size} entries from ${this.path}`);
+                }
+            }
+            catch (error) {
+                if (this.verbose) {
+                    console.error('[JsonBackend] Error loading file:', error);
+                }
+            }
+        }
+        this.initialized = true;
+    }
+    async shutdown() {
+        await this.persist();
+        this.initialized = false;
+    }
+    async store(entry) {
+        this.entries.set(entry.id, entry);
+        await this.persist();
+    }
+    async get(id) {
+        return this.entries.get(id) || null;
+    }
+    async getByKey(namespace, key) {
+        for (const entry of this.entries.values()) {
+            if (entry.namespace === namespace && entry.key === key) {
+                return entry;
+            }
+        }
+        return null;
+    }
+    async update(id, updateData) {
+        const entry = this.entries.get(id);
+        if (!entry)
+            return null;
+        const updated = { ...entry, ...updateData, updatedAt: Date.now(), version: entry.version + 1 };
+        this.entries.set(id, updated);
+        await this.persist();
+        return updated;
+    }
+    async delete(id) {
+        const result = this.entries.delete(id);
+        await this.persist();
+        return result;
+    }
+    async query(query) {
+        let results = Array.from(this.entries.values());
+        if (query.namespace) {
+            results = results.filter((e) => e.namespace === query.namespace);
+        }
+        if (query.key) {
+            results = results.filter((e) => e.key === query.key);
+        }
+        if (query.tags && query.tags.length > 0) {
+            results = results.filter((e) => query.tags.every((tag) => e.tags.includes(tag)));
+        }
+        return results.slice(0, query.limit);
+    }
+    async search(embedding, options) {
+        // Simple brute-force search
+        const results = [];
+        for (const entry of this.entries.values()) {
+            if (!entry.embedding)
+                continue;
+            const similarity = this.cosineSimilarity(embedding, entry.embedding);
+            if (options.threshold && similarity < options.threshold)
+                continue;
+            results.push({ entry, score: similarity, distance: 1 - similarity });
+        }
+        results.sort((a, b) => b.score - a.score);
+        return results.slice(0, options.k);
+    }
+    async bulkInsert(entries) {
+        for (const entry of entries) {
+            this.entries.set(entry.id, entry);
+        }
+        await this.persist();
+    }
+    async bulkDelete(ids) {
+        let count = 0;
+        for (const id of ids) {
+            if (this.entries.delete(id))
+                count++;
+        }
+        await this.persist();
+        return count;
+    }
+    async count(namespace) {
+        if (!namespace)
+            return this.entries.size;
+        let count = 0;
+        for (const entry of this.entries.values()) {
+            if (entry.namespace === namespace)
+                count++;
+        }
+        return count;
+    }
+    async listNamespaces() {
+        const namespaces = new Set();
+        for (const entry of this.entries.values()) {
+            namespaces.add(entry.namespace);
+        }
+        return Array.from(namespaces);
+    }
+    async clearNamespace(namespace) {
+        let count = 0;
+        for (const [id, entry] of this.entries.entries()) {
+            if (entry.namespace === namespace) {
+                this.entries.delete(id);
+                count++;
+            }
+        }
+        await this.persist();
+        return count;
+    }
+    async getStats() {
+        return {
+            totalEntries: this.entries.size,
+            entriesByNamespace: {},
+            entriesByType: {},
+            memoryUsage: 0,
+            avgQueryTime: 0,
+            avgSearchTime: 0,
+        };
+    }
+    async healthCheck() {
+        return {
+            status: 'healthy',
+            components: {
+                storage: { status: 'healthy', latency: 0 },
+                index: { status: 'healthy', latency: 0 },
+                cache: { status: 'healthy', latency: 0 },
+            },
+            timestamp: Date.now(),
+            issues: [],
+            recommendations: ['Consider using SQLite backend for better performance'],
+        };
+    }
+    async persist() {
+        if (this.path === ':memory:')
+            return;
+        const fs = await import('node:fs/promises');
+        const entries = Array.from(this.entries.values()).map((e) => ({
+            ...e,
+            // Convert Float32Array to regular array for JSON serialization
+            embedding: e.embedding ? Array.from(e.embedding) : undefined,
+        }));
+        await fs.writeFile(this.path, JSON.stringify(entries, null, 2));
+    }
+    cosineSimilarity(a, b) {
+        let dot = 0;
+        let normA = 0;
+        let normB = 0;
+        for (let i = 0; i < a.length; i++) {
+            dot += a[i] * b[i];
+            normA += a[i] * a[i];
+            normB += b[i] * b[i];
+        }
+        if (normA === 0 || normB === 0)
+            return 0;
+        return dot / (Math.sqrt(normA) * Math.sqrt(normB));
+    }
+}
+//# sourceMappingURL=database-provider.js.map

package/v3/@claude-flow/memory/dist/database-provider.test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Database Provider Tests - Cross-Platform Compatibility
+ *
+ * Tests for platform-aware database selection and fallback mechanisms
+ */
+export {};
+//# sourceMappingURL=database-provider.test.d.ts.map