moflo 4.8.16 → 4.8.19

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

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

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

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

@@ -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