@exaudeus/workrail 0.1.0 → 0.1.2

package/dist/application/services/classification-engine.js

@@ -0,0 +1,258 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClassificationEngine = void 0;
+const context_types_1 = require("../../types/context-types");
+class ClassificationEngine {
+    constructor(initialRules) {
+        this.overrides = new Map();
+        this.rules = initialRules || this.getDefaultRules();
+        this.stats = {
+            totalClassifications: 0,
+            layerDistribution: {
+                [context_types_1.ContextLayer.CRITICAL]: 0,
+                [context_types_1.ContextLayer.IMPORTANT]: 0,
+                [context_types_1.ContextLayer.USEFUL]: 0,
+                [context_types_1.ContextLayer.EPHEMERAL]: 0
+            },
+            overrideCount: 0,
+            averageProcessingTime: 0
+        };
+    }
+    async classify(context, rules) {
+        const startTime = process.hrtime.bigint();
+        const activeRules = rules || this.rules;
+        const classified = {
+            [context_types_1.ContextLayer.CRITICAL]: {},
+            [context_types_1.ContextLayer.IMPORTANT]: {},
+            [context_types_1.ContextLayer.USEFUL]: {},
+            [context_types_1.ContextLayer.EPHEMERAL]: {}
+        };
+        for (const [key, value] of Object.entries(context)) {
+            const layer = this.classifyKeyValue(key, value, activeRules);
+            classified[layer][key] = value;
+        }
+        this.updateStats(startTime, classified);
+        return Object.freeze(classified);
+    }
+    async loadRules(config) {
+        if (config) {
+            this.rules = {
+                patterns: { ...this.rules.patterns, ...config.patterns },
+                heuristics: { ...this.rules.heuristics, ...config.heuristics },
+                overrides: { ...this.rules.overrides, ...config.overrides }
+            };
+        }
+    }
+    addOverride(sessionId, contextKey, layer) {
+        if (!this.overrides.has(sessionId)) {
+            this.overrides.set(sessionId, new Map());
+        }
+        const sessionOverrides = this.overrides.get(sessionId);
+        sessionOverrides.set(contextKey, layer);
+        this.stats.overrideCount++;
+    }
+    removeOverride(sessionId, contextKey) {
+        const sessionOverrides = this.overrides.get(sessionId);
+        if (sessionOverrides && sessionOverrides.has(contextKey)) {
+            sessionOverrides.delete(contextKey);
+            this.stats.overrideCount = Math.max(0, this.stats.overrideCount - 1);
+            if (sessionOverrides.size === 0) {
+                this.overrides.delete(sessionId);
+            }
+        }
+    }
+    async markCritical(sessionId, contextKey) {
+        this.addOverride(sessionId, contextKey, context_types_1.ContextLayer.CRITICAL);
+        console.log(`✓ Marked key '${contextKey}' as CRITICAL for session '${sessionId}'`);
+    }
+    getStats() {
+        return { ...this.stats };
+    }
+    classifyKeyValue(key, value, rules, sessionId) {
+        if (sessionId) {
+            const sessionOverrides = this.overrides.get(sessionId);
+            const override = sessionOverrides?.get(key);
+            if (override) {
+                return override;
+            }
+        }
+        if (rules.overrides[key]) {
+            return rules.overrides[key];
+        }
+        const patternLayer = this.applyPatternMatching(key, value, rules);
+        if (patternLayer) {
+            return patternLayer;
+        }
+        return this.applyHeuristics(key, value, rules);
+    }
+    applyPatternMatching(key, value, rules) {
+        let bestMatch = null;
+        for (const [layer, patterns] of Object.entries(rules.patterns)) {
+            for (const pattern of patterns) {
+                if (this.matchesPattern(key, value, pattern)) {
+                    if (!bestMatch || pattern.weight > bestMatch.weight) {
+                        bestMatch = { layer: layer, weight: pattern.weight };
+                    }
+                }
+            }
+        }
+        return bestMatch?.layer || null;
+    }
+    matchesPattern(key, value, pattern) {
+        const keyRegex = new RegExp(pattern.keyPattern, 'i');
+        if (!keyRegex.test(key)) {
+            return false;
+        }
+        if (pattern.valuePattern) {
+            const valueStr = typeof value === 'string' ? value : JSON.stringify(value);
+            const valueRegex = new RegExp(pattern.valuePattern, 'i');
+            if (!valueRegex.test(valueStr)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    applyHeuristics(key, value, rules) {
+        const heuristics = rules.heuristics;
+        const valueStr = typeof value === 'string' ? value :
+            value === undefined ? 'undefined' :
+                value === null ? 'null' :
+                    JSON.stringify(value);
+        const contentLength = valueStr.length;
+        let keywordScore = 0;
+        for (const [keyword, weight] of Object.entries(heuristics.keywordWeights)) {
+            const regex = new RegExp(keyword, 'gi');
+            const matches = (key + ' ' + valueStr).match(regex);
+            if (matches) {
+                keywordScore += matches.length * weight;
+            }
+        }
+        if (keywordScore >= 10 || contentLength >= heuristics.lengthThresholds[context_types_1.ContextLayer.CRITICAL]) {
+            return context_types_1.ContextLayer.CRITICAL;
+        }
+        else if (keywordScore >= 5 || contentLength >= heuristics.lengthThresholds[context_types_1.ContextLayer.IMPORTANT]) {
+            return context_types_1.ContextLayer.IMPORTANT;
+        }
+        else if (contentLength >= heuristics.lengthThresholds[context_types_1.ContextLayer.USEFUL]) {
+            return context_types_1.ContextLayer.USEFUL;
+        }
+        else {
+            return heuristics.defaultLayer;
+        }
+    }
+    updateStats(startTime, classified) {
+        const endTime = process.hrtime.bigint();
+        const processingTime = Number(endTime - startTime) / 1000000;
+        this.stats.totalClassifications++;
+        this.stats.averageProcessingTime =
+            (this.stats.averageProcessingTime * (this.stats.totalClassifications - 1) + processingTime) /
+                this.stats.totalClassifications;
+        for (const [layer, content] of Object.entries(classified)) {
+            const itemCount = Object.keys(content).length;
+            this.stats.layerDistribution[layer] += itemCount;
+        }
+    }
+    getDefaultRules() {
+        return {
+            patterns: {
+                [context_types_1.ContextLayer.CRITICAL]: [
+                    {
+                        keyPattern: '^(goal|objective|target|requirement|result|answer|decision|conclusion)s?$',
+                        weight: 100,
+                        description: 'Core workflow objectives and final results'
+                    },
+                    {
+                        keyPattern: '^(user|customer|client).*',
+                        weight: 90,
+                        description: 'User-related information and requirements'
+                    },
+                    {
+                        keyPattern: '^(error|failure|critical|urgent|important).*',
+                        weight: 85,
+                        description: 'Critical errors and urgent items'
+                    }
+                ],
+                [context_types_1.ContextLayer.IMPORTANT]: [
+                    {
+                        keyPattern: '^(plan|strategy|approach|method|process|workflow)s?$',
+                        weight: 80,
+                        description: 'Planning and strategic information'
+                    },
+                    {
+                        keyPattern: '^(config|settings|parameters).*',
+                        weight: 70,
+                        description: 'Configuration and settings'
+                    },
+                    {
+                        keyPattern: '^(state|status|progress).*',
+                        weight: 65,
+                        description: 'Current state and progress tracking'
+                    }
+                ],
+                [context_types_1.ContextLayer.USEFUL]: [
+                    {
+                        keyPattern: '^(data|content|information|details).*',
+                        weight: 50,
+                        description: 'Supporting data and detailed information'
+                    },
+                    {
+                        keyPattern: '^(example|sample|demo)s?.*',
+                        weight: 45,
+                        description: 'Examples and demonstrations'
+                    },
+                    {
+                        keyPattern: '^(analysis|report|summary).*',
+                        weight: 40,
+                        description: 'Analysis results and reports'
+                    }
+                ],
+                [context_types_1.ContextLayer.EPHEMERAL]: [
+                    {
+                        keyPattern: '^(temp|temporary|cache|buffer).*',
+                        weight: 20,
+                        description: 'Temporary data and cache'
+                    },
+                    {
+                        keyPattern: '.*(debug|log|trace|timestamp).*',
+                        weight: 15,
+                        description: 'Debug information and logs'
+                    },
+                    {
+                        keyPattern: '^(_|internal).*',
+                        weight: 10,
+                        description: 'Internal system metadata'
+                    }
+                ]
+            },
+            heuristics: {
+                lengthThresholds: {
+                    [context_types_1.ContextLayer.CRITICAL]: 1000,
+                    [context_types_1.ContextLayer.IMPORTANT]: 500,
+                    [context_types_1.ContextLayer.USEFUL]: 100,
+                    [context_types_1.ContextLayer.EPHEMERAL]: 0
+                },
+                keywordWeights: {
+                    'goal': 15,
+                    'objective': 15,
+                    'requirement': 12,
+                    'critical': 10,
+                    'important': 8,
+                    'urgent': 8,
+                    'user': 7,
+                    'error': 7,
+                    'failure': 7,
+                    'plan': 6,
+                    'strategy': 6,
+                    'config': 5,
+                    'data': 3,
+                    'example': 2,
+                    'debug': 1,
+                    'temp': 1
+                },
+                defaultLayer: context_types_1.ContextLayer.USEFUL
+            },
+            overrides: {}
+        };
+    }
+}
+exports.ClassificationEngine = ClassificationEngine;

package/dist/application/services/compression-service.d.ts

@@ -0,0 +1,20 @@
+import { ICompressionService, ClassifiedContext, CompressedBlob, RawContext, CompressionConfig, CompressionStats } from '../../types/context-types';
+export declare class CompressionService implements ICompressionService {
+    private config;
+    private stats;
+    constructor(config?: Partial<CompressionConfig>);
+    compress(classified: ClassifiedContext): Promise<CompressedBlob>;
+    decompress(blob: CompressedBlob): Promise<RawContext>;
+    getStats(): CompressionStats;
+    resetStats(): void;
+    updateConfig(newConfig: Partial<CompressionConfig>): void;
+    private compressLayer;
+    private decompressLayer;
+    private applyLightCompression;
+    private applyMediumCompression;
+    private applyAggressiveCompression;
+    private applyAlgorithmCompression;
+    private applyAlgorithmDecompression;
+    private createUncompressedBlob;
+    private updateStats;
+}

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

@@ -0,0 +1,312 @@
+"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

@@ -0,0 +1,38 @@
+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 {};