@exaudeus/workrail 0.8.6 → 0.9.0

package/dist/application/services/compression-service.js

@@ -1,312 +0,0 @@
-"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.CompressionService = void 0;
-const zlib = __importStar(require("zlib"));
-const util_1 = require("util");
-const context_types_1 = require("../../types/context-types");
-const gzip = (0, util_1.promisify)(zlib.gzip);
-const gunzip = (0, util_1.promisify)(zlib.gunzip);
-const deflate = (0, util_1.promisify)(zlib.deflate);
-const inflate = (0, util_1.promisify)(zlib.inflate);
-const LAYER_COMPRESSION_SETTINGS = {
-    [context_types_1.ContextLayer.CRITICAL]: {
-        enabled: false,
-        aggressiveness: 'none',
-        level: 0
-    },
-    [context_types_1.ContextLayer.IMPORTANT]: {
-        enabled: true,
-        aggressiveness: 'light',
-        level: 3
-    },
-    [context_types_1.ContextLayer.USEFUL]: {
-        enabled: true,
-        aggressiveness: 'medium',
-        level: 6
-    },
-    [context_types_1.ContextLayer.EPHEMERAL]: {
-        enabled: true,
-        aggressiveness: 'aggressive',
-        level: 9
-    }
-};
-const DEFAULT_COMPRESSION_CONFIG = {
-    enabled: true,
-    algorithm: 'gzip',
-    level: 6,
-    layerSettings: LAYER_COMPRESSION_SETTINGS
-};
-class CompressionService {
-    constructor(config = {}) {
-        this.config = { ...DEFAULT_COMPRESSION_CONFIG, ...config };
-        this.stats = {
-            totalOperations: 0,
-            averageRatio: 1.0,
-            totalSizeReduction: 0,
-            averageCompressionTime: 0
-        };
-    }
-    async compress(classified) {
-        const startTime = process.hrtime.bigint();
-        try {
-            const compressedLayers = {};
-            let totalOriginalSize = 0;
-            let totalCompressedSize = 0;
-            for (const [layerName, layerData] of Object.entries(classified)) {
-                const layer = layerName;
-                const layerConfig = this.config.layerSettings[layer];
-                if (!layerConfig.enabled || !this.config.enabled) {
-                    const safeData = layerData || {};
-                    compressedLayers[layer] = safeData;
-                    const serialized = JSON.stringify(safeData);
-                    totalOriginalSize += Buffer.byteLength(serialized, 'utf8');
-                    totalCompressedSize += Buffer.byteLength(serialized, 'utf8');
-                    continue;
-                }
-                const result = await this.compressLayer(layerData, layer, layerConfig.aggressiveness);
-                compressedLayers[layer] = result.data;
-                totalOriginalSize += result.originalSize;
-                totalCompressedSize += result.compressedSize;
-            }
-            const serializedData = JSON.stringify(compressedLayers);
-            let finalCompressedBuffer;
-            if (this.config.enabled) {
-                finalCompressedBuffer = await this.applyAlgorithmCompression(Buffer.from(serializedData, 'utf8'), this.config.level);
-            }
-            else {
-                finalCompressedBuffer = Buffer.from(serializedData, 'utf8');
-            }
-            const finalOriginalSize = Buffer.byteLength(serializedData, 'utf8');
-            const finalCompressedSize = finalCompressedBuffer.length;
-            if (!this.config.enabled) {
-                return {
-                    data: finalCompressedBuffer,
-                    originalSize: finalCompressedSize,
-                    compressedSize: finalCompressedSize,
-                    compressionRatio: 1.0,
-                    algorithm: 'none'
-                };
-            }
-            const compressionRatio = totalOriginalSize > 0 ? totalOriginalSize / finalCompressedSize : 1.0;
-            const endTime = process.hrtime.bigint();
-            const compressionTimeMs = Number(endTime - startTime) / 1000000;
-            this.updateStats(compressionRatio, totalOriginalSize - finalCompressedSize, compressionTimeMs);
-            return {
-                data: finalCompressedBuffer,
-                originalSize: totalOriginalSize,
-                compressedSize: finalCompressedSize,
-                compressionRatio,
-                algorithm: this.config.enabled ? this.config.algorithm : 'none'
-            };
-        }
-        catch (error) {
-            console.warn('Compression failed, falling back to uncompressed data:', error);
-            return this.createUncompressedBlob(classified);
-        }
-    }
-    async decompress(blob) {
-        try {
-            if (blob.algorithm === 'none') {
-                return JSON.parse(blob.data.toString('utf8'));
-            }
-            const decompressedBuffer = await this.applyAlgorithmDecompression(blob.data);
-            const decompressedData = JSON.parse(decompressedBuffer.toString('utf8'));
-            const rawContext = {};
-            for (const [layerName, layerData] of Object.entries(decompressedData)) {
-                const layer = layerName;
-                const layerConfig = this.config.layerSettings[layer];
-                if (!layerConfig.enabled) {
-                    Object.assign(rawContext, layerData);
-                }
-                else {
-                    const decompressedLayerData = await this.decompressLayer(layerData, layer);
-                    Object.assign(rawContext, decompressedLayerData);
-                }
-            }
-            return Object.freeze(rawContext);
-        }
-        catch (error) {
-            throw new Error(`Decompression failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    getStats() {
-        return { ...this.stats };
-    }
-    resetStats() {
-        this.stats = {
-            totalOperations: 0,
-            averageRatio: 1.0,
-            totalSizeReduction: 0,
-            averageCompressionTime: 0
-        };
-    }
-    updateConfig(newConfig) {
-        this.config = { ...this.config, ...newConfig };
-    }
-    async compressLayer(layerData, layer, aggressiveness) {
-        const safeLayerData = layerData || {};
-        const serialized = JSON.stringify(safeLayerData);
-        const originalSize = Buffer.byteLength(serialized, 'utf8');
-        if (aggressiveness === 'none') {
-            return {
-                data: safeLayerData,
-                originalSize,
-                compressedSize: originalSize
-            };
-        }
-        let processedData = safeLayerData;
-        switch (aggressiveness) {
-            case 'light':
-                processedData = this.applyLightCompression(layerData);
-                break;
-            case 'medium':
-                processedData = this.applyMediumCompression(layerData);
-                break;
-            case 'aggressive':
-                processedData = this.applyAggressiveCompression(layerData);
-                break;
-        }
-        const processedSerialized = JSON.stringify(processedData);
-        const compressedSize = Buffer.byteLength(processedSerialized, 'utf8');
-        return {
-            data: processedData,
-            originalSize,
-            compressedSize
-        };
-    }
-    async decompressLayer(layerData, layer) {
-        return layerData;
-    }
-    applyLightCompression(data) {
-        const compressed = {};
-        for (const [key, value] of Object.entries(data)) {
-            if (typeof value === 'string') {
-                compressed[key] = value.replace(/\s+/g, ' ').trim();
-            }
-            else {
-                compressed[key] = value;
-            }
-        }
-        return compressed;
-    }
-    applyMediumCompression(data) {
-        const compressed = {};
-        for (const [key, value] of Object.entries(data)) {
-            if (typeof value === 'string') {
-                let processedValue = value.replace(/\s+/g, ' ').trim();
-                if (processedValue.length > 1000) {
-                    processedValue = processedValue.substring(0, 950) + '...[truncated]';
-                }
-                compressed[key] = processedValue;
-            }
-            else if (Array.isArray(value) && value.length > 50) {
-                compressed[key] = [...value.slice(0, 50), '...[truncated]'];
-            }
-            else {
-                compressed[key] = value;
-            }
-        }
-        return compressed;
-    }
-    applyAggressiveCompression(data) {
-        const compressed = {};
-        for (const [key, value] of Object.entries(data)) {
-            if (key.includes('debug') || key.includes('temp') || key.includes('timestamp')) {
-                continue;
-            }
-            if (typeof value === 'string') {
-                let processedValue = value.replace(/\s+/g, ' ').trim();
-                if (processedValue.length > 200) {
-                    processedValue = processedValue.substring(0, 100) +
-                        '...[compressed]...' +
-                        processedValue.substring(processedValue.length - 50);
-                }
-                compressed[key] = processedValue;
-            }
-            else if (Array.isArray(value) && value.length > 10) {
-                compressed[key] = [...value.slice(0, 5), '...[compressed]', ...value.slice(-2)];
-            }
-            else if (typeof value === 'object' && value !== null) {
-                compressed[key] = this.applyAggressiveCompression(value);
-            }
-            else {
-                compressed[key] = value;
-            }
-        }
-        return compressed;
-    }
-    async applyAlgorithmCompression(data, level) {
-        const options = { level };
-        switch (this.config.algorithm) {
-            case 'gzip':
-                return await gzip(data, options);
-            case 'deflate':
-                return await deflate(data, options);
-            default:
-                throw new Error(`Unsupported compression algorithm: ${this.config.algorithm}`);
-        }
-    }
-    async applyAlgorithmDecompression(data) {
-        switch (this.config.algorithm) {
-            case 'gzip':
-                return await gunzip(data);
-            case 'deflate':
-                return await inflate(data);
-            default:
-                throw new Error(`Unsupported compression algorithm: ${this.config.algorithm}`);
-        }
-    }
-    createUncompressedBlob(classified) {
-        const serialized = JSON.stringify(classified);
-        const data = Buffer.from(serialized, 'utf8');
-        const size = data.length;
-        return {
-            data,
-            originalSize: size,
-            compressedSize: size,
-            compressionRatio: 1.0,
-            algorithm: 'none'
-        };
-    }
-    updateStats(ratio, sizeReduction, timeMs) {
-        const prevOps = this.stats.totalOperations;
-        this.stats.totalOperations += 1;
-        this.stats.averageRatio = (this.stats.averageRatio * prevOps + ratio) / this.stats.totalOperations;
-        this.stats.totalSizeReduction += sizeReduction;
-        this.stats.averageCompressionTime = (this.stats.averageCompressionTime * prevOps + timeMs) / this.stats.totalOperations;
-    }
-}
-exports.CompressionService = CompressionService;

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

@@ -1,38 +0,0 @@
-import { IContextManagementService, IContextPersistenceService, SaveCheckpointParams, SaveCheckpointResult, LoadCheckpointParams, LoadCheckpointResult, ListCheckpointsParams, CheckpointMetadata, MarkCriticalParams, MarkCriticalResult } from '../../types/context-types';
-import { IContextStorage } from '../../infrastructure/storage/context-storage';
-interface ContextManagementMetrics {
-    totalSaveOperations: number;
-    totalLoadOperations: number;
-    totalListOperations: number;
-    totalMarkCriticalOperations: number;
-    averageSaveTime: number;
-    averageLoadTime: number;
-    lastOperationTime: number;
-    errorCount: number;
-}
-export declare class ContextManagementService implements IContextManagementService {
-    private readonly persistenceService;
-    private readonly storage;
-    private metrics;
-    constructor(persistenceService: IContextPersistenceService, storage: IContextStorage);
-    saveCheckpoint(params: SaveCheckpointParams): Promise<SaveCheckpointResult>;
-    loadCheckpoint(params: LoadCheckpointParams): Promise<LoadCheckpointResult>;
-    listCheckpoints(params: ListCheckpointsParams): Promise<CheckpointMetadata[]>;
-    markCritical(params: MarkCriticalParams): Promise<MarkCriticalResult>;
-    getMetrics(): ContextManagementMetrics;
-    resetMetrics(): void;
-    private generateSessionId;
-    private generateCheckpointId;
-    private isContextUnchanged;
-    private getLastCheckpointId;
-    private countLayers;
-    private upsertSessionInfo;
-    private updateSaveMetrics;
-    private updateLoadMetrics;
-    private updateListMetrics;
-    private updateMarkCriticalMetrics;
-    private calculateMovingAverage;
-    private hashContext;
-    private getLastCheckpointData;
-}
-export {};

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

@@ -1,301 +0,0 @@
-"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-optimizer.d.ts

@@ -1,11 +0,0 @@
-import { EnhancedContext } from '../../types/workflow-types';
-type ConditionContext = Record<string, any>;
-export declare class ContextOptimizer {
-    static createEnhancedContext(base: ConditionContext, enhancements: Partial<EnhancedContext>): EnhancedContext;
-    static mergeLoopState(context: EnhancedContext, loopId: string, loopState: any): EnhancedContext;
-    static addWarnings(context: EnhancedContext, category: string, key: string, warnings: string[]): EnhancedContext;
-    static hasProperty(context: ConditionContext, property: string): boolean;
-    static getProperty(context: ConditionContext, property: string): any;
-    static getOwnPropertiesSize(context: ConditionContext): number;
-}
-export {};