@exaudeus/workrail 0.1.0 → 0.1.2

package/dist/application/services/context-management-service.js

@@ -0,0 +1,301 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextManagementService = void 0;
+const crypto = __importStar(require("crypto"));
+const error_handler_1 = require("../../core/error-handler");
+class ContextManagementService {
+    constructor(persistenceService, storage) {
+        this.persistenceService = persistenceService;
+        this.storage = storage;
+        this.metrics = {
+            totalSaveOperations: 0,
+            totalLoadOperations: 0,
+            totalListOperations: 0,
+            totalMarkCriticalOperations: 0,
+            averageSaveTime: 0,
+            averageLoadTime: 0,
+            lastOperationTime: 0,
+            errorCount: 0
+        };
+    }
+    async saveCheckpoint(params) {
+        const startTimeMs = Date.now();
+        try {
+            const frozenParams = Object.freeze({ ...params });
+            const frozenContext = Object.freeze({ ...frozenParams.context });
+            const sessionId = frozenParams.sessionId || this.generateSessionId(frozenContext);
+            const lastCheckpointData = await this.getLastCheckpointData(sessionId);
+            const currentHash = this.hashContext(frozenParams.context);
+            if (!frozenParams.force && lastCheckpointData && lastCheckpointData.contextHash === currentHash) {
+                return {
+                    checkpointId: lastCheckpointData.id || 'none',
+                    sessionId,
+                    status: 'SKIPPED_UNCHANGED',
+                    sizeBytes: lastCheckpointData.contextSizeBytes || undefined
+                };
+            }
+            const pipelineResult = await this.persistenceService.processPersistencePipeline(frozenParams.context, '');
+            const checkpointId = this.generateCheckpointId(sessionId);
+            const metadata = {
+                id: checkpointId,
+                sessionId,
+                name: frozenParams.metadata?.name,
+                agentId: 'default',
+                createdAt: new Date().toISOString(),
+                tags: frozenParams.metadata?.tags,
+                contextSizeBytes: pipelineResult.compressed.compressedSize,
+                contextHash: currentHash,
+                blobPath: '',
+                classificationSummary: {
+                    criticalCount: this.countLayers(pipelineResult.classified, 'CRITICAL'),
+                    importantCount: this.countLayers(pipelineResult.classified, 'IMPORTANT'),
+                    usefulCount: this.countLayers(pipelineResult.classified, 'USEFUL'),
+                    ephemeralCount: this.countLayers(pipelineResult.classified, 'EPHEMERAL')
+                },
+                status: 'active'
+            };
+            await this.storage.saveCheckpoint(metadata, pipelineResult.compressed);
+            await this.upsertSessionInfo(sessionId);
+            const endTime = Date.now();
+            this.updateSaveMetrics(endTime - startTimeMs);
+            return {
+                checkpointId,
+                sessionId,
+                status: 'SAVED',
+                sizeBytes: pipelineResult.compressed.compressedSize
+            };
+        }
+        catch (error) {
+            this.metrics.errorCount++;
+            throw new Error(`Failed to save checkpoint: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    async loadCheckpoint(params) {
+        const startTime = process.hrtime.bigint();
+        try {
+            const frozenParams = Object.freeze({ ...params });
+            if (!frozenParams.checkpointId && !frozenParams.sessionId) {
+                throw new Error('Either checkpointId or sessionId must be provided');
+            }
+            let checkpointId;
+            if (frozenParams.checkpointId) {
+                checkpointId = frozenParams.checkpointId;
+            }
+            else {
+                const checkpoints = await this.storage.listCheckpoints(frozenParams.sessionId, 1, 0);
+                if (!checkpoints || checkpoints.length === 0) {
+                    throw new Error(`No checkpoints found for session: ${frozenParams.sessionId}`);
+                }
+                checkpointId = checkpoints[0].id;
+            }
+            const checkpointData = await this.storage.loadCheckpoint(checkpointId);
+            if (!checkpointData) {
+                throw new error_handler_1.CheckpointNotFoundError(checkpointId);
+            }
+            const restorationResult = await this.persistenceService.restoreFromPersistence(checkpointData.blob);
+            const metadata = checkpointData.metadata;
+            if (!metadata) {
+                throw new error_handler_1.CheckpointNotFoundError(checkpointId);
+            }
+            const endTime = process.hrtime.bigint();
+            this.updateLoadMetrics(endTime);
+            return {
+                checkpointId,
+                sessionId: metadata.sessionId,
+                context: restorationResult.context,
+                metadata: {
+                    name: metadata.name,
+                    tags: metadata.tags,
+                    createdAt: metadata.createdAt,
+                    contextSizeBytes: metadata.contextSizeBytes
+                }
+            };
+        }
+        catch (error) {
+            this.metrics.errorCount++;
+            throw new Error(`Failed to load checkpoint: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    async listCheckpoints(params) {
+        const startTime = process.hrtime.bigint();
+        try {
+            const frozenParams = Object.freeze({ ...params });
+            const checkpoints = await this.storage.listCheckpoints(frozenParams.sessionId, frozenParams.limit || 20, frozenParams.offset || 0);
+            const endTime = process.hrtime.bigint();
+            this.updateListMetrics(endTime);
+            return checkpoints;
+        }
+        catch (error) {
+            this.metrics.errorCount++;
+            throw new Error(`Failed to list checkpoints: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    async markCritical(params) {
+        const startTime = process.hrtime.bigint();
+        try {
+            const frozenParams = Object.freeze({ ...params });
+            const classificationEngine = this.persistenceService.getClassificationEngine();
+            await classificationEngine.markCritical(frozenParams.sessionId, frozenParams.contextKey);
+            const endTime = process.hrtime.bigint();
+            this.updateMarkCriticalMetrics(endTime);
+            return {
+                status: 'SUCCESS',
+                message: `Key '${frozenParams.contextKey}' marked as critical for session '${frozenParams.sessionId}'`
+            };
+        }
+        catch (error) {
+            this.metrics.errorCount++;
+            throw new Error(`Failed to mark critical: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    getMetrics() {
+        return Object.freeze({ ...this.metrics });
+    }
+    resetMetrics() {
+        this.metrics = {
+            totalSaveOperations: 0,
+            totalLoadOperations: 0,
+            totalListOperations: 0,
+            totalMarkCriticalOperations: 0,
+            averageSaveTime: 0,
+            averageLoadTime: 0,
+            lastOperationTime: 0,
+            errorCount: 0
+        };
+    }
+    generateSessionId(context) {
+        const contextString = JSON.stringify(context, Object.keys(context).sort());
+        const hash = crypto.createHash('sha256').update(contextString).digest('hex');
+        return `session_${hash.substring(0, 16)}`;
+    }
+    generateCheckpointId(sessionId) {
+        const timestamp = Date.now();
+        const randomSuffix = crypto.randomBytes(4).toString('hex');
+        return `${sessionId}_checkpoint_${timestamp}_${randomSuffix}`;
+    }
+    async isContextUnchanged(sessionId, context) {
+        try {
+            const lastCheckpointData = await this.getLastCheckpointData(sessionId);
+            if (!lastCheckpointData.contextHash) {
+                return false;
+            }
+            const currentHash = this.hashContext(context);
+            return currentHash === lastCheckpointData.contextHash;
+        }
+        catch (error) {
+            console.warn(`Failed to check context changes: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            return false;
+        }
+    }
+    async getLastCheckpointId(sessionId) {
+        const lastCheckpointData = await this.getLastCheckpointData(sessionId);
+        return lastCheckpointData.id || null;
+    }
+    countLayers(classified, layerType) {
+        if (!classified || typeof classified !== 'object') {
+            return 0;
+        }
+        const layer = classified[layerType];
+        if (!layer || typeof layer !== 'object') {
+            return 0;
+        }
+        return Object.keys(layer).length;
+    }
+    async upsertSessionInfo(sessionId) {
+        try {
+            const sessionInfo = {
+                id: sessionId,
+                createdAt: new Date().toISOString(),
+                lastAccessedAt: new Date().toISOString(),
+                totalSizeBytes: 0
+            };
+            await this.storage.upsertSession(sessionInfo);
+        }
+        catch (error) {
+            console.warn(`Failed to update session info: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    updateSaveMetrics(operationTime) {
+        this.metrics.totalSaveOperations++;
+        this.metrics.averageSaveTime = this.calculateMovingAverage(this.metrics.averageSaveTime, operationTime, this.metrics.totalSaveOperations);
+        this.metrics.lastOperationTime = operationTime;
+    }
+    updateLoadMetrics(startTime) {
+        const endTime = process.hrtime.bigint();
+        const operationTime = Number(endTime - startTime) / 1000000;
+        this.metrics.totalLoadOperations++;
+        this.metrics.averageLoadTime = this.calculateMovingAverage(this.metrics.averageLoadTime, operationTime, this.metrics.totalLoadOperations);
+        this.metrics.lastOperationTime = operationTime;
+    }
+    updateListMetrics(startTime) {
+        const endTime = process.hrtime.bigint();
+        const operationTime = Number(endTime - startTime) / 1000000;
+        this.metrics.totalListOperations++;
+        this.metrics.lastOperationTime = operationTime;
+    }
+    updateMarkCriticalMetrics(startTime) {
+        const endTime = process.hrtime.bigint();
+        const operationTime = Number(endTime - startTime) / 1000000;
+        this.metrics.totalMarkCriticalOperations++;
+        this.metrics.lastOperationTime = operationTime;
+    }
+    calculateMovingAverage(currentAverage, newValue, count) {
+        return ((currentAverage * (count - 1)) + newValue) / count;
+    }
+    hashContext(context) {
+        const contextString = JSON.stringify(context, Object.keys(context).sort());
+        return crypto.createHash('sha256').update(contextString).digest('hex');
+    }
+    async getLastCheckpointData(sessionId) {
+        try {
+            const checkpoints = await this.storage.listCheckpoints(sessionId, 1, 0);
+            if (!checkpoints || checkpoints.length === 0) {
+                return { id: undefined, contextSizeBytes: undefined, contextHash: undefined };
+            }
+            const checkpoint = checkpoints[0];
+            return {
+                id: checkpoint.id,
+                contextSizeBytes: checkpoint.contextSizeBytes,
+                contextHash: checkpoint.contextHash
+            };
+        }
+        catch (error) {
+            console.warn(`Failed to get last checkpoint data for session ${sessionId}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            return { id: undefined, contextSizeBytes: undefined, contextHash: undefined };
+        }
+    }
+}
+exports.ContextManagementService = ContextManagementService;

package/dist/application/services/context-persistence-service.d.ts

@@ -0,0 +1,45 @@
+import { IContextPersistenceService, IClassificationEngine, ICompressionService, RawContext, ClassifiedContext, PersistableContext, CompressedBlob, CompressionStats } from '../../types/context-types';
+interface PersistenceMetrics {
+    totalOperations: number;
+    averageClassificationTime: number;
+    averageCompressionTime: number;
+    averageTotalTime: number;
+    lastOperationTime: number;
+    compressionStats: CompressionStats;
+}
+export declare class ContextPersistenceService implements IContextPersistenceService {
+    private readonly classificationEngine;
+    private readonly compressionService;
+    private metrics;
+    constructor(classificationEngine: IClassificationEngine, compressionService: ICompressionService);
+    classifyContext(context: RawContext): Promise<ClassifiedContext>;
+    compressContext(classified: ClassifiedContext): Promise<CompressedBlob>;
+    decompressContext(compressed: CompressedBlob): Promise<RawContext>;
+    generateSessionId(workflowId: string, context: RawContext): string;
+    processPersistencePipeline(context: RawContext, workflowId: string): Promise<{
+        sessionId: string;
+        classified: ClassifiedContext;
+        compressed: CompressedBlob;
+        metrics: {
+            classificationTime: number;
+            compressionTime: number;
+            totalTime: number;
+        };
+    }>;
+    processRestorationPipeline(compressed: CompressedBlob): Promise<{
+        context: RawContext;
+        metrics: {
+            decompressionTime: number;
+        };
+    }>;
+    getMetrics(): PersistenceMetrics;
+    resetMetrics(): void;
+    restoreFromPersistence(persistableContext: PersistableContext): Promise<RawContext>;
+    private createFallbackClassification;
+    private createUncompressedBlob;
+    private generateFallbackSessionId;
+    private updateClassificationMetrics;
+    private updateCompressionMetrics;
+    private updatePipelineMetrics;
+}
+export {};

package/dist/application/services/context-persistence-service.js

@@ -0,0 +1,273 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextPersistenceService = void 0;
+const crypto = __importStar(require("crypto"));
+const context_types_1 = require("../../types/context-types");
+const SESSION_ID_CONFIG = {
+    algorithm: 'sha256',
+    encoding: 'hex',
+    maxLength: 32
+};
+class ContextPersistenceService {
+    constructor(classificationEngine, compressionService) {
+        this.classificationEngine = classificationEngine;
+        this.compressionService = compressionService;
+        this.metrics = {
+            totalOperations: 0,
+            averageClassificationTime: 0,
+            averageCompressionTime: 0,
+            averageTotalTime: 0,
+            lastOperationTime: 0,
+            compressionStats: {
+                totalOperations: 0,
+                averageRatio: 1.0,
+                totalSizeReduction: 0,
+                averageCompressionTime: 0
+            }
+        };
+    }
+    async classifyContext(context) {
+        const startTime = process.hrtime.bigint();
+        try {
+            const frozenContext = Object.freeze({ ...context });
+            const classified = await this.classificationEngine.classify(frozenContext);
+            const immutableClassified = {
+                [context_types_1.ContextLayer.CRITICAL]: Object.freeze({ ...classified[context_types_1.ContextLayer.CRITICAL] }),
+                [context_types_1.ContextLayer.IMPORTANT]: Object.freeze({ ...classified[context_types_1.ContextLayer.IMPORTANT] }),
+                [context_types_1.ContextLayer.USEFUL]: Object.freeze({ ...classified[context_types_1.ContextLayer.USEFUL] }),
+                [context_types_1.ContextLayer.EPHEMERAL]: Object.freeze({ ...classified[context_types_1.ContextLayer.EPHEMERAL] })
+            };
+            const endTime = process.hrtime.bigint();
+            const classificationTime = Number(endTime - startTime) / 1000000;
+            this.updateClassificationMetrics(classificationTime);
+            return Object.freeze(immutableClassified);
+        }
+        catch (error) {
+            console.error('Context classification failed:', error);
+            return this.createFallbackClassification(context);
+        }
+    }
+    async compressContext(classified) {
+        const startTime = process.hrtime.bigint();
+        try {
+            const frozenClassified = Object.freeze({ ...classified });
+            const compressed = await this.compressionService.compress(frozenClassified);
+            const endTime = process.hrtime.bigint();
+            const compressionTime = Number(endTime - startTime) / 1000000;
+            this.updateCompressionMetrics(compressionTime);
+            return compressed;
+        }
+        catch (error) {
+            console.error('Context compression failed:', error);
+            return this.createUncompressedBlob(classified);
+        }
+    }
+    async decompressContext(compressed) {
+        try {
+            const decompressed = await this.compressionService.decompress(compressed);
+            return Object.freeze({ ...decompressed });
+        }
+        catch (error) {
+            console.error('Context decompression failed:', error);
+            throw new Error(`Failed to decompress context: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    generateSessionId(workflowId, context) {
+        try {
+            const contextString = JSON.stringify(context, Object.keys(context).sort());
+            const contextHash = crypto
+                .createHash(SESSION_ID_CONFIG.algorithm)
+                .update(contextString)
+                .digest(SESSION_ID_CONFIG.encoding);
+            const combinedInput = `${workflowId}:${contextHash}`;
+            const sessionHash = crypto
+                .createHash(SESSION_ID_CONFIG.algorithm)
+                .update(combinedInput)
+                .digest(SESSION_ID_CONFIG.encoding);
+            const sessionId = sessionHash.substring(0, SESSION_ID_CONFIG.maxLength);
+            if (!/^[a-zA-Z0-9-]+$/.test(sessionId)) {
+                throw new Error('Generated session ID contains invalid characters');
+            }
+            return sessionId;
+        }
+        catch (error) {
+            console.warn('Session ID generation failed, using fallback:', error);
+            return this.generateFallbackSessionId(workflowId);
+        }
+    }
+    async processPersistencePipeline(context, workflowId) {
+        const pipelineStartTime = process.hrtime.bigint();
+        try {
+            const sessionId = this.generateSessionId(workflowId, context);
+            const classificationStart = process.hrtime.bigint();
+            const classified = await this.classifyContext(context);
+            const classificationEnd = process.hrtime.bigint();
+            const classificationTime = Number(classificationEnd - classificationStart) / 1000000;
+            const compressionStart = process.hrtime.bigint();
+            const compressed = await this.compressContext(classified);
+            const compressionEnd = process.hrtime.bigint();
+            const compressionTime = Number(compressionEnd - compressionStart) / 1000000;
+            const pipelineEndTime = process.hrtime.bigint();
+            const totalTime = Number(pipelineEndTime - pipelineStartTime) / 1000000;
+            this.updatePipelineMetrics(totalTime);
+            return {
+                sessionId,
+                classified: Object.freeze(classified),
+                compressed,
+                metrics: {
+                    classificationTime,
+                    compressionTime,
+                    totalTime
+                }
+            };
+        }
+        catch (error) {
+            console.error('Persistence pipeline failed:', error);
+            throw new Error(`Persistence pipeline error: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    async processRestorationPipeline(compressed) {
+        const startTime = process.hrtime.bigint();
+        try {
+            const context = await this.decompressContext(compressed);
+            const endTime = process.hrtime.bigint();
+            const decompressionTime = Number(endTime - startTime) / 1000000;
+            return {
+                context: Object.freeze(context),
+                metrics: {
+                    decompressionTime
+                }
+            };
+        }
+        catch (error) {
+            console.error('Restoration pipeline failed:', error);
+            throw new Error(`Restoration pipeline error: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    getMetrics() {
+        const latestCompressionStats = this.compressionService.getStats();
+        return {
+            ...this.metrics,
+            compressionStats: { ...latestCompressionStats }
+        };
+    }
+    resetMetrics() {
+        this.metrics = {
+            totalOperations: 0,
+            averageClassificationTime: 0,
+            averageCompressionTime: 0,
+            averageTotalTime: 0,
+            lastOperationTime: 0,
+            compressionStats: {
+                totalOperations: 0,
+                averageRatio: 1.0,
+                totalSizeReduction: 0,
+                averageCompressionTime: 0
+            }
+        };
+        this.compressionService.resetStats?.();
+    }
+    async restoreFromPersistence(persistableContext) {
+        const startTime = process.hrtime.bigint();
+        try {
+            const frozenPersistable = Object.freeze({ ...persistableContext });
+            const restoredContext = await this.compressionService.decompress(frozenPersistable);
+            const endTime = process.hrtime.bigint();
+            const operationTime = Number(endTime - startTime) / 1000000;
+            this.metrics.totalOperations++;
+            this.metrics.lastOperationTime = operationTime;
+            return Object.freeze({ ...restoredContext });
+        }
+        catch (error) {
+            console.warn('Context restoration failed, attempting graceful fallback:', error);
+            const fallbackContext = {
+                restorationError: true,
+                originalError: error instanceof Error ? error.message : 'Unknown error',
+                fallbackData: persistableContext
+            };
+            return Object.freeze(fallbackContext);
+        }
+    }
+    createFallbackClassification(context) {
+        const safeContext = { ...context };
+        return Object.freeze({
+            [context_types_1.ContextLayer.CRITICAL]: {},
+            [context_types_1.ContextLayer.IMPORTANT]: Object.freeze(safeContext),
+            [context_types_1.ContextLayer.USEFUL]: {},
+            [context_types_1.ContextLayer.EPHEMERAL]: {}
+        });
+    }
+    async createUncompressedBlob(classified) {
+        const flattened = {};
+        for (const [layer, data] of Object.entries(classified)) {
+            Object.assign(flattened, data);
+        }
+        const serialized = JSON.stringify(flattened);
+        const data = Buffer.from(serialized, 'utf8');
+        const size = data.length;
+        return {
+            data,
+            originalSize: size,
+            compressedSize: size,
+            compressionRatio: 1.0,
+            algorithm: 'none'
+        };
+    }
+    generateFallbackSessionId(workflowId) {
+        const timestamp = Date.now().toString(36);
+        const randomSuffix = Math.random().toString(36).substring(2, 8);
+        const fallbackId = `${workflowId}-${timestamp}-${randomSuffix}`;
+        return fallbackId.substring(0, SESSION_ID_CONFIG.maxLength);
+    }
+    updateClassificationMetrics(classificationTime) {
+        const prevOps = this.metrics.totalOperations;
+        this.metrics.totalOperations += 1;
+        this.metrics.averageClassificationTime =
+            (this.metrics.averageClassificationTime * prevOps + classificationTime) / this.metrics.totalOperations;
+        this.metrics.lastOperationTime = Date.now();
+    }
+    updateCompressionMetrics(compressionTime) {
+        const prevOps = this.metrics.totalOperations || 1;
+        this.metrics.averageCompressionTime =
+            (this.metrics.averageCompressionTime * (prevOps - 1) + compressionTime) / prevOps;
+    }
+    updatePipelineMetrics(totalTime) {
+        const prevOps = this.metrics.totalOperations || 1;
+        this.metrics.averageTotalTime =
+            (this.metrics.averageTotalTime * (prevOps - 1) + totalTime) / prevOps;
+    }
+}
+exports.ContextPersistenceService = ContextPersistenceService;

package/dist/cli/migrate-workflow.js

@@ -11,6 +11,7 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const validation_1 = require("../application/validation");
 const chalk_1 = __importDefault(require("chalk"));
+const semver_1 = __importDefault(require("semver"));
 function detectWorkflowVersion(workflow) {
     if (workflow.version) {
         return workflow.version;
@@ -29,13 +30,13 @@ function migrateWorkflow(workflow) {
         warnings: [],
         errors: []
     };
-    if (result.originalVersion === result.targetVersion) {
+    if (semver_1.default.eq(result.originalVersion, result.targetVersion)) {
         result.success = true;
         result.warnings.push(`Workflow is already at version ${result.targetVersion}`);
         result.migratedWorkflow = workflow;
         return result;
     }
-    if (result.originalVersion > result.targetVersion) {
+    if (semver_1.default.gt(result.originalVersion, result.targetVersion)) {
         result.errors.push(`Cannot downgrade from version ${result.originalVersion} to ${result.targetVersion}`);
         return result;
     }