moflo 4.8.19 → 4.8.20

package/src/@claude-flow/memory/dist/application/queries/search-memory.query.js

@@ -0,0 +1,143 @@
+/**
+ * Search Memory Query - Application Layer (CQRS)
+ *
+ * Query for searching memory entries.
+ * Supports text search, vector search, and filtering.
+ *
+ * @module v3/memory/application/queries
+ */
+/**
+ * Search Memory Query Handler
+ */
+export class SearchMemoryQueryHandler {
+    repository;
+    constructor(repository) {
+        this.repository = repository;
+    }
+    async execute(input) {
+        const limit = input.limit ?? 10;
+        const offset = input.offset ?? 0;
+        // Vector search takes precedence
+        if (input.vector) {
+            return this.executeVectorSearch(input, limit, offset);
+        }
+        // Text search
+        if (input.textQuery) {
+            return this.executeTextSearch(input, limit, offset);
+        }
+        // Filter-based search
+        return this.executeFilterSearch(input, limit, offset);
+    }
+    async executeVectorSearch(input, limit, offset) {
+        const results = await this.repository.searchByVector({
+            vector: input.vector,
+            namespace: input.namespace,
+            limit: limit + offset, // Get extra for pagination
+            threshold: input.similarityThreshold ?? 0.5,
+            type: input.type,
+        });
+        // Apply offset
+        const paginatedResults = results.slice(offset, offset + limit);
+        // Track access if requested
+        if (input.trackAccess) {
+            await this.trackEntryAccess(paginatedResults.map((r) => r.entry));
+        }
+        return {
+            entries: paginatedResults.map((r) => r.entry),
+            total: results.length,
+            hasMore: results.length > offset + limit,
+            searchType: 'vector',
+            similarities: paginatedResults.map((r) => r.similarity),
+        };
+    }
+    async executeTextSearch(input, limit, offset) {
+        // Get all entries matching filters
+        const options = {
+            namespace: input.namespace,
+            type: input.type,
+            status: input.status ?? 'active',
+            orderBy: input.orderBy ?? 'createdAt',
+            orderDirection: input.orderDirection ?? 'desc',
+        };
+        const allEntries = await this.repository.findAll(options);
+        // Filter by text query
+        const query = input.textQuery.toLowerCase();
+        const matchingEntries = allEntries.filter((entry) => {
+            const valueStr = JSON.stringify(entry.value).toLowerCase();
+            const metadataStr = JSON.stringify(entry.metadata).toLowerCase();
+            return valueStr.includes(query) || metadataStr.includes(query);
+        });
+        // Paginate
+        const paginatedEntries = matchingEntries.slice(offset, offset + limit);
+        // Track access if requested
+        if (input.trackAccess) {
+            await this.trackEntryAccess(paginatedEntries);
+        }
+        return {
+            entries: paginatedEntries,
+            total: matchingEntries.length,
+            hasMore: matchingEntries.length > offset + limit,
+            searchType: 'text',
+        };
+    }
+    async executeFilterSearch(input, limit, offset) {
+        const options = {
+            namespace: input.namespace,
+            type: input.type,
+            status: input.status ?? 'active',
+            limit,
+            offset,
+            orderBy: input.orderBy ?? 'createdAt',
+            orderDirection: input.orderDirection ?? 'desc',
+        };
+        const entries = await this.repository.findAll(options);
+        const total = await this.repository.count({
+            namespace: input.namespace,
+            type: input.type,
+            status: input.status ?? 'active',
+        });
+        // Track access if requested
+        if (input.trackAccess) {
+            await this.trackEntryAccess(entries);
+        }
+        return {
+            entries,
+            total,
+            hasMore: total > offset + limit,
+            searchType: 'filter',
+        };
+    }
+    async trackEntryAccess(entries) {
+        for (const entry of entries) {
+            entry.recordAccess();
+            await this.repository.save(entry);
+        }
+    }
+}
+/**
+ * Get Memory By Key Query Handler
+ */
+export class GetMemoryByKeyQueryHandler {
+    repository;
+    constructor(repository) {
+        this.repository = repository;
+    }
+    async execute(input) {
+        const entry = await this.repository.findByKey(input.namespace, input.key);
+        if (!entry) {
+            return { found: false };
+        }
+        if (!entry.isAccessible()) {
+            return { found: false };
+        }
+        if (input.trackAccess) {
+            entry.recordAccess();
+            await this.repository.save(entry);
+        }
+        return {
+            found: true,
+            entry,
+        };
+    }
+}
+//# sourceMappingURL=search-memory.query.js.map

package/src/@claude-flow/memory/dist/application/services/memory-application-service.d.ts

@@ -0,0 +1,121 @@
+/**
+ * Memory Application Service - Application Layer
+ *
+ * Orchestrates use cases and coordinates between domain and infrastructure.
+ * Provides a simplified interface for external consumers.
+ *
+ * @module v3/memory/application/services
+ */
+import { MemoryEntry, MemoryType } from '../../domain/entities/memory-entry.js';
+import { IMemoryRepository, VectorSearchResult, MemoryStatistics } from '../../domain/repositories/memory-repository.interface.js';
+import { ConsolidationOptions, ConsolidationResult } from '../../domain/services/memory-domain-service.js';
+import { StoreMemoryInput } from '../commands/store-memory.command.js';
+import { SearchMemoryInput } from '../queries/search-memory.query.js';
+/**
+ * Memory Application Service
+ *
+ * Main entry point for memory operations.
+ * Coordinates commands and queries with domain services.
+ */
+export declare class MemoryApplicationService {
+    private readonly repository;
+    private readonly domainService;
+    private readonly storeHandler;
+    private readonly deleteHandler;
+    private readonly bulkDeleteHandler;
+    private readonly searchHandler;
+    private readonly getByKeyHandler;
+    constructor(repository: IMemoryRepository);
+    /**
+     * Store a memory entry
+     */
+    store(input: StoreMemoryInput): Promise<MemoryEntry>;
+    /**
+     * Store multiple memory entries
+     */
+    storeMany(inputs: StoreMemoryInput[]): Promise<MemoryEntry[]>;
+    /**
+     * Get a memory entry by namespace and key
+     */
+    get(namespace: string, key: string): Promise<MemoryEntry | null>;
+    /**
+     * Get a memory entry by ID
+     */
+    getById(id: string): Promise<MemoryEntry | null>;
+    /**
+     * Search memory entries
+     */
+    search(input: SearchMemoryInput): Promise<{
+        entries: MemoryEntry[];
+        total: number;
+        hasMore: boolean;
+    }>;
+    /**
+     * Search by vector similarity
+     */
+    searchByVector(vector: Float32Array, options?: {
+        namespace?: string;
+        limit?: number;
+        threshold?: number;
+    }): Promise<VectorSearchResult[]>;
+    /**
+     * Get all entries in a namespace
+     */
+    getNamespace(namespace: string): Promise<MemoryEntry[]>;
+    /**
+     * List all namespaces
+     */
+    listNamespaces(): Promise<string[]>;
+    /**
+     * Delete a memory entry by namespace and key
+     */
+    delete(namespace: string, key: string, hardDelete?: boolean): Promise<boolean>;
+    /**
+     * Delete a memory entry by ID
+     */
+    deleteById(id: string, hardDelete?: boolean): Promise<boolean>;
+    /**
+     * Delete all entries in a namespace
+     */
+    deleteNamespace(namespace: string, hardDelete?: boolean): Promise<number>;
+    /**
+     * Clear all memory entries
+     */
+    clear(): Promise<void>;
+    /**
+     * Consolidate memories using specified strategy
+     */
+    consolidate(options: ConsolidationOptions): Promise<ConsolidationResult>;
+    /**
+     * Clean up expired memories
+     */
+    cleanupExpired(): Promise<number>;
+    /**
+     * Archive cold (rarely accessed) memories
+     */
+    archiveCold(milliseconds?: number): Promise<number>;
+    /**
+     * Get memory statistics
+     */
+    getStatistics(): Promise<MemoryStatistics>;
+    /**
+     * Count entries matching criteria
+     */
+    count(options?: {
+        namespace?: string;
+        type?: MemoryType;
+    }): Promise<number>;
+    /**
+     * Analyze a namespace
+     */
+    analyzeNamespace(namespace: string): Promise<import("../../domain/index.js").NamespaceAnalysis>;
+    /**
+     * Initialize the memory service
+     */
+    initialize(): Promise<void>;
+    /**
+     * Shutdown the memory service
+     */
+    shutdown(): Promise<void>;
+}
+//# sourceMappingURL=memory-application-service.d.ts.map

package/src/@claude-flow/memory/dist/application/services/memory-application-service.js

@@ -0,0 +1,190 @@
+/**
+ * Memory Application Service - Application Layer
+ *
+ * Orchestrates use cases and coordinates between domain and infrastructure.
+ * Provides a simplified interface for external consumers.
+ *
+ * @module v3/memory/application/services
+ */
+import { MemoryDomainService } from '../../domain/services/memory-domain-service.js';
+import { StoreMemoryCommandHandler } from '../commands/store-memory.command.js';
+import { DeleteMemoryCommandHandler, BulkDeleteMemoryCommandHandler } from '../commands/delete-memory.command.js';
+import { SearchMemoryQueryHandler, GetMemoryByKeyQueryHandler } from '../queries/search-memory.query.js';
+/**
+ * Memory Application Service
+ *
+ * Main entry point for memory operations.
+ * Coordinates commands and queries with domain services.
+ */
+export class MemoryApplicationService {
+    repository;
+    domainService;
+    storeHandler;
+    deleteHandler;
+    bulkDeleteHandler;
+    searchHandler;
+    getByKeyHandler;
+    constructor(repository) {
+        this.repository = repository;
+        this.domainService = new MemoryDomainService(repository);
+        this.storeHandler = new StoreMemoryCommandHandler(repository, this.domainService);
+        this.deleteHandler = new DeleteMemoryCommandHandler(repository);
+        this.bulkDeleteHandler = new BulkDeleteMemoryCommandHandler(repository);
+        this.searchHandler = new SearchMemoryQueryHandler(repository);
+        this.getByKeyHandler = new GetMemoryByKeyQueryHandler(repository);
+    }
+    // ============================================================================
+    // Store Operations (Commands)
+    // ============================================================================
+    /**
+     * Store a memory entry
+     */
+    async store(input) {
+        const result = await this.storeHandler.execute(input);
+        return result.entry;
+    }
+    /**
+     * Store multiple memory entries
+     */
+    async storeMany(inputs) {
+        const results = await Promise.all(inputs.map((input) => this.storeHandler.execute(input)));
+        return results.map((r) => r.entry);
+    }
+    // ============================================================================
+    // Retrieve Operations (Queries)
+    // ============================================================================
+    /**
+     * Get a memory entry by namespace and key
+     */
+    async get(namespace, key) {
+        const result = await this.getByKeyHandler.execute({ namespace, key, trackAccess: true });
+        return result.entry ?? null;
+    }
+    /**
+     * Get a memory entry by ID
+     */
+    async getById(id) {
+        return this.repository.findById(id);
+    }
+    /**
+     * Search memory entries
+     */
+    async search(input) {
+        const result = await this.searchHandler.execute(input);
+        return {
+            entries: result.entries,
+            total: result.total,
+            hasMore: result.hasMore,
+        };
+    }
+    /**
+     * Search by vector similarity
+     */
+    async searchByVector(vector, options) {
+        return this.domainService.searchSimilarWithTracking(vector, options?.namespace, options?.limit ?? 10);
+    }
+    /**
+     * Get all entries in a namespace
+     */
+    async getNamespace(namespace) {
+        return this.repository.findByNamespace(namespace, { status: 'active' });
+    }
+    /**
+     * List all namespaces
+     */
+    async listNamespaces() {
+        return this.repository.listNamespaces();
+    }
+    // ============================================================================
+    // Delete Operations (Commands)
+    // ============================================================================
+    /**
+     * Delete a memory entry by namespace and key
+     */
+    async delete(namespace, key, hardDelete = false) {
+        const result = await this.deleteHandler.execute({ namespace, key, hardDelete });
+        return result.deleted;
+    }
+    /**
+     * Delete a memory entry by ID
+     */
+    async deleteById(id, hardDelete = false) {
+        const result = await this.deleteHandler.execute({ id, hardDelete });
+        return result.deleted;
+    }
+    /**
+     * Delete all entries in a namespace
+     */
+    async deleteNamespace(namespace, hardDelete = false) {
+        const entries = await this.repository.findByNamespace(namespace);
+        const result = await this.bulkDeleteHandler.execute({
+            ids: entries.map((e) => e.id),
+            hardDelete,
+        });
+        return result.deletedCount;
+    }
+    /**
+     * Clear all memory entries
+     */
+    async clear() {
+        await this.repository.clear();
+    }
+    // ============================================================================
+    // Maintenance Operations
+    // ============================================================================
+    /**
+     * Consolidate memories using specified strategy
+     */
+    async consolidate(options) {
+        return this.domainService.consolidate(options);
+    }
+    /**
+     * Clean up expired memories
+     */
+    async cleanupExpired() {
+        return this.repository.deleteExpired();
+    }
+    /**
+     * Archive cold (rarely accessed) memories
+     */
+    async archiveCold(milliseconds = 86400000) {
+        return this.repository.archiveCold(milliseconds);
+    }
+    // ============================================================================
+    // Statistics
+    // ============================================================================
+    /**
+     * Get memory statistics
+     */
+    async getStatistics() {
+        return this.repository.getStatistics();
+    }
+    /**
+     * Count entries matching criteria
+     */
+    async count(options) {
+        return this.repository.count(options);
+    }
+    /**
+     * Analyze a namespace
+     */
+    async analyzeNamespace(namespace) {
+        return this.domainService.analyzeNamespace(namespace);
+    }
+    // ============================================================================
+    // Lifecycle
+    // ============================================================================
+    /**
+     * Initialize the memory service
+     */
+    async initialize() {
+        await this.repository.initialize();
+    }
+    /**
+     * Shutdown the memory service
+     */
+    async shutdown() {
+        await this.repository.shutdown();
+    }
+}
+//# sourceMappingURL=memory-application-service.js.map

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

@@ -0,0 +1,226 @@
+/**
+ * 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