@cmdoss/memwal-sdk 0.6.0

package/dist/pipeline/PipelineManager.d.ts

@@ -0,0 +1,178 @@
+/**
+ * PipelineManager - High-Level Pipeline Orchestration
+ *
+ * Manages multiple pipeline instances, provides scheduling, monitoring,
+ * and administration capabilities for memory processing workflows.
+ */
+import { MemoryPipeline, PipelineConfig, PipelineExecution } from './MemoryPipeline';
+import { Memory } from '../embedding/types';
+export interface PipelineManagerConfig {
+    maxConcurrentPipelines?: number;
+    defaultPipelineConfig?: PipelineConfig;
+    enableScheduling?: boolean;
+    enableHealthChecks?: boolean;
+    healthCheckIntervalMs?: number;
+    enableMetricsCollection?: boolean;
+    metricsRetentionDays?: number;
+}
+export interface ManagedPipeline {
+    id: string;
+    name: string;
+    pipeline: MemoryPipeline;
+    config: PipelineConfig;
+    status: 'active' | 'paused' | 'stopped';
+    createdAt: Date;
+    lastUsed: Date;
+    executionCount: number;
+}
+export interface PipelineSchedule {
+    id: string;
+    pipelineId: string;
+    userId: string;
+    memories: Memory[];
+    scheduledAt: Date;
+    priority: 'low' | 'normal' | 'high';
+    status: 'scheduled' | 'running' | 'completed' | 'failed';
+    result?: PipelineExecution[];
+}
+export interface SystemMetrics {
+    totalPipelines: number;
+    activePipelines: number;
+    totalExecutions: number;
+    activeExecutions: number;
+    systemLoad: number;
+    memoryUsage: {
+        used: number;
+        total: number;
+        percentage: number;
+    };
+    performance: {
+        averageExecutionTime: number;
+        throughput: number;
+        successRate: number;
+    };
+    health: {
+        status: 'healthy' | 'degraded' | 'critical';
+        issues: string[];
+        lastCheck: Date;
+    };
+}
+export interface PipelineTemplate {
+    name: string;
+    description: string;
+    config: PipelineConfig;
+    category: 'basic' | 'advanced' | 'custom';
+    tags: string[];
+}
+/**
+ * High-level pipeline management and orchestration
+ */
+export declare class PipelineManager {
+    private pipelines;
+    private schedules;
+    private healthCheckTimer?;
+    private readonly config;
+    private systemMetrics;
+    private readonly PIPELINE_TEMPLATES;
+    constructor(config?: PipelineManagerConfig);
+    /**
+     * Create a new managed pipeline
+     */
+    createPipeline(name: string, config?: PipelineConfig, options?: {
+        autoStart?: boolean;
+        description?: string;
+    }): string;
+    /**
+     * Create pipeline from template
+     */
+    createPipelineFromTemplate(templateName: string, customName: string, configOverrides?: Partial<PipelineConfig>): string;
+    /**
+     * Get pipeline templates
+     */
+    getPipelineTemplates(): PipelineTemplate[];
+    /**
+     * Get managed pipeline
+     */
+    getPipeline(pipelineId: string): ManagedPipeline | null;
+    /**
+     * List all pipelines
+     */
+    listPipelines(): ManagedPipeline[];
+    /**
+     * Start pipeline
+     */
+    startPipeline(pipelineId: string): boolean;
+    /**
+     * Pause pipeline
+     */
+    pausePipeline(pipelineId: string): boolean;
+    /**
+     * Stop and remove pipeline
+     */
+    removePipeline(pipelineId: string): boolean;
+    /**
+     * Process memory using specified pipeline
+     */
+    processMemory(pipelineId: string, memory: Memory, userId: string, options?: any): Promise<PipelineExecution>;
+    /**
+     * Process memories in batch using specified pipeline
+     */
+    processMemoriesBatch(pipelineId: string, memories: Memory[], userId: string, options?: any): Promise<PipelineExecution[]>;
+    /**
+     * Schedule memory processing
+     */
+    scheduleMemoryProcessing(pipelineId: string, userId: string, memories: Memory[], scheduledAt: Date, priority?: 'low' | 'normal' | 'high'): string;
+    /**
+     * Get scheduled processing jobs
+     */
+    getScheduledJobs(): PipelineSchedule[];
+    /**
+     * Cancel scheduled job
+     */
+    cancelScheduledJob(scheduleId: string): boolean;
+    /**
+     * Get system metrics
+     */
+    getSystemMetrics(): SystemMetrics;
+    /**
+     * Get pipeline health status
+     */
+    getPipelineHealth(pipelineId: string): any;
+    /**
+     * Get all pipeline executions
+     */
+    getAllExecutions(): {
+        pipelineId: string;
+        executions: PipelineExecution[];
+    }[];
+    /**
+     * Cleanup completed executions across all pipelines
+     */
+    cleanupCompletedExecutions(): number;
+    /**
+     * Get system health summary
+     */
+    getSystemHealth(): {
+        overallStatus: 'healthy' | 'degraded' | 'critical';
+        pipelineHealth: Array<{
+            pipelineId: string;
+            status: string;
+            issues: string[];
+        }>;
+        systemLoad: number;
+        recommendations: string[];
+    };
+    /**
+     * Shutdown pipeline manager
+     */
+    shutdown(): void;
+    private executeScheduledProcessing;
+    private startHealthChecks;
+    private performHealthCheck;
+    private updateSystemMetrics;
+    private updatePerformanceMetrics;
+    private generatePipelineId;
+    private generateScheduleId;
+}
+export default PipelineManager;
+//# sourceMappingURL=PipelineManager.d.ts.map

package/dist/pipeline/PipelineManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PipelineManager.d.ts","sourceRoot":"","sources":["../../src/pipeline/PipelineManager.ts"],"names":[],"mappings":"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"}

package/dist/pipeline/PipelineManager.js

@@ -0,0 +1,485 @@
+/**
+ * PipelineManager - High-Level Pipeline Orchestration
+ *
+ * Manages multiple pipeline instances, provides scheduling, monitoring,
+ * and administration capabilities for memory processing workflows.
+ */
+import { MemoryPipeline } from './MemoryPipeline.js';
+/**
+ * High-level pipeline management and orchestration
+ */
+export class PipelineManager {
+    constructor(config = {}) {
+        this.pipelines = new Map();
+        this.schedules = new Map();
+        this.systemMetrics = {
+            totalPipelines: 0,
+            activePipelines: 0,
+            totalExecutions: 0,
+            activeExecutions: 0,
+            systemLoad: 0,
+            memoryUsage: { used: 0, total: 0, percentage: 0 },
+            performance: { averageExecutionTime: 0, throughput: 0, successRate: 0 },
+            health: { status: 'healthy', issues: [], lastCheck: new Date() }
+        };
+        this.PIPELINE_TEMPLATES = [
+            {
+                name: 'Basic Memory Processing',
+                description: 'Simple memory processing with embedding and storage',
+                category: 'basic',
+                tags: ['embedding', 'storage'],
+                config: {
+                    embedding: { enableBatching: true, batchSize: 10 },
+                    storage: { enableEncryption: false },
+                    blockchain: { enableOwnershipTracking: false }
+                }
+            },
+            {
+                name: 'Full Decentralized Pipeline',
+                description: 'Complete pipeline with all features enabled',
+                category: 'advanced',
+                tags: ['embedding', 'vector', 'graph', 'storage', 'blockchain'],
+                config: {
+                    embedding: { enableBatching: true, batchSize: 20 },
+                    vector: { enablePersistence: true },
+                    graph: { enableExtraction: true, confidenceThreshold: 0.7 },
+                    storage: { enableEncryption: true, enableBatching: true },
+                    blockchain: { enableOwnershipTracking: true, enableBatching: true }
+                }
+            },
+            {
+                name: 'High-Performance Batch Processing',
+                description: 'Optimized for high-throughput batch processing',
+                category: 'advanced',
+                tags: ['batch', 'performance', 'throughput'],
+                config: {
+                    embedding: { enableBatching: true, batchSize: 50 },
+                    batch: { enableBatching: true, batchSize: 100, batchDelayMs: 2000 },
+                    vector: { maxElements: 50000 },
+                    skipFailedSteps: true,
+                    maxRetryAttempts: 1
+                }
+            }
+        ];
+        this.config = {
+            maxConcurrentPipelines: config.maxConcurrentPipelines || 10,
+            defaultPipelineConfig: config.defaultPipelineConfig || {},
+            enableScheduling: config.enableScheduling !== false,
+            enableHealthChecks: config.enableHealthChecks !== false,
+            healthCheckIntervalMs: config.healthCheckIntervalMs || 30000, // 30 seconds
+            enableMetricsCollection: config.enableMetricsCollection !== false,
+            metricsRetentionDays: config.metricsRetentionDays || 7
+        };
+        this.startHealthChecks();
+    }
+    // ==================== PIPELINE MANAGEMENT ====================
+    /**
+     * Create a new managed pipeline
+     */
+    createPipeline(name, config = {}, options = {}) {
+        if (this.pipelines.size >= this.config.maxConcurrentPipelines) {
+            throw new Error(`Maximum concurrent pipelines limit reached: ${this.config.maxConcurrentPipelines}`);
+        }
+        const pipelineId = this.generatePipelineId();
+        const mergedConfig = { ...this.config.defaultPipelineConfig, ...config };
+        const managedPipeline = {
+            id: pipelineId,
+            name,
+            pipeline: new MemoryPipeline(mergedConfig),
+            config: mergedConfig,
+            status: options.autoStart !== false ? 'active' : 'paused',
+            createdAt: new Date(),
+            lastUsed: new Date(),
+            executionCount: 0
+        };
+        this.pipelines.set(pipelineId, managedPipeline);
+        this.systemMetrics.totalPipelines++;
+        if (managedPipeline.status === 'active') {
+            this.systemMetrics.activePipelines++;
+        }
+        console.log(`✅ Created pipeline: ${name} (${pipelineId})`);
+        return pipelineId;
+    }
+    /**
+     * Create pipeline from template
+     */
+    createPipelineFromTemplate(templateName, customName, configOverrides = {}) {
+        const template = this.PIPELINE_TEMPLATES.find(t => t.name === templateName);
+        if (!template) {
+            throw new Error(`Pipeline template not found: ${templateName}`);
+        }
+        const config = { ...template.config, ...configOverrides };
+        return this.createPipeline(customName, config);
+    }
+    /**
+     * Get pipeline templates
+     */
+    getPipelineTemplates() {
+        return [...this.PIPELINE_TEMPLATES];
+    }
+    /**
+     * Get managed pipeline
+     */
+    getPipeline(pipelineId) {
+        return this.pipelines.get(pipelineId) || null;
+    }
+    /**
+     * List all pipelines
+     */
+    listPipelines() {
+        return Array.from(this.pipelines.values());
+    }
+    /**
+     * Start pipeline
+     */
+    startPipeline(pipelineId) {
+        const managedPipeline = this.pipelines.get(pipelineId);
+        if (!managedPipeline) {
+            return false;
+        }
+        if (managedPipeline.status !== 'active') {
+            managedPipeline.status = 'active';
+            this.systemMetrics.activePipelines++;
+            console.log(`▶️ Started pipeline: ${managedPipeline.name}`);
+        }
+        return true;
+    }
+    /**
+     * Pause pipeline
+     */
+    pausePipeline(pipelineId) {
+        const managedPipeline = this.pipelines.get(pipelineId);
+        if (!managedPipeline) {
+            return false;
+        }
+        if (managedPipeline.status === 'active') {
+            managedPipeline.status = 'paused';
+            this.systemMetrics.activePipelines--;
+            console.log(`⏸️ Paused pipeline: ${managedPipeline.name}`);
+        }
+        return true;
+    }
+    /**
+     * Stop and remove pipeline
+     */
+    removePipeline(pipelineId) {
+        const managedPipeline = this.pipelines.get(pipelineId);
+        if (!managedPipeline) {
+            return false;
+        }
+        if (managedPipeline.status === 'active') {
+            this.systemMetrics.activePipelines--;
+        }
+        this.pipelines.delete(pipelineId);
+        this.systemMetrics.totalPipelines--;
+        console.log(`🗑️ Removed pipeline: ${managedPipeline.name}`);
+        return true;
+    }
+    // ==================== MEMORY PROCESSING ====================
+    /**
+     * Process memory using specified pipeline
+     */
+    async processMemory(pipelineId, memory, userId, options) {
+        const managedPipeline = this.pipelines.get(pipelineId);
+        if (!managedPipeline) {
+            throw new Error(`Pipeline not found: ${pipelineId}`);
+        }
+        if (managedPipeline.status !== 'active') {
+            throw new Error(`Pipeline is not active: ${managedPipeline.name}`);
+        }
+        // Update pipeline usage
+        managedPipeline.lastUsed = new Date();
+        managedPipeline.executionCount++;
+        this.systemMetrics.totalExecutions++;
+        this.systemMetrics.activeExecutions++;
+        try {
+            const execution = await managedPipeline.pipeline.processMemory(memory, userId, options);
+            // Update metrics
+            this.systemMetrics.activeExecutions--;
+            this.updatePerformanceMetrics(managedPipeline);
+            return execution;
+        }
+        catch (error) {
+            this.systemMetrics.activeExecutions--;
+            throw error;
+        }
+    }
+    /**
+     * Process memories in batch using specified pipeline
+     */
+    async processMemoriesBatch(pipelineId, memories, userId, options) {
+        const managedPipeline = this.pipelines.get(pipelineId);
+        if (!managedPipeline) {
+            throw new Error(`Pipeline not found: ${pipelineId}`);
+        }
+        if (managedPipeline.status !== 'active') {
+            throw new Error(`Pipeline is not active: ${managedPipeline.name}`);
+        }
+        // Update pipeline usage
+        managedPipeline.lastUsed = new Date();
+        managedPipeline.executionCount += memories.length;
+        this.systemMetrics.totalExecutions += memories.length;
+        this.systemMetrics.activeExecutions += memories.length;
+        try {
+            const executions = await managedPipeline.pipeline.processMemoriesBatch(memories, userId, options);
+            // Update metrics
+            this.systemMetrics.activeExecutions -= memories.length;
+            this.updatePerformanceMetrics(managedPipeline);
+            return executions;
+        }
+        catch (error) {
+            this.systemMetrics.activeExecutions -= memories.length;
+            throw error;
+        }
+    }
+    // ==================== SCHEDULING ====================
+    /**
+     * Schedule memory processing
+     */
+    scheduleMemoryProcessing(pipelineId, userId, memories, scheduledAt, priority = 'normal') {
+        if (!this.config.enableScheduling) {
+            throw new Error('Scheduling is not enabled');
+        }
+        const scheduleId = this.generateScheduleId();
+        const schedule = {
+            id: scheduleId,
+            pipelineId,
+            userId,
+            memories,
+            scheduledAt,
+            priority,
+            status: 'scheduled'
+        };
+        this.schedules.set(scheduleId, schedule);
+        // Set timeout for execution
+        const delay = scheduledAt.getTime() - Date.now();
+        if (delay > 0) {
+            setTimeout(() => {
+                this.executeScheduledProcessing(scheduleId);
+            }, delay);
+        }
+        else {
+            // Execute immediately if time has passed
+            setImmediate(() => this.executeScheduledProcessing(scheduleId));
+        }
+        console.log(`📅 Scheduled processing for ${memories.length} memories at ${scheduledAt.toISOString()}`);
+        return scheduleId;
+    }
+    /**
+     * Get scheduled processing jobs
+     */
+    getScheduledJobs() {
+        return Array.from(this.schedules.values());
+    }
+    /**
+     * Cancel scheduled job
+     */
+    cancelScheduledJob(scheduleId) {
+        const schedule = this.schedules.get(scheduleId);
+        if (!schedule || schedule.status !== 'scheduled') {
+            return false;
+        }
+        schedule.status = 'failed';
+        console.log(`❌ Cancelled scheduled job: ${scheduleId}`);
+        return true;
+    }
+    // ==================== MONITORING & HEALTH ====================
+    /**
+     * Get system metrics
+     */
+    getSystemMetrics() {
+        this.updateSystemMetrics();
+        return { ...this.systemMetrics };
+    }
+    /**
+     * Get pipeline health status
+     */
+    getPipelineHealth(pipelineId) {
+        const managedPipeline = this.pipelines.get(pipelineId);
+        if (!managedPipeline) {
+            return null;
+        }
+        return managedPipeline.pipeline.getPipelineHealth();
+    }
+    /**
+     * Get all pipeline executions
+     */
+    getAllExecutions() {
+        const results = [];
+        for (const [pipelineId, managedPipeline] of this.pipelines.entries()) {
+            const executions = managedPipeline.pipeline.getUserExecutions(''); // Get all executions
+            results.push({ pipelineId, executions });
+        }
+        return results;
+    }
+    /**
+     * Cleanup completed executions across all pipelines
+     */
+    cleanupCompletedExecutions() {
+        let totalCleared = 0;
+        for (const managedPipeline of this.pipelines.values()) {
+            const cleared = managedPipeline.pipeline.clearCompletedExecutions();
+            totalCleared += cleared;
+        }
+        console.log(`🧹 Cleaned up ${totalCleared} completed executions across all pipelines`);
+        return totalCleared;
+    }
+    /**
+     * Get system health summary
+     */
+    getSystemHealth() {
+        const pipelineHealth = [];
+        let overallStatus = 'healthy';
+        const recommendations = [];
+        // Check each pipeline health
+        for (const [pipelineId, managedPipeline] of this.pipelines.entries()) {
+            const health = managedPipeline.pipeline.getPipelineHealth();
+            pipelineHealth.push({
+                pipelineId,
+                status: health.status,
+                issues: health.issues
+            });
+            if (health.status === 'critical') {
+                overallStatus = 'critical';
+            }
+            else if (health.status === 'degraded' && overallStatus !== 'critical') {
+                overallStatus = 'degraded';
+            }
+        }
+        // System-level recommendations
+        if (this.systemMetrics.activePipelines > 8) {
+            recommendations.push('High number of active pipelines - consider consolidation');
+        }
+        if (this.systemMetrics.systemLoad > 0.8) {
+            recommendations.push('High system load - consider reducing concurrent operations');
+        }
+        return {
+            overallStatus,
+            pipelineHealth,
+            systemLoad: this.systemMetrics.systemLoad,
+            recommendations
+        };
+    }
+    /**
+     * Shutdown pipeline manager
+     */
+    shutdown() {
+        console.log('🛑 Shutting down PipelineManager...');
+        // Clear health check timer
+        if (this.healthCheckTimer) {
+            clearInterval(this.healthCheckTimer);
+        }
+        // Pause all pipelines
+        for (const [pipelineId] of this.pipelines.entries()) {
+            this.pausePipeline(pipelineId);
+        }
+        console.log('✅ PipelineManager shutdown complete');
+    }
+    // ==================== PRIVATE METHODS ====================
+    async executeScheduledProcessing(scheduleId) {
+        const schedule = this.schedules.get(scheduleId);
+        if (!schedule || schedule.status !== 'scheduled') {
+            return;
+        }
+        schedule.status = 'running';
+        try {
+            console.log(`🚀 Executing scheduled processing: ${scheduleId}`);
+            const executions = await this.processMemoriesBatch(schedule.pipelineId, schedule.memories, schedule.userId);
+            schedule.status = 'completed';
+            schedule.result = executions;
+            console.log(`✅ Scheduled processing completed: ${scheduleId}`);
+        }
+        catch (error) {
+            schedule.status = 'failed';
+            console.error(`❌ Scheduled processing failed: ${scheduleId}`, error);
+        }
+    }
+    startHealthChecks() {
+        if (!this.config.enableHealthChecks) {
+            return;
+        }
+        this.healthCheckTimer = setInterval(() => {
+            this.performHealthCheck();
+        }, this.config.healthCheckIntervalMs);
+        console.log(`💚 Started health checks (interval: ${this.config.healthCheckIntervalMs}ms)`);
+    }
+    performHealthCheck() {
+        const issues = [];
+        let status = 'healthy';
+        // Check system load
+        const activeExecutions = this.systemMetrics.activeExecutions;
+        const maxConcurrent = this.config.maxConcurrentPipelines * 10; // Estimated max
+        this.systemMetrics.systemLoad = activeExecutions / maxConcurrent;
+        if (this.systemMetrics.systemLoad > 0.9) {
+            issues.push('System overloaded');
+            status = 'critical';
+        }
+        else if (this.systemMetrics.systemLoad > 0.7) {
+            issues.push('High system load');
+            if (status === 'healthy')
+                status = 'degraded';
+        }
+        // Check pipeline health
+        for (const managedPipeline of this.pipelines.values()) {
+            const pipelineHealth = managedPipeline.pipeline.getPipelineHealth();
+            if (pipelineHealth.status === 'critical') {
+                issues.push(`Pipeline ${managedPipeline.name} is critical`);
+                status = 'critical';
+            }
+            else if (pipelineHealth.status === 'degraded') {
+                issues.push(`Pipeline ${managedPipeline.name} is degraded`);
+                if (status === 'healthy')
+                    status = 'degraded';
+            }
+        }
+        this.systemMetrics.health = {
+            status,
+            issues,
+            lastCheck: new Date()
+        };
+        if (issues.length > 0) {
+            console.warn(`⚠️ Health check issues detected:`, issues);
+        }
+    }
+    updateSystemMetrics() {
+        // Update basic counts
+        this.systemMetrics.totalPipelines = this.pipelines.size;
+        this.systemMetrics.activePipelines = Array.from(this.pipelines.values())
+            .filter(p => p.status === 'active').length;
+        // Calculate performance metrics
+        let totalExecutions = 0;
+        let totalProcessingTime = 0;
+        let successfulExecutions = 0;
+        for (const managedPipeline of this.pipelines.values()) {
+            const metrics = managedPipeline.pipeline.getPipelineMetrics();
+            totalExecutions += metrics.totalExecutions;
+            successfulExecutions += metrics.successfulExecutions;
+            totalProcessingTime += metrics.averageProcessingTime * metrics.totalExecutions;
+        }
+        this.systemMetrics.performance = {
+            averageExecutionTime: totalExecutions > 0 ? totalProcessingTime / totalExecutions : 0,
+            throughput: Array.from(this.pipelines.values()).reduce((sum, p) => sum + p.pipeline.getPipelineMetrics().throughput.memoriesPerHour, 0),
+            successRate: totalExecutions > 0 ? successfulExecutions / totalExecutions : 1
+        };
+        // Update memory usage (simplified)
+        this.systemMetrics.memoryUsage = {
+            used: this.systemMetrics.activeExecutions * 10, // Estimated MB per execution
+            total: 1024, // Estimated total available MB
+            percentage: (this.systemMetrics.activeExecutions * 10) / 1024
+        };
+    }
+    updatePerformanceMetrics(managedPipeline) {
+        // Update performance tracking for the pipeline
+        const metrics = managedPipeline.pipeline.getPipelineMetrics();
+        // Could implement more sophisticated performance tracking here
+        // For now, metrics are tracked within each pipeline
+    }
+    generatePipelineId() {
+        return `pipeline_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+    }
+    generateScheduleId() {
+        return `schedule_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+    }
+}
+export default PipelineManager;
+//# sourceMappingURL=PipelineManager.js.map