moflo 4.8.31 → 4.8.32

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

@@ -1,100 +0,0 @@
-/**
- * Knowledge Graph Module for @claude-flow/memory
- *
- * Builds a graph from MemoryEntry.references, computes PageRank,
- * detects communities via label propagation, and provides
- * graph-aware ranking for search results.
- *
- * Pure TypeScript - no external graph libraries.
- * @module v3/memory/memory-graph
- */
-import { EventEmitter } from 'node:events';
-import type { IMemoryBackend, MemoryEntry, SearchResult } from './types.js';
-export type EdgeType = 'reference' | 'similar' | 'temporal' | 'co-accessed' | 'causal';
-export interface MemoryGraphConfig {
-    similarityThreshold?: number;
-    pageRankDamping?: number;
-    pageRankIterations?: number;
-    pageRankConvergence?: number;
-    maxNodes?: number;
-    enableAutoEdges?: boolean;
-    communityAlgorithm?: 'louvain' | 'label-propagation';
-}
-export interface GraphNode {
-    id: string;
-    category: string;
-    confidence: number;
-    accessCount: number;
-    createdAt: number;
-}
-export interface GraphEdge {
-    targetId: string;
-    type: EdgeType;
-    weight: number;
-}
-export interface RankedResult {
-    entry: MemoryEntry;
-    score: number;
-    pageRank: number;
-    combinedScore: number;
-    community?: string;
-}
-export interface GraphStats {
-    nodeCount: number;
-    edgeCount: number;
-    avgDegree: number;
-    communityCount: number;
-    pageRankComputed: boolean;
-    maxPageRank: number;
-    minPageRank: number;
-}
-/**
- * Knowledge graph built from memory entry references.
- * Supports PageRank, community detection (label propagation),
- * and graph-aware result ranking blending vector similarity with structural importance.
- */
-export declare class MemoryGraph extends EventEmitter {
-    private nodes;
-    private edges;
-    private reverseEdges;
-    private pageRanks;
-    private communities;
-    private config;
-    private dirty;
-    constructor(config?: MemoryGraphConfig);
-    /** Build graph from all entries in a backend. Creates nodes and reference edges. */
-    buildFromBackend(backend: IMemoryBackend, namespace?: string): Promise<void>;
-    /** Add a node from a MemoryEntry. Skips silently at maxNodes capacity. */
-    addNode(entry: MemoryEntry): void;
-    /** Add a directed edge. Skips if either node missing. Updates weight to max if exists. */
-    addEdge(sourceId: string, targetId: string, type: EdgeType, weight?: number): void;
-    /** Remove a node and all associated edges (both directions). */
-    removeNode(id: string): void;
-    /** Add similarity edges by searching backend. Returns count of edges added. */
-    addSimilarityEdges(backend: IMemoryBackend, entryId: string): Promise<number>;
-    /**
-     * Compute PageRank via power iteration with dangling node redistribution.
-     * Returns map of node ID to PageRank score.
-     */
-    computePageRank(): Map<string, number>;
-    /** Detect communities using label propagation. Returns map of nodeId to communityId. */
-    detectCommunities(): Map<string, string>;
-    /**
-     * Rank search results blending vector similarity and PageRank.
-     * @param alpha - Weight for vector score (default 0.7). PageRank weight is (1 - alpha).
-     */
-    rankWithGraph(searchResults: SearchResult[], alpha?: number): RankedResult[];
-    /** Get top N nodes by PageRank score. */
-    getTopNodes(n: number): Array<{
-        id: string;
-        pageRank: number;
-        community: string;
-    }>;
-    /** BFS neighbors from a node up to given depth. Excludes the start node. */
-    getNeighbors(id: string, depth?: number): Set<string>;
-    /** Get statistics about the current graph state. */
-    getStats(): GraphStats;
-    private hasEdge;
-    private shuffleArray;
-}
-//# sourceMappingURL=memory-graph.d.ts.map

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

@@ -1,8 +0,0 @@
-/**
- * Tests for MemoryGraph - Knowledge Graph Module
- *
- * TDD London School (mock-first) tests for graph construction,
- * PageRank computation, community detection, and graph-aware ranking.
- */
-export {};
-//# sourceMappingURL=memory-graph.test.d.ts.map

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

@@ -1,68 +0,0 @@
-/**
- * V3 Memory Migration Utility
- *
- * Migrates data from legacy memory systems (SQLite, Markdown, JSON, etc.)
- * to the unified AgentDB-backed memory system with HNSW indexing.
- *
- * @module v3/memory/migration
- */
-import { EventEmitter } from 'node:events';
-import { MigrationConfig, MigrationProgress, MigrationResult, MigrationSource, EmbeddingGenerator } from './types.js';
-import { AgentDBAdapter } from './agentdb-adapter.js';
-/**
- * Memory Migration Manager
- *
- * Handles migration from:
- * - SQLite backends (.db files)
- * - Markdown backends (.md files)
- * - JSON memory stores (.json files)
- * - MemoryManager instances
- * - SwarmMemory instances
- * - DistributedMemory instances
- */
-export declare class MemoryMigrator extends EventEmitter {
-    private config;
-    private target;
-    private embeddingGenerator?;
-    private progress;
-    constructor(target: AgentDBAdapter, config: Partial<MigrationConfig>, embeddingGenerator?: EmbeddingGenerator);
-    /**
-     * Run the migration
-     */
-    migrate(): Promise<MigrationResult>;
-    /**
-     * Get current migration progress
-     */
-    getProgress(): MigrationProgress;
-    private loadFromSource;
-    private loadFromSQLite;
-    private loadFromMarkdown;
-    private loadFromJSON;
-    private loadFromMemoryManager;
-    private loadFromSwarmMemory;
-    private loadFromDistributedMemory;
-    private processBatch;
-    private transformEntry;
-    private initializeProgress;
-    private validateEntry;
-    private addError;
-    private parseTimestamp;
-    private isValidMemoryType;
-    private estimateTimeRemaining;
-    private generateSummary;
-    private walkDirectory;
-    private parseMarkdownEntry;
-}
-/**
- * Convenience function to create a migrator
- */
-export declare function createMigrator(target: AgentDBAdapter, source: MigrationSource, sourcePath: string, options?: Partial<MigrationConfig>, embeddingGenerator?: EmbeddingGenerator): MemoryMigrator;
-/**
- * Migrate from multiple sources
- */
-export declare function migrateMultipleSources(target: AgentDBAdapter, sources: Array<{
-    source: MigrationSource;
-    path: string;
-}>, options?: Partial<MigrationConfig>, embeddingGenerator?: EmbeddingGenerator): Promise<MigrationResult[]>;
-export default MemoryMigrator;
-//# sourceMappingURL=migration.d.ts.map

package/src/@claude-flow/memory/dist/persistent-sona.d.ts

@@ -1,144 +0,0 @@
-/**
- * PersistentSonaCoordinator - SONA learning with RVF persistence
- *
- * Wraps RvfLearningStore to provide an in-memory pattern bank with
- * brute-force cosine similarity, trajectory buffering, EWC tracking,
- * and automatic periodic persistence to disk.
- *
- * This is intentionally decoupled from the ruvector SONA classes:
- * it defines its own compatible types and delegates persistence to
- * RvfLearningStore.
- *
- * @module @claude-flow/memory/persistent-sona
- */
-import type { PatternRecord, TrajectoryRecord } from './rvf-learning-store.js';
-export interface PersistentSonaConfig {
-    /** Path to the RVF learning store file */
-    storePath: string;
-    /** Cosine similarity threshold for pattern matching (default: 0.85) */
-    patternThreshold?: number;
-    /** Maximum buffered trajectories before oldest are evicted (default: 1000) */
-    maxTrajectoryBuffer?: number;
-    /** Auto-persist interval in ms (default: 30000) */
-    autoPersistInterval?: number;
-    /** Enable verbose logging (default: false) */
-    verbose?: boolean;
-}
-/**
- * Coordinates SONA learning with persistent storage.
- *
- * @example
- * ```typescript
- * const sona = new PersistentSonaCoordinator({
- *   storePath: './data/sona-learning.rvls',
- * });
- * await sona.initialize();
- *
- * // Store a pattern
- * const id = sona.storePattern('query_response', embedding);
- *
- * // Find similar patterns
- * const matches = sona.findSimilarPatterns(queryEmbedding, 5);
- *
- * // Record a trajectory
- * sona.recordTrajectory({ id: 'traj-1', steps: [...], outcome: 'success', ... });
- *
- * // Periodic background learning
- * const result = sona.runBackgroundLoop();
- *
- * await sona.shutdown();
- * ```
- */
-export declare class PersistentSonaCoordinator {
-    private store;
-    private patterns;
-    private trajectoryBuffer;
-    private ewcState;
-    private patternThreshold;
-    private maxTrajectoryBuffer;
-    private verbose;
-    private initialized;
-    constructor(config: PersistentSonaConfig);
-    /**
-     * Initialize by loading persisted state from the RVF store.
-     */
-    initialize(): Promise<void>;
-    /**
-     * Store a new pattern and return its ID.
-     *
-     * @param type - Pattern type (e.g. 'query_response', 'routing')
-     * @param embedding - The pattern embedding vector
-     * @param metadata - Optional extra metadata (currently unused, reserved)
-     * @returns The generated pattern ID
-     */
-    storePattern(type: string, embedding: number[], metadata?: Record<string, unknown>): string;
-    /**
-     * Find the k most similar patterns above the configured threshold.
-     * Uses brute-force cosine similarity (suitable for small pattern sets).
-     */
-    findSimilarPatterns(embedding: number[], k?: number): PatternRecord[];
-    /**
-     * Record a pattern usage outcome. Updates the success rate using an
-     * exponential moving average (alpha = 0.1).
-     */
-    recordPatternUsage(patternId: string, success: boolean): void;
-    /**
-     * Remove patterns that have low success rates after sufficient usage.
-     *
-     * @returns The number of patterns pruned
-     */
-    prunePatterns(minSuccessRate?: number, minUseCount?: number): number;
-    /**
-     * Buffer a completed trajectory for later processing.
-     * When the buffer exceeds maxTrajectoryBuffer, the oldest entries
-     * are evicted.
-     */
-    recordTrajectory(trajectory: TrajectoryRecord): void;
-    /**
-     * Process buffered trajectories to extract new patterns.
-     * Successful and partial trajectories are mined for high-confidence
-     * steps; new patterns are stored if they are sufficiently different
-     * from existing ones.
-     *
-     * After processing, the trajectory buffer is cleared and low-performing
-     * patterns are pruned.
-     *
-     * @returns Summary of the learning pass
-     */
-    runBackgroundLoop(): {
-        patternsLearned: number;
-        trajectoriesProcessed: number;
-    };
-    /**
-     * Flush current in-memory state to the RVF store on disk.
-     */
-    persist(): Promise<void>;
-    /**
-     * Persist state and shut down the store.
-     */
-    shutdown(): Promise<void>;
-    /**
-     * Return a summary of the coordinator's current state.
-     */
-    getStats(): {
-        patterns: number;
-        avgSuccessRate: number;
-        trajectoriesBuffered: number;
-        ewcTasksLearned: number;
-    };
-    /**
-     * Extract patterns from a trajectory's high-confidence steps.
-     * A step produces a new pattern only if no sufficiently similar
-     * pattern already exists.
-     */
-    private extractPatternsFromTrajectory;
-    /**
-     * Deterministic hash-based embedding for pattern extraction.
-     * This is a lightweight stand-in for a real embedding model,
-     * matching the approach used in SonaCoordinator.
-     */
-    private createHashEmbedding;
-    private ensureInitialized;
-    private log;
-}
-//# sourceMappingURL=persistent-sona.d.ts.map

package/src/@claude-flow/memory/dist/query-builder.d.ts

@@ -1,211 +0,0 @@
-/**
- * V3 Query Builder
- *
- * Fluent API for building memory queries with filter chaining,
- * sorting options, and pagination support.
- *
- * @module v3/memory/query-builder
- */
-import { MemoryQuery, MemoryType, AccessLevel, DistanceMetric } from './types.js';
-/**
- * Sort direction
- */
-export type SortDirection = 'asc' | 'desc';
-/**
- * Sort field options
- */
-export type SortField = 'createdAt' | 'updatedAt' | 'lastAccessedAt' | 'accessCount' | 'key' | 'score';
-/**
- * Fluent query builder for constructing memory queries
- *
- * @example
- * ```typescript
- * const query = new QueryBuilder()
- *   .semantic('user authentication patterns')
- *   .inNamespace('security')
- *   .withTags(['auth', 'patterns'])
- *   .ofType('semantic')
- *   .limit(10)
- *   .threshold(0.8)
- *   .build();
- * ```
- */
-export declare class QueryBuilder {
-    private state;
-    constructor();
-    /**
-     * Create a semantic (vector similarity) query
-     */
-    semantic(content: string): this;
-    /**
-     * Create a semantic query with pre-computed embedding
-     */
-    semanticWithEmbedding(embedding: Float32Array): this;
-    /**
-     * Create an exact key match query
-     */
-    exact(key: string): this;
-    /**
-     * Create a key prefix match query
-     */
-    prefix(keyPrefix: string): this;
-    /**
-     * Create a tag-based query
-     */
-    byTags(tags: string[]): this;
-    /**
-     * Create a hybrid query (semantic + filters)
-     */
-    hybrid(content: string): this;
-    /**
-     * Filter by namespace
-     */
-    inNamespace(namespace: string): this;
-    /**
-     * Add tag filter (entries must have all specified tags)
-     */
-    withTags(tags: string[]): this;
-    /**
-     * Add a single tag filter
-     */
-    withTag(tag: string): this;
-    /**
-     * Filter by memory type
-     */
-    ofType(type: MemoryType): this;
-    /**
-     * Filter by access level
-     */
-    withAccessLevel(level: AccessLevel): this;
-    /**
-     * Filter by owner
-     */
-    ownedBy(ownerId: string): this;
-    /**
-     * Filter by metadata field
-     */
-    whereMetadata(key: string, value: unknown): this;
-    /**
-     * Filter by creation date range
-     */
-    createdBetween(after: Date | number, before?: Date | number): this;
-    /**
-     * Filter entries created after a date
-     */
-    createdAfter(date: Date | number): this;
-    /**
-     * Filter entries created before a date
-     */
-    createdBefore(date: Date | number): this;
-    /**
-     * Filter by update date range
-     */
-    updatedBetween(after: Date | number, before?: Date | number): this;
-    /**
-     * Filter entries updated in the last N milliseconds
-     */
-    updatedWithin(milliseconds: number): this;
-    /**
-     * Set maximum number of results
-     */
-    limit(count: number): this;
-    /**
-     * Set pagination offset
-     */
-    offset(count: number): this;
-    /**
-     * Set pagination with page number and size
-     */
-    page(pageNumber: number, pageSize: number): this;
-    /**
-     * Set minimum similarity threshold for semantic search
-     */
-    threshold(minScore: number): this;
-    /**
-     * Include expired entries in results
-     */
-    includeExpired(include?: boolean): this;
-    /**
-     * Set distance metric for semantic search
-     */
-    withMetric(metric: DistanceMetric): this;
-    /**
-     * Sort results by field
-     */
-    sortBy(field: SortField, direction?: SortDirection): this;
-    /**
-     * Sort by creation date (newest first)
-     */
-    newestFirst(): this;
-    /**
-     * Sort by creation date (oldest first)
-     */
-    oldestFirst(): this;
-    /**
-     * Sort by relevance score (highest first)
-     */
-    mostRelevant(): this;
-    /**
-     * Sort by access count (most accessed first)
-     */
-    mostAccessed(): this;
-    /**
-     * Sort by last accessed time (most recent first)
-     */
-    recentlyAccessed(): this;
-    /**
-     * Build the final query object
-     */
-    build(): MemoryQuery;
-    /**
-     * Clone this builder
-     */
-    clone(): QueryBuilder;
-    /**
-     * Reset the builder to initial state
-     */
-    reset(): this;
-}
-/**
- * Convenience function to create a new query builder
- */
-export declare function query(): QueryBuilder;
-/**
- * Predefined query templates for common use cases
- */
-export declare const QueryTemplates: {
-    /**
-     * Find recent entries in a namespace
-     */
-    recentInNamespace(namespace: string, limit?: number): MemoryQuery;
-    /**
-     * Find entries by exact key
-     */
-    byKey(namespace: string, key: string): MemoryQuery;
-    /**
-     * Semantic search with threshold
-     */
-    semanticSearch(content: string, namespace?: string, threshold?: number, limit?: number): MemoryQuery;
-    /**
-     * Find entries with specific tags
-     */
-    withTags(tags: string[], namespace?: string, limit?: number): MemoryQuery;
-    /**
-     * Find entries owned by a specific agent
-     */
-    ownedBy(ownerId: string, namespace?: string, limit?: number): MemoryQuery;
-    /**
-     * Find episodic memories within a time range
-     */
-    episodicInRange(after: Date | number, before: Date | number, limit?: number): MemoryQuery;
-    /**
-     * Find hot entries (frequently accessed)
-     */
-    hotEntries(namespace?: string, limit?: number): MemoryQuery;
-    /**
-     * Find stale entries (not accessed recently)
-     */
-    staleEntries(staleThresholdMs: number, namespace?: string, limit?: number): MemoryQuery;
-};
-export default QueryBuilder;
-//# sourceMappingURL=query-builder.d.ts.map

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

@@ -1,51 +0,0 @@
-import type { IMemoryBackend, MemoryEntry, MemoryEntryUpdate, MemoryQuery, SearchOptions, SearchResult, BackendStats, HealthCheckResult } from './types.js';
-export interface RvfBackendConfig {
-    databasePath: string;
-    dimensions?: number;
-    metric?: 'cosine' | 'euclidean' | 'dot';
-    quantization?: 'fp32' | 'fp16' | 'int8';
-    hnswM?: number;
-    hnswEfConstruction?: number;
-    maxElements?: number;
-    verbose?: boolean;
-    defaultNamespace?: string;
-    autoPersistInterval?: number;
-}
-export declare class RvfBackend implements IMemoryBackend {
-    private entries;
-    private keyIndex;
-    private hnswIndex;
-    private nativeDb;
-    private config;
-    private initialized;
-    private dirty;
-    private persisting;
-    private persistTimer;
-    private queryTimes;
-    private searchTimes;
-    constructor(config: RvfBackendConfig);
-    initialize(): Promise<void>;
-    shutdown(): Promise<void>;
-    store(entry: MemoryEntry): Promise<void>;
-    get(id: string): Promise<MemoryEntry | null>;
-    getByKey(namespace: string, key: string): Promise<MemoryEntry | null>;
-    update(id: string, updateData: MemoryEntryUpdate): Promise<MemoryEntry | null>;
-    delete(id: string): Promise<boolean>;
-    query(q: MemoryQuery): Promise<MemoryEntry[]>;
-    search(embedding: Float32Array, options: SearchOptions): Promise<SearchResult[]>;
-    bulkInsert(entries: MemoryEntry[]): Promise<void>;
-    bulkDelete(ids: string[]): Promise<number>;
-    count(namespace?: string): Promise<number>;
-    listNamespaces(): Promise<string[]>;
-    clearNamespace(namespace: string): Promise<number>;
-    getStats(): Promise<BackendStats>;
-    healthCheck(): Promise<HealthCheckResult>;
-    private tryNativeInit;
-    private compositeKey;
-    private bruteForceSearch;
-    private recordTiming;
-    private avg;
-    private loadFromDisk;
-    private persistToDisk;
-}
-//# sourceMappingURL=rvf-backend.d.ts.map