moflo 4.8.21 → 4.8.22

package/src/@claude-flow/memory/dist/agent-memory-scope.test.js

@@ -93,21 +93,18 @@ describe('resolveAgentMemoryDir', () => {
         process.env.USERPROFILE = originalUserProfile;
     });
     it('should resolve project scope to gitRoot/.claude/agent-memory/name/', () => {
-        // path.resolve() adds drive letter on Windows (e.g., C:\workspaces\...)
-        const projectRoot = path.resolve('/workspaces/my-project');
         mockExistsSync.mockImplementation((p) => {
-            return String(p) === path.join(projectRoot, '.git');
+            return String(p) === path.join('/workspaces/my-project', '.git');
         });
         const result = resolveAgentMemoryDir('coder', 'project', '/workspaces/my-project/src');
-        expect(result).toBe(path.join(projectRoot, '.claude', 'agent-memory', 'coder'));
+        expect(result).toBe(path.join('/workspaces/my-project', '.claude', 'agent-memory', 'coder'));
     });
     it('should resolve local scope to gitRoot/.claude/agent-memory-local/name/', () => {
-        const projectRoot = path.resolve('/workspaces/my-project');
         mockExistsSync.mockImplementation((p) => {
-            return String(p) === path.join(projectRoot, '.git');
+            return String(p) === path.join('/workspaces/my-project', '.git');
         });
         const result = resolveAgentMemoryDir('researcher', 'local', '/workspaces/my-project/src');
-        expect(result).toBe(path.join(projectRoot, '.claude', 'agent-memory-local', 'researcher'));
+        expect(result).toBe(path.join('/workspaces/my-project', '.claude', 'agent-memory-local', 'researcher'));
     });
     it('should resolve user scope to ~/.claude/agent-memory/name/', () => {
         process.env.HOME = '/home/testuser';

package/src/@claude-flow/memory/dist/agentdb-backend.d.ts

@@ -5,6 +5,7 @@
  * - HNSW vector search (150x-12,500x faster than brute-force)
  * - Native or WASM backend support with graceful fallback
  * - Optional dependency handling (works without hnswlib-node)
+ * - Seamless integration with HybridBackend
  *
  * @module v3/memory/agentdb-backend
  */
@@ -48,6 +49,7 @@ export interface AgentDBBackendConfig {
  * - Automatic fallback: native hnswlib → ruvector → WASM
  * - Graceful handling of optional native dependencies
  * - Semantic search with filtering
+ * - Compatible with HybridBackend for combined SQLite+AgentDB queries
  */
 export declare class AgentDBBackend extends EventEmitter implements IMemoryBackend {
     private config;

package/src/@claude-flow/memory/dist/agentdb-backend.js

@@ -5,6 +5,7 @@
  * - HNSW vector search (150x-12,500x faster than brute-force)
  * - Native or WASM backend support with graceful fallback
  * - Optional dependency handling (works without hnswlib-node)
+ * - Seamless integration with HybridBackend
  *
  * @module v3/memory/agentdb-backend
  */
@@ -57,6 +58,7 @@ const DEFAULT_CONFIG = {
  * - Automatic fallback: native hnswlib → ruvector → WASM
  * - Graceful handling of optional native dependencies
  * - Semantic search with filtering
+ * - Compatible with HybridBackend for combined SQLite+AgentDB queries
  */
 export class AgentDBBackend extends EventEmitter {
     config;
@@ -450,26 +452,26 @@ export class AgentDBBackend extends EventEmitter {
         }
         try {
             // Create memory_entries table
-            await db.run(`
-      CREATE TABLE IF NOT EXISTS memory_entries (
-        id TEXT PRIMARY KEY,
-        key TEXT NOT NULL,
-        content TEXT NOT NULL,
-        embedding BLOB,
-        type TEXT NOT NULL,
-        namespace TEXT NOT NULL,
-        tags TEXT,
-        metadata TEXT,
-        owner_id TEXT,
-        access_level TEXT NOT NULL,
-        created_at INTEGER NOT NULL,
-        updated_at INTEGER NOT NULL,
-        expires_at INTEGER,
-        version INTEGER NOT NULL,
-        references TEXT,
-        access_count INTEGER DEFAULT 0,
-        last_accessed_at INTEGER
-      )
+            await db.run(`
+      CREATE TABLE IF NOT EXISTS memory_entries (
+        id TEXT PRIMARY KEY,
+        key TEXT NOT NULL,
+        content TEXT NOT NULL,
+        embedding BLOB,
+        type TEXT NOT NULL,
+        namespace TEXT NOT NULL,
+        tags TEXT,
+        metadata TEXT,
+        owner_id TEXT,
+        access_level TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL,
+        expires_at INTEGER,
+        version INTEGER NOT NULL,
+        references TEXT,
+        access_count INTEGER DEFAULT 0,
+        last_accessed_at INTEGER
+      )
     `);
             // Create indexes
             await db.run('CREATE INDEX IF NOT EXISTS idx_namespace ON memory_entries(namespace)');
@@ -507,12 +509,12 @@ export class AgentDBBackend extends EventEmitter {
                 // Entry is already stored in-memory
                 return;
             }
-            await db.run(`
-      INSERT OR REPLACE INTO memory_entries
-      (id, key, content, embedding, type, namespace, tags, metadata, owner_id,
-       access_level, created_at, updated_at, expires_at, version, references,
-       access_count, last_accessed_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            await db.run(`
+      INSERT OR REPLACE INTO memory_entries
+      (id, key, content, embedding, type, namespace, tags, metadata, owner_id,
+       access_level, created_at, updated_at, expires_at, version, references,
+       access_count, last_accessed_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `, [
                 entry.id,
                 entry.key,

package/src/@claude-flow/memory/dist/auto-memory-bridge.test.js

@@ -64,8 +64,7 @@ function createTestInsight(overrides = {}) {
 describe('resolveAutoMemoryDir', () => {
     it('should derive path from working directory', () => {
         const result = resolveAutoMemoryDir('/workspaces/my-project');
-        // Use path.sep-aware check for cross-platform compatibility
-        expect(result).toMatch(/\.claude[/\\]projects[/\\]/);
+        expect(result).toContain('.claude/projects/');
         expect(result).toContain('memory');
         expect(result).not.toContain('//');
     });
@@ -80,33 +79,31 @@ describe('resolveAutoMemoryDir', () => {
     });
 });
 describe('findGitRoot', () => {
-    // Use the actual repo root (works on any platform)
-    const repoRoot = path.resolve(__dirname, '..', '..', '..', '..');
     it('should find git root for a directory inside a repo', () => {
-        const root = findGitRoot(path.join(repoRoot, 'src', '@claude-flow', 'memory'));
-        expect(root).toBe(repoRoot);
+        // We know /workspaces/claude-flow is a git repo
+        const root = findGitRoot('/workspaces/claude-flow/v3/@claude-flow/memory');
+        expect(root).toBe('/workspaces/claude-flow');
     });
     it('should return the directory itself if it is the git root', () => {
-        const root = findGitRoot(repoRoot);
-        expect(root).toBe(repoRoot);
+        const root = findGitRoot('/workspaces/claude-flow');
+        expect(root).toBe('/workspaces/claude-flow');
     });
-    it('should return null for non-git directory', () => {
-        // A temp or system dir unlikely to be in a git repo
-        const testDir = process.platform === 'win32' ? 'C:\\Windows\\Temp' : '/proc';
-        const result = findGitRoot(testDir);
+    it('should return null for root filesystem', () => {
+        // /proc is almost certainly not in a git repo
+        const result = findGitRoot('/proc');
         expect(result).toBeNull();
     });
 });
 describe('parseMarkdownEntries', () => {
     it('should parse markdown with ## headings into entries', () => {
-        const content = `# Main Title
-
-## Section One
-Content of section one.
-More content here.
-
-## Section Two
-Content of section two.
+        const content = `# Main Title
+
+## Section One
+Content of section one.
+More content here.
+
+## Section Two
+Content of section two.
 `;
         const entries = parseMarkdownEntries(content);
         expect(entries).toHaveLength(2);
@@ -120,10 +117,10 @@ Content of section two.
         expect(entries).toHaveLength(0);
     });
     it('should handle multiple lines under a heading', () => {
-        const content = `## Heading
-Line 1
-Line 2
-Line 3
+        const content = `## Heading
+Line 1
+Line 2
+Line 3
 `;
         const entries = parseMarkdownEntries(content);
         expect(entries).toHaveLength(1);
@@ -141,12 +138,12 @@ Line 3
 });
 describe('extractSummaries', () => {
     it('should extract bullet points from content', () => {
-        const content = `# Topic
-
-- First summary
-- Second summary
-- See \`details.md\` for more
-Some other text
+        const content = `# Topic
+
+- First summary
+- Second summary
+- See \`details.md\` for more
+Some other text
 `;
         const summaries = extractSummaries(content);
         expect(summaries).toHaveLength(2);
@@ -412,11 +409,11 @@ describe('AutoMemoryBridge', () => {
     });
     describe('importFromAutoMemory', () => {
         it('should import entries from existing markdown files', async () => {
-            const topicContent = `# Debugging Insights
-
-## Known Issues
-- Always init HNSW before search
-- SQLite WASM needs sql.js
+            const topicContent = `# Debugging Insights
+
+## Known Issues
+- Always init HNSW before search
+- SQLite WASM needs sql.js
 `;
             fsSync.writeFileSync(path.join(testDir, 'debugging.md'), topicContent, 'utf-8');
             const result = await bridge.importFromAutoMemory();
@@ -426,10 +423,10 @@ describe('AutoMemoryBridge', () => {
             expect(backend.bulkInsert).toHaveBeenCalled();
         });
         it('should skip entries already in AgentDB', async () => {
-            const topicContent = `# Test
-
-## Existing
-Already in DB
+            const topicContent = `# Test
+
+## Existing
+Already in DB
 `;
             fsSync.writeFileSync(path.join(testDir, 'test.md'), topicContent, 'utf-8');
             // Mock backend to return existing entry with matching content hash

package/src/@claude-flow/memory/dist/benchmark.test.js

@@ -241,7 +241,7 @@ describe('ADR-049 Performance Benchmarks', () => {
             resolveAgentMemoryDir(`agent-${i % 100}`, scopes[i % 3]);
         const dt = performance.now() - t0;
         console.log(`  Resolve 10k paths:  ${dt.toFixed(2)}ms  (${(dt / 10).toFixed(1)}us/each)`);
-        expect(dt).toBeLessThan(1000); // Not an ADR-049 target; relaxed for CI/full-suite variance
+        expect(dt).toBeLessThan(200); // Not an ADR-049 target; relaxed for CI variance
     });
     it('AgentMemoryScope: transfer knowledge', async () => {
         const sourceEntries = [];

package/src/@claude-flow/memory/dist/controller-registry.test.js

@@ -590,4 +590,47 @@ describe('ControllerRegistry', () => {
         });
     });
 });
+// ===== HybridBackend Proxy Methods Tests =====
+describe('HybridBackend proxy methods', () => {
+    it('should export recordFeedback method', async () => {
+        const { HybridBackend } = await import('./hybrid-backend.js');
+        const backend = new HybridBackend();
+        expect(typeof backend.recordFeedback).toBe('function');
+    });
+    it('should export verifyWitnessChain method', async () => {
+        const { HybridBackend } = await import('./hybrid-backend.js');
+        const backend = new HybridBackend();
+        expect(typeof backend.verifyWitnessChain).toBe('function');
+    });
+    it('should export getWitnessChain method', async () => {
+        const { HybridBackend } = await import('./hybrid-backend.js');
+        const backend = new HybridBackend();
+        expect(typeof backend.getWitnessChain).toBe('function');
+    });
+    it('should return false for recordFeedback when AgentDB unavailable', async () => {
+        const { HybridBackend } = await import('./hybrid-backend.js');
+        const backend = new HybridBackend();
+        await backend.initialize();
+        const result = await backend.recordFeedback('entry-1', { score: 0.9 });
+        expect(result).toBe(false);
+        await backend.shutdown();
+    });
+    it('should return invalid for verifyWitnessChain when AgentDB unavailable', async () => {
+        const { HybridBackend } = await import('./hybrid-backend.js');
+        const backend = new HybridBackend();
+        await backend.initialize();
+        const result = await backend.verifyWitnessChain('entry-1');
+        expect(result.valid).toBe(false);
+        expect(result.errors).toContain('AgentDB not available');
+        await backend.shutdown();
+    });
+    it('should return empty array for getWitnessChain when AgentDB unavailable', async () => {
+        const { HybridBackend } = await import('./hybrid-backend.js');
+        const backend = new HybridBackend();
+        await backend.initialize();
+        const result = await backend.getWitnessChain('entry-1');
+        expect(result).toEqual([]);
+        await backend.shutdown();
+    });
+});
 //# sourceMappingURL=controller-registry.test.js.map

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

@@ -2,7 +2,7 @@
  * DatabaseProvider - Platform-aware database selection
  *
  * Automatically selects best backend:
- * - All platforms: sql.js (WASM, no native deps)
+ * - Linux/macOS: better-sqlite3 (native, fast)
  * - Windows: sql.js (WASM, universal) when native fails
  * - Fallback: JSON file storage
  *
@@ -21,7 +21,7 @@ export interface DatabaseOptions {
     provider?: DatabaseProvider;
     /** Enable verbose logging */
     verbose?: boolean;
-    /** Enable WAL mode (not applicable for sql.js) */
+    /** Enable WAL mode (better-sqlite3 only) */
     walMode?: boolean;
     /** Enable query optimization */
     optimize?: boolean;

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

@@ -2,7 +2,7 @@
  * DatabaseProvider - Platform-aware database selection
  *
  * Automatically selects best backend:
- * - All platforms: sql.js (WASM, no native deps)
+ * - Linux/macOS: better-sqlite3 (native, fast)
  * - Windows: sql.js (WASM, universal) when native fails
  * - Fallback: JSON file storage
  *
@@ -35,7 +35,10 @@ function detectPlatform() {
 async function testRvf() {
     return true;
 }
-/** better-sqlite3 removed — sql.js is the only SQLite backend */
+/** better-sqlite3 removed — always returns false */
+async function testBetterSqlite3() {
+    return false;
+}
 /**
  * Test if sql.js is available and working
  */
@@ -172,7 +175,7 @@ export function getPlatformInfo() {
 export async function getAvailableProviders() {
     return {
         rvf: true,
-        betterSqlite3: false, // Removed — sql.js is the only SQLite backend
+        betterSqlite3: await testBetterSqlite3(),
         sqlJs: await testSqlJs(),
         json: true,
     };

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

@@ -64,9 +64,7 @@ describe('DatabaseProvider', () => {
                 namespace: 'test',
             });
             await db.store(entry);
-            const count = await db.count();
-            // RVF backend may include internal metadata entries
-            expect(count).toBeGreaterThanOrEqual(1);
+            await expect(db.count()).resolves.toBe(1);
             await db.shutdown();
         });
     });

package/src/@claude-flow/memory/dist/hybrid-backend.d.ts

@@ -0,0 +1,245 @@
+/**
+ * HybridBackend - Combines SQLite (structured queries) + AgentDB (vector search)
+ *
+ * Per ADR-009: "HybridBackend (SQLite + AgentDB) as default"
+ * - SQLite for: Structured queries, ACID transactions, exact matches
+ * - AgentDB for: Semantic search, vector similarity, RAG
+ *
+ * @module v3/memory/hybrid-backend
+ */
+import { EventEmitter } from 'node:events';
+import { IMemoryBackend, MemoryEntry, MemoryEntryUpdate, MemoryQuery, SearchOptions, SearchResult, BackendStats, HealthCheckResult, EmbeddingGenerator } from './types.js';
+import { SQLiteBackend, SQLiteBackendConfig } from './sqlite-backend.js';
+import { AgentDBBackend, AgentDBBackendConfig } from './agentdb-backend.js';
+/**
+ * Configuration for HybridBackend
+ */
+export interface HybridBackendConfig {
+    /** SQLite configuration */
+    sqlite?: Partial<SQLiteBackendConfig>;
+    /** AgentDB configuration */
+    agentdb?: Partial<AgentDBBackendConfig>;
+    /** Default namespace */
+    defaultNamespace?: string;
+    /** Embedding generator function */
+    embeddingGenerator?: EmbeddingGenerator;
+    /** Query routing strategy */
+    routingStrategy?: 'auto' | 'sqlite-first' | 'agentdb-first';
+    /** Enable dual-write (write to both backends) */
+    dualWrite?: boolean;
+    /** Semantic search threshold for hybrid queries */
+    semanticThreshold?: number;
+    /** Maximum results to fetch from each backend in hybrid queries */
+    hybridMaxResults?: number;
+}
+/**
+ * Structured Query Interface
+ * Optimized for SQLite's strengths
+ */
+export interface StructuredQuery {
+    /** Exact key match */
+    key?: string;
+    /** Key prefix match */
+    keyPrefix?: string;
+    /** Namespace filter */
+    namespace?: string;
+    /** Owner filter */
+    ownerId?: string;
+    /** Type filter */
+    type?: string;
+    /** Time range filters */
+    createdAfter?: number;
+    createdBefore?: number;
+    updatedAfter?: number;
+    updatedBefore?: number;
+    /** Pagination */
+    limit?: number;
+    offset?: number;
+}
+/**
+ * Semantic Query Interface
+ * Optimized for AgentDB's vector search
+ */
+export interface SemanticQuery {
+    /** Content to search for (will be embedded) */
+    content?: string;
+    /** Pre-computed embedding */
+    embedding?: Float32Array;
+    /** Number of results */
+    k?: number;
+    /** Similarity threshold (0-1) */
+    threshold?: number;
+    /** Additional filters */
+    filters?: Partial<MemoryQuery>;
+}
+/**
+ * Hybrid Query Interface
+ * Combines structured + semantic search
+ */
+export interface HybridQuery {
+    /** Semantic component */
+    semantic: SemanticQuery;
+    /** Structured component */
+    structured?: StructuredQuery;
+    /** How to combine results */
+    combineStrategy?: 'union' | 'intersection' | 'semantic-first' | 'structured-first';
+    /** Weights for score combination */
+    weights?: {
+        semantic: number;
+        structured: number;
+    };
+}
+/**
+ * HybridBackend Implementation
+ *
+ * Intelligently routes queries between SQLite and AgentDB:
+ * - Exact matches, prefix queries → SQLite
+ * - Semantic search, similarity → AgentDB
+ * - Complex hybrid queries → Both backends with intelligent merging
+ */
+export declare class HybridBackend extends EventEmitter implements IMemoryBackend {
+    private sqlite;
+    private agentdb;
+    private config;
+    private initialized;
+    private stats;
+    constructor(config?: HybridBackendConfig);
+    /**
+     * Initialize both backends
+     */
+    initialize(): Promise<void>;
+    /**
+     * Shutdown both backends
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Store in both backends (dual-write for consistency)
+     */
+    store(entry: MemoryEntry): Promise<void>;
+    /**
+     * Get from AgentDB (has caching enabled)
+     */
+    get(id: string): Promise<MemoryEntry | null>;
+    /**
+     * Get by key (SQLite optimized for exact matches)
+     */
+    getByKey(namespace: string, key: string): Promise<MemoryEntry | null>;
+    /**
+     * Update in both backends
+     */
+    update(id: string, update: MemoryEntryUpdate): Promise<MemoryEntry | null>;
+    /**
+     * Delete from both backends
+     */
+    delete(id: string): Promise<boolean>;
+    /**
+     * Query routing - semantic goes to AgentDB, structured to SQLite
+     */
+    query(query: MemoryQuery): Promise<MemoryEntry[]>;
+    /**
+     * Structured queries (SQL)
+     * Routes to SQLite for optimal performance
+     */
+    queryStructured(query: StructuredQuery): Promise<MemoryEntry[]>;
+    /**
+     * Semantic queries (vector)
+     * Routes to AgentDB for HNSW-based vector search
+     */
+    querySemantic(query: SemanticQuery): Promise<MemoryEntry[]>;
+    /**
+     * Hybrid queries (combine both)
+     * Intelligently merges results from both backends
+     */
+    queryHybrid(query: HybridQuery): Promise<MemoryEntry[]>;
+    /**
+     * Semantic vector search (routes to AgentDB)
+     */
+    search(embedding: Float32Array, options: SearchOptions): Promise<SearchResult[]>;
+    /**
+     * Bulk insert to both backends
+     */
+    bulkInsert(entries: MemoryEntry[]): Promise<void>;
+    /**
+     * Bulk delete from both backends
+     */
+    bulkDelete(ids: string[]): Promise<number>;
+    /**
+     * Count entries (use SQLite for efficiency)
+     */
+    count(namespace?: string): Promise<number>;
+    /**
+     * List namespaces (use SQLite)
+     */
+    listNamespaces(): Promise<string[]>;
+    /**
+     * Clear namespace in both backends
+     */
+    clearNamespace(namespace: string): Promise<number>;
+    /**
+     * Get combined statistics from both backends
+     */
+    getStats(): Promise<BackendStats>;
+    /**
+     * Health check for both backends
+     */
+    healthCheck(): Promise<HealthCheckResult>;
+    /**
+     * Auto-route queries based on properties
+     */
+    private autoRoute;
+    /**
+     * Internal hybrid query implementation
+     */
+    private queryHybridInternal;
+    /**
+     * Combine results using union (all unique results)
+     */
+    private combineUnion;
+    /**
+     * Combine results using intersection (only common results)
+     */
+    private combineIntersection;
+    /**
+     * Semantic-first: Prefer semantic results, add structured if not present
+     */
+    private combineSemanticFirst;
+    /**
+     * Structured-first: Prefer structured results, add semantic if not present
+     */
+    private combineStructuredFirst;
+    /**
+     * Record feedback for a memory entry.
+     * Delegates to AgentDB's recordFeedback when available.
+     * Gracefully degrades to a no-op when AgentDB is unavailable.
+     */
+    recordFeedback(entryId: string, feedback: {
+        score: number;
+        label?: string;
+        context?: Record<string, unknown>;
+    }): Promise<boolean>;
+    /**
+     * Verify a witness chain for a memory entry.
+     * Delegates to AgentDB's verifyWitnessChain when available.
+     */
+    verifyWitnessChain(entryId: string): Promise<{
+        valid: boolean;
+        chainLength: number;
+        errors: string[];
+    }>;
+    /**
+     * Get the witness chain for a memory entry.
+     * Delegates to AgentDB's getWitnessChain when available.
+     */
+    getWitnessChain(entryId: string): Promise<Array<{
+        hash: string;
+        timestamp: number;
+        operation: string;
+    }>>;
+    /**
+     * Get underlying backends for advanced operations
+     */
+    getSQLiteBackend(): SQLiteBackend;
+    getAgentDBBackend(): AgentDBBackend;
+}
+export default HybridBackend;
+//# sourceMappingURL=hybrid-backend.d.ts.map