moflo 4.8.30 → 4.8.32

package/src/@claude-flow/memory/dist/auto-memory-bridge.d.ts

@@ -1,226 +0,0 @@
-/**
- * AutoMemoryBridge - Bidirectional sync between Claude Code Auto Memory and AgentDB
- *
- * Per ADR-048: Bridges Claude Code's auto memory (markdown files at
- * ~/.claude/projects/<project>/memory/) with claude-flow's unified memory
- * system (AgentDB + HNSW).
- *
- * Auto memory files are human-readable markdown that Claude loads into its
- * system prompt. MEMORY.md (first 200 lines) is the entrypoint; topic files
- * store detailed notes and are read on demand.
- *
- * @module @claude-flow/memory/auto-memory-bridge
- */
-import { EventEmitter } from 'node:events';
-import { type IMemoryBackend } from './types.js';
-import { type LearningBridgeConfig } from './learning-bridge.js';
-import { type MemoryGraphConfig } from './memory-graph.js';
-/** Insight category for organization in MEMORY.md */
-export type InsightCategory = 'project-patterns' | 'debugging' | 'architecture' | 'performance' | 'security' | 'preferences' | 'swarm-results';
-/** Sync direction */
-export type SyncDirection = 'to-auto' | 'from-auto' | 'bidirectional';
-/** Sync mode determines when syncs occur */
-export type SyncMode = 'on-write' | 'on-session-end' | 'periodic';
-/** Prune strategy for keeping MEMORY.md under line limit */
-export type PruneStrategy = 'confidence-weighted' | 'fifo' | 'lru';
-/** Configuration for AutoMemoryBridge */
-export interface AutoMemoryBridgeConfig {
-    /** Auto memory directory path (auto-resolved if not provided) */
-    memoryDir?: string;
-    /** Working directory for git root detection */
-    workingDir?: string;
-    /** Max lines for MEMORY.md index (default: 180, Claude reads first 200) */
-    maxIndexLines?: number;
-    /** Topic file mapping: category → filename */
-    topicMapping?: Partial<Record<InsightCategory, string>>;
-    /** Sync mode (default: 'on-session-end') */
-    syncMode?: SyncMode;
-    /** Periodic sync interval in ms (if syncMode is 'periodic') */
-    syncIntervalMs?: number;
-    /** Minimum confidence for syncing to auto memory (default: 0.7) */
-    minConfidence?: number;
-    /** Maximum lines per topic file (default: 500) */
-    maxTopicFileLines?: number;
-    /** Prune strategy for MEMORY.md (default: 'confidence-weighted') */
-    pruneStrategy?: PruneStrategy;
-    /** Learning bridge config (ADR-049). When set, insights trigger neural learning. */
-    learning?: LearningBridgeConfig;
-    /** Knowledge graph config (ADR-049). When set, graph-aware curation is enabled. */
-    graph?: MemoryGraphConfig;
-}
-/** A memory insight to record */
-export interface MemoryInsight {
-    /** Category for organization */
-    category: InsightCategory;
-    /** One-line summary for MEMORY.md index */
-    summary: string;
-    /** Detailed content (goes in topic file if > 2 lines) */
-    detail?: string;
-    /** Source: which agent/hook discovered this */
-    source: string;
-    /** Confidence score (0-1), used for curation priority */
-    confidence: number;
-    /** AgentDB entry ID for cross-reference */
-    agentDbId?: string;
-}
-/** Result of a sync operation */
-export interface SyncResult {
-    /** Number of entries synced */
-    synced: number;
-    /** Categories that were updated */
-    categories: string[];
-    /** Duration of sync in milliseconds */
-    durationMs: number;
-    /** Any errors encountered */
-    errors: string[];
-}
-/** Result of an import operation */
-export interface ImportResult {
-    /** Number of entries imported */
-    imported: number;
-    /** Number of entries skipped (already in AgentDB) */
-    skipped: number;
-    /** Files processed */
-    files: string[];
-    /** Duration in milliseconds */
-    durationMs: number;
-}
-/** Parsed markdown entry from a topic file */
-interface ParsedEntry {
-    heading: string;
-    content: string;
-    metadata: Record<string, string>;
-}
-/**
- * Bidirectional bridge between Claude Code auto memory and AgentDB.
- *
- * @example
- * ```typescript
- * const bridge = new AutoMemoryBridge(memoryBackend, {
- *   workingDir: '/workspaces/my-project',
- * });
- *
- * // Record an insight
- * await bridge.recordInsight({
- *   category: 'debugging',
- *   summary: 'HNSW index requires initialization before search',
- *   source: 'agent:tester',
- *   confidence: 0.95,
- * });
- *
- * // Sync to auto memory files
- * await bridge.syncToAutoMemory();
- *
- * // Import auto memory into AgentDB
- * await bridge.importFromAutoMemory();
- * ```
- */
-export declare class AutoMemoryBridge extends EventEmitter {
-    private config;
-    private backend;
-    private lastSyncTime;
-    private syncTimer;
-    private insights;
-    /** Track AgentDB keys of insights already written to files during this session */
-    private syncedInsightKeys;
-    /** Monotonic counter to prevent key collisions within the same ms */
-    private insightCounter;
-    /** Optional learning bridge (ADR-049) */
-    private learningBridge?;
-    /** Optional knowledge graph (ADR-049) */
-    private memoryGraph?;
-    constructor(backend: IMemoryBackend, config?: AutoMemoryBridgeConfig);
-    /** Get the resolved auto memory directory path */
-    getMemoryDir(): string;
-    /** Get the path to MEMORY.md */
-    getIndexPath(): string;
-    /** Get the path to a topic file */
-    getTopicPath(category: InsightCategory): string;
-    /**
-     * Record a memory insight.
-     * Stores in the in-memory buffer and optionally writes immediately.
-     */
-    recordInsight(insight: MemoryInsight): Promise<void>;
-    /**
-     * Sync high-confidence AgentDB entries to auto memory files.
-     * Called on session-end or periodically.
-     */
-    syncToAutoMemory(): Promise<SyncResult>;
-    /**
-     * Import auto memory files into AgentDB.
-     * Called on session-start to hydrate AgentDB with previous learnings.
-     * Uses bulk insert for efficiency.
-     */
-    importFromAutoMemory(): Promise<ImportResult>;
-    /**
-     * Curate MEMORY.md to stay under the line limit.
-     * Groups entries by category and prunes low-confidence items.
-     */
-    curateIndex(): Promise<void>;
-    /**
-     * Get auto memory status: directory info, file count, line counts.
-     */
-    getStatus(): {
-        memoryDir: string;
-        exists: boolean;
-        files: {
-            name: string;
-            lines: number;
-        }[];
-        totalLines: number;
-        indexLines: number;
-        lastSyncTime: number;
-        bufferedInsights: number;
-    };
-    /** Stop periodic sync and clean up */
-    destroy(): void;
-    private ensureMemoryDir;
-    private storeInsightInAgentDB;
-    private writeInsightToFiles;
-    private queryRecentInsights;
-    private classifyEntry;
-    private appendToTopicFile;
-    /** Fetch all existing content hashes from the auto-memory namespace in one query */
-    private fetchExistingContentHashes;
-    private startPeriodicSync;
-}
-/**
- * Resolve the auto memory directory for a given working directory.
- * Mirrors Claude Code's path derivation from git root.
- */
-export declare function resolveAutoMemoryDir(workingDir: string): string;
-/**
- * Find the git root directory by walking up from workingDir.
- */
-export declare function findGitRoot(dir: string): string | null;
-/**
- * Parse markdown content into structured entries.
- * Splits on ## headings and extracts content under each.
- */
-export declare function parseMarkdownEntries(content: string): ParsedEntry[];
-/**
- * Extract clean one-line summaries from a topic file.
- * Returns bullet-point items (lines starting with '- '), stripping
- * metadata annotations like _(source, date, conf: 0.95)_.
- */
-export declare function extractSummaries(content: string): string[];
-/**
- * Format an insight as a markdown line for topic files.
- */
-export declare function formatInsightLine(insight: MemoryInsight): string;
-/**
- * Hash content for deduplication.
- */
-export declare function hashContent(content: string): string;
-/**
- * Prune a topic file to stay under the line limit.
- * Removes oldest entries (those closest to the top after the header).
- */
-export declare function pruneTopicFile(content: string, maxLines: number): string;
-/**
- * Check if a summary already exists as a bullet line in topic file content.
- * Uses exact bullet prefix matching (not substring) to avoid false positives.
- */
-export declare function hasSummaryLine(content: string, summary: string): boolean;
-export default AutoMemoryBridge;
-//# sourceMappingURL=auto-memory-bridge.d.ts.map

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

@@ -1,8 +0,0 @@
-/**
- * Tests for AutoMemoryBridge
- *
- * TDD London School (mock-first) tests for the bidirectional bridge
- * between Claude Code auto memory and AgentDB.
- */
-export {};
-//# sourceMappingURL=auto-memory-bridge.test.d.ts.map

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

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=benchmark.test.d.ts.map

package/src/@claude-flow/memory/dist/cache-manager.d.ts

@@ -1,134 +0,0 @@
-/**
- * V3 Cache Manager
- *
- * High-performance LRU cache with TTL support, memory pressure handling,
- * and write-through caching for the unified memory system.
- *
- * @module v3/memory/cache-manager
- */
-import { EventEmitter } from 'node:events';
-import { CacheConfig, CacheStats, MemoryEntry } from './types.js';
-/**
- * High-performance LRU Cache with TTL support
- *
- * Features:
- * - O(1) get, set, delete operations
- * - LRU eviction policy
- * - TTL-based expiration
- * - Memory pressure handling
- * - Write-through caching support
- * - Performance statistics
- */
-export declare class CacheManager<T = MemoryEntry> extends EventEmitter {
-    private config;
-    private cache;
-    private head;
-    private tail;
-    private currentMemory;
-    private stats;
-    private cleanupInterval;
-    constructor(config?: Partial<CacheConfig>);
-    /**
-     * Get a value from the cache
-     */
-    get(key: string): T | null;
-    /**
-     * Set a value in the cache
-     */
-    set(key: string, data: T, ttl?: number): void;
-    /**
-     * Delete a value from the cache
-     */
-    delete(key: string): boolean;
-    /**
-     * Check if a key exists in the cache (without affecting LRU order)
-     */
-    has(key: string): boolean;
-    /**
-     * Clear all entries from the cache
-     */
-    clear(): void;
-    /**
-     * Get cache statistics
-     */
-    getStats(): CacheStats;
-    /**
-     * Get all keys in the cache
-     */
-    keys(): string[];
-    /**
-     * Get the size of the cache
-     */
-    get size(): number;
-    /**
-     * Prefetch multiple keys in a single batch
-     */
-    prefetch(keys: string[], loader: (keys: string[]) => Promise<Map<string, T>>, ttl?: number): Promise<void>;
-    /**
-     * Get or set pattern - get from cache or load and cache
-     */
-    getOrSet(key: string, loader: () => Promise<T>, ttl?: number): Promise<T>;
-    /**
-     * Warm the cache with initial data
-     */
-    warmUp(entries: Array<{
-        key: string;
-        data: T;
-        ttl?: number;
-    }>): void;
-    /**
-     * Invalidate entries matching a pattern
-     */
-    invalidatePattern(pattern: string | RegExp): number;
-    /**
-     * Shutdown the cache manager
-     */
-    shutdown(): void;
-    private mergeConfig;
-    private isExpired;
-    private estimateSize;
-    private addToFront;
-    private removeNode;
-    private moveToFront;
-    private evictLRU;
-    private startCleanupTimer;
-    private cleanupExpired;
-}
-/**
- * Multi-layer cache with L1 (memory) and L2 (storage) tiers
- */
-export declare class TieredCacheManager<T = MemoryEntry> extends EventEmitter {
-    private l1Cache;
-    private l2Loader;
-    private l2Writer;
-    constructor(l1Config?: Partial<CacheConfig>, l2Options?: {
-        loader: (key: string) => Promise<T | null>;
-        writer?: (key: string, value: T) => Promise<void>;
-    });
-    /**
-     * Get from tiered cache
-     */
-    get(key: string): Promise<T | null>;
-    /**
-     * Set in tiered cache
-     */
-    set(key: string, value: T, ttl?: number): Promise<void>;
-    /**
-     * Delete from tiered cache
-     */
-    delete(key: string): boolean;
-    /**
-     * Get L1 cache statistics
-     */
-    getStats(): CacheStats;
-    /**
-     * Clear L1 cache
-     */
-    clear(): void;
-    /**
-     * Shutdown tiered cache
-     */
-    shutdown(): void;
-}
-export default CacheManager;
-//# sourceMappingURL=cache-manager.d.ts.map

package/src/@claude-flow/memory/dist/controller-registry.d.ts

@@ -1,216 +0,0 @@
-/**
- * ControllerRegistry - Central controller lifecycle management for AgentDB v3
- *
- * Wraps the AgentDB class and adds CLI-specific controllers from @claude-flow/memory.
- * Manages initialization (level-based ordering), health checks, and graceful shutdown.
- *
- * Per ADR-053: Replaces memory-initializer.js's raw sql.js usage with a unified
- * controller ecosystem routing all memory operations through AgentDB v3.
- *
- * @module @claude-flow/memory/controller-registry
- */
-import { EventEmitter } from 'node:events';
-import type { IMemoryBackend, EmbeddingGenerator, SONAMode } from './types.js';
-import type { LearningBridgeConfig } from './learning-bridge.js';
-import type { MemoryGraphConfig } from './memory-graph.js';
-import type { CacheConfig } from './types.js';
-/**
- * Controllers accessible via AgentDB.getController()
- */
-export type AgentDBControllerName = 'reasoningBank' | 'skills' | 'reflexion' | 'causalGraph' | 'causalRecall' | 'learningSystem' | 'explainableRecall' | 'nightlyLearner' | 'graphTransformer' | 'mutationGuard' | 'attestationLog' | 'vectorBackend' | 'graphAdapter';
-/**
- * CLI-layer controllers (from @claude-flow/memory or new)
- */
-export type CLIControllerName = 'learningBridge' | 'memoryGraph' | 'agentMemoryScope' | 'tieredCache' | 'hybridSearch' | 'federatedSession' | 'semanticRouter' | 'sonaTrajectory' | 'hierarchicalMemory' | 'memoryConsolidation' | 'batchOperations' | 'contextSynthesizer' | 'gnnService' | 'rvfOptimizer' | 'mmrDiversityRanker' | 'guardedVectorBackend';
-/**
- * All controller names
- */
-export type ControllerName = AgentDBControllerName | CLIControllerName;
-/**
- * Initialization level for dependency ordering
- */
-export interface InitLevel {
-    level: number;
-    controllers: ControllerName[];
-}
-/**
- * Individual controller health status
- */
-export interface ControllerHealth {
-    name: ControllerName;
-    status: 'healthy' | 'degraded' | 'unavailable';
-    initTimeMs: number;
-    error?: string;
-}
-/**
- * Aggregated health report for all controllers
- */
-export interface RegistryHealthReport {
-    status: 'healthy' | 'degraded' | 'unhealthy';
-    controllers: ControllerHealth[];
-    agentdbAvailable: boolean;
-    initTimeMs: number;
-    timestamp: number;
-    activeControllers: number;
-    totalControllers: number;
-}
-/**
- * Runtime configuration for controller activation
- */
-export interface RuntimeConfig {
-    /** Database path for AgentDB */
-    dbPath?: string;
-    /** Vector dimension (default: 384 for MiniLM) */
-    dimension?: number;
-    /** Embedding generator function */
-    embeddingGenerator?: EmbeddingGenerator;
-    /** Memory backend config */
-    memory?: {
-        enableHNSW?: boolean;
-        learningBridge?: Partial<LearningBridgeConfig>;
-        memoryGraph?: Partial<MemoryGraphConfig>;
-        tieredCache?: Partial<CacheConfig>;
-    };
-    /** Neural config */
-    neural?: {
-        enabled?: boolean;
-        modelPath?: string;
-        sonaMode?: SONAMode;
-    };
-    /** Controllers to explicitly enable/disable */
-    controllers?: Partial<Record<ControllerName, boolean>>;
-    /** Backend instance to use (if pre-created) */
-    backend?: IMemoryBackend;
-}
-/**
- * Level-based initialization order per ADR-053.
- * Controllers at each level can be initialized in parallel.
- * Each level must complete before the next begins.
- */
-export declare const INIT_LEVELS: InitLevel[];
-/**
- * Central registry for AgentDB v3 controller lifecycle management.
- *
- * Handles:
- * - Level-based initialization ordering (levels 0-6)
- * - Graceful degradation (each controller fails independently)
- * - Config-driven activation (controllers only instantiate when enabled)
- * - Health check aggregation across all controllers
- * - Ordered shutdown (reverse initialization order)
- *
- * @example
- * ```typescript
- * const registry = new ControllerRegistry();
- * await registry.initialize({
- *   dbPath: './data/memory.db',
- *   dimension: 384,
- *   memory: {
- *     enableHNSW: true,
- *     learningBridge: { sonaMode: 'balanced' },
- *     memoryGraph: { pageRankDamping: 0.85 },
- *   },
- * });
- *
- * const reasoning = registry.get<ReasoningBank>('reasoningBank');
- * const graph = registry.get<MemoryGraph>('memoryGraph');
- *
- * await registry.shutdown();
- * ```
- */
-export declare class ControllerRegistry extends EventEmitter {
-    private controllers;
-    private agentdb;
-    private backend;
-    private config;
-    private initialized;
-    private initTimeMs;
-    /**
-     * Initialize all controllers in level-based order.
-     *
-     * Each level's controllers are initialized in parallel within the level.
-     * Failures are isolated: a controller that fails to init is marked as
-     * unavailable but does not block other controllers.
-     */
-    initialize(config?: RuntimeConfig): Promise<void>;
-    /**
-     * Shutdown all controllers in reverse initialization order.
-     */
-    shutdown(): Promise<void>;
-    /**
-     * Get a controller instance by name.
-     * Returns null if the controller is not initialized or unavailable.
-     */
-    get<T>(name: ControllerName): T | null;
-    /**
-     * Check if a controller is enabled and initialized.
-     */
-    isEnabled(name: ControllerName): boolean;
-    /**
-     * Aggregate health check across all controllers.
-     */
-    healthCheck(): Promise<RegistryHealthReport>;
-    /**
-     * Get the underlying AgentDB instance.
-     */
-    getAgentDB(): any;
-    /**
-     * Get the memory backend.
-     */
-    getBackend(): IMemoryBackend | null;
-    /**
-     * Check if the registry is initialized.
-     */
-    isInitialized(): boolean;
-    /**
-     * Get the number of active (successfully initialized) controllers.
-     */
-    getActiveCount(): number;
-    /**
-     * List all registered controller names and their status.
-     */
-    listControllers(): Array<{
-        name: ControllerName;
-        enabled: boolean;
-        level: number;
-    }>;
-    /**
-     * Initialize AgentDB instance with dynamic import and fallback chain.
-     */
-    private initAgentDB;
-    /**
-     * Check whether a controller should be initialized based on config.
-     */
-    private isControllerEnabled;
-    /**
-     * Initialize a single controller with error isolation.
-     */
-    private initController;
-    /**
-     * Factory method to create a controller instance.
-     * Handles CLI-layer controllers; AgentDB-internal controllers are
-     * accessed via agentdb.getController().
-     */
-    private createController;
-    /**
-     * Shutdown a single controller gracefully.
-     */
-    private shutdownController;
-    /**
-     * Create an EmbeddingService for controllers that need it.
-     * Uses the config's embedding generator or creates a minimal local service.
-     */
-    private createEmbeddingService;
-    /**
-     * Lightweight in-memory tiered store (fallback when HierarchicalMemory
-     * cannot be initialized from agentdb).
-     * Enforces per-tier size limits to prevent unbounded memory growth.
-     */
-    private createTieredMemoryStub;
-    /**
-     * No-op consolidation stub (fallback when MemoryConsolidation
-     * cannot be initialized from agentdb).
-     */
-    private createConsolidationStub;
-}
-export default ControllerRegistry;
-//# sourceMappingURL=controller-registry.d.ts.map

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

@@ -1,14 +0,0 @@
-/**
- * Comprehensive tests for ControllerRegistry (ADR-053)
- *
- * Covers:
- * - Initialization lifecycle and level-based ordering
- * - Graceful degradation (isolated controller failures)
- * - Config-driven activation
- * - Health check aggregation
- * - Shutdown ordering
- * - Cross-platform path handling (Linux/Mac/Windows)
- * - AgentDB unavailable scenarios
- */
-export {};
-//# sourceMappingURL=controller-registry.test.d.ts.map

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

@@ -1,87 +0,0 @@
-/**
- * DatabaseProvider - Platform-aware database selection
- *
- * Automatically selects best backend:
- * - All platforms: sql.js (WASM, no native deps)
- * - 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 = '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 (not applicable for sql.js) */
-    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/src/@claude-flow/memory/dist/database-provider.test.d.ts

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