@codebolt/agent 2.2.2 → 2.2.5

package/dist/processor-pieces/additionalModifiers/fallbackHandlerModifier.js

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FallbackHandlerModifier = exports.FallbackStrategy = void 0;
+const base_1 = require("../base");
+var FallbackStrategy;
+(function (FallbackStrategy) {
+    FallbackStrategy["RETRY_WITH_SIMPLIFIED_CONTEXT"] = "retry_simplified";
+    FallbackStrategy["RETRY_WITHOUT_TOOLS"] = "retry_no_tools";
+    FallbackStrategy["RETRY_WITH_SHORTER_HISTORY"] = "retry_short_history";
+    FallbackStrategy["USE_FALLBACK_MODEL"] = "fallback_model";
+    FallbackStrategy["PROVIDE_ERROR_CONTEXT"] = "error_context";
+})(FallbackStrategy || (exports.FallbackStrategy = FallbackStrategy = {}));
+class FallbackHandlerModifier extends base_1.BaseMessageModifier {
+    constructor(options = {}) {
+        super();
+        this.fallbackContexts = new Map();
+        this.options = {
+            enableFallback: options.enableFallback !== false,
+            maxRetries: options.maxRetries || 3,
+            fallbackStrategies: options.fallbackStrategies || [
+                FallbackStrategy.RETRY_WITH_SIMPLIFIED_CONTEXT,
+                FallbackStrategy.RETRY_WITHOUT_TOOLS,
+                FallbackStrategy.RETRY_WITH_SHORTER_HISTORY
+            ],
+            timeoutMs: options.timeoutMs || 30000
+        };
+    }
+    async modify(originalRequest, createdMessage) {
+        try {
+            if (!this.options.enableFallback) {
+                return createdMessage;
+            }
+            // Check if this is a retry attempt
+            const messageId = this.generateMessageId(originalRequest);
+            const fallbackContext = this.fallbackContexts.get(messageId);
+            if (fallbackContext && fallbackContext.attemptCount >= this.options.maxRetries) {
+                // Max retries reached, add error context and return
+                return this.addErrorContextMessage(createdMessage, fallbackContext);
+            }
+            // Check if we need to apply fallback strategies
+            const shouldApplyFallback = this.shouldApplyFallback(createdMessage, fallbackContext);
+            if (!shouldApplyFallback) {
+                return createdMessage;
+            }
+            // Apply the next fallback strategy
+            const modifiedMessage = await this.applyFallbackStrategy(createdMessage, fallbackContext || this.initializeFallbackContext(originalRequest));
+            // Update fallback context
+            this.updateFallbackContext(messageId, modifiedMessage);
+            return modifiedMessage;
+        }
+        catch (error) {
+            console.error('Error in FallbackHandlerModifier:', error);
+            return createdMessage;
+        }
+    }
+    generateMessageId(request) {
+        // Generate a unique ID for this message request
+        const content = request.userMessage || '';
+        return Buffer.from(content).toString('base64').substring(0, 16);
+    }
+    shouldApplyFallback(message, context) {
+        var _a, _b, _c;
+        // Check metadata for error indicators
+        const hasError = !!(((_a = message.metadata) === null || _a === void 0 ? void 0 : _a.hasError) || ((_b = message.metadata) === null || _b === void 0 ? void 0 : _b.lastError));
+        const isRetry = !!((_c = message.metadata) === null || _c === void 0 ? void 0 : _c.isRetry) || ((context === null || context === void 0 ? void 0 : context.attemptCount) || 0) > 0;
+        return hasError || isRetry;
+    }
+    initializeFallbackContext(originalRequest) {
+        const content = originalRequest.userMessage || '';
+        return {
+            attemptCount: 0,
+            originalMessageLength: content.length,
+            fallbacksAttempted: []
+        };
+    }
+    async applyFallbackStrategy(message, context) {
+        const nextStrategy = this.getNextFallbackStrategy(context);
+        if (!nextStrategy) {
+            return message;
+        }
+        context.fallbacksAttempted.push(nextStrategy);
+        switch (nextStrategy) {
+            case FallbackStrategy.RETRY_WITH_SIMPLIFIED_CONTEXT:
+                return this.simplifyContext(message);
+            case FallbackStrategy.RETRY_WITHOUT_TOOLS:
+                return this.removeTools(message);
+            case FallbackStrategy.RETRY_WITH_SHORTER_HISTORY:
+                return this.shortenHistory(message);
+            case FallbackStrategy.USE_FALLBACK_MODEL:
+                return this.setFallbackModel(message);
+            case FallbackStrategy.PROVIDE_ERROR_CONTEXT:
+                return this.addErrorContextMessage(message, context);
+            default:
+                return message;
+        }
+    }
+    getNextFallbackStrategy(context) {
+        const availableStrategies = this.options.fallbackStrategies.filter(strategy => !context.fallbacksAttempted.includes(strategy));
+        return availableStrategies.length > 0 ? availableStrategies[0] : null;
+    }
+    simplifyContext(message) {
+        // Remove or simplify complex context messages
+        const simplifiedMessages = message.message.messages.map(msg => {
+            if (msg.role === 'system' && typeof msg.content === 'string' && msg.content.length > 500) {
+                return {
+                    ...msg,
+                    content: msg.content.substring(0, 500) + '...[context simplified for fallback]'
+                };
+            }
+            return msg;
+        });
+        return {
+            ...message,
+            message: {
+                ...message.message,
+                messages: simplifiedMessages
+            },
+            metadata: {
+                ...message.metadata,
+                fallbackApplied: 'simplified_context',
+                isRetry: true
+            }
+        };
+    }
+    removeTools(message) {
+        return {
+            ...message,
+            metadata: {
+                ...message.metadata,
+                fallbackApplied: 'no_tools',
+                toolsDisabled: true,
+                isRetry: true
+            }
+        };
+    }
+    shortenHistory(message) {
+        // Keep only the last few messages
+        const messages = message.message.messages;
+        const systemMessages = messages.filter(msg => msg.role === 'system');
+        const otherMessages = messages.filter(msg => msg.role !== 'system');
+        const recentMessages = otherMessages.slice(-3); // Keep last 3 non-system messages
+        return {
+            ...message,
+            message: {
+                ...message.message,
+                messages: [...systemMessages, ...recentMessages]
+            },
+            metadata: {
+                ...message.metadata,
+                fallbackApplied: 'shortened_history',
+                originalMessageCount: messages.length,
+                isRetry: true
+            }
+        };
+    }
+    setFallbackModel(message) {
+        return {
+            ...message,
+            metadata: {
+                ...message.metadata,
+                fallbackApplied: 'fallback_model',
+                useFallbackModel: true,
+                isRetry: true
+            }
+        };
+    }
+    addErrorContextMessage(message, context) {
+        const errorMessage = {
+            role: 'system',
+            content: `Note: This request has been attempted ${context.attemptCount} times with fallback strategies: ${context.fallbacksAttempted.join(', ')}. Please provide a simpler response if the request seems too complex.`
+        };
+        return {
+            ...message,
+            message: {
+                ...message.message,
+                messages: [errorMessage, ...message.message.messages]
+            },
+            metadata: {
+                ...message.metadata,
+                fallbackApplied: 'error_context',
+                fallbackExhausted: true,
+                isRetry: true
+            }
+        };
+    }
+    updateFallbackContext(messageId, message) {
+        const existingContext = this.fallbackContexts.get(messageId);
+        if (existingContext) {
+            existingContext.attemptCount++;
+        }
+        else {
+            this.fallbackContexts.set(messageId, {
+                attemptCount: 1,
+                originalMessageLength: JSON.stringify(message.message).length,
+                fallbacksAttempted: []
+            });
+        }
+        // Clean up old contexts (prevent memory leaks)
+        if (this.fallbackContexts.size > 100) {
+            const entries = Array.from(this.fallbackContexts.entries());
+            const oldestKey = entries[0][0];
+            this.fallbackContexts.delete(oldestKey);
+        }
+    }
+    clearFallbackContext(messageId) {
+        this.fallbackContexts.delete(messageId);
+    }
+    getFallbackStats() {
+        const contexts = Array.from(this.fallbackContexts.values());
+        const totalAttempts = contexts.reduce((sum, ctx) => sum + ctx.attemptCount, 0);
+        return {
+            totalContexts: contexts.length,
+            averageAttempts: contexts.length > 0 ? totalAttempts / contexts.length : 0
+        };
+    }
+}
+exports.FallbackHandlerModifier = FallbackHandlerModifier;

package/dist/processor-pieces/additionalModifiers/ideContextModifier.d.ts

@@ -0,0 +1,34 @@
+import { ProcessedMessage } from "@codebolt/types/agent";
+import { BaseMessageModifier } from "../base";
+import { FlatUserMessage } from "@codebolt/types/sdk";
+export interface IdeContextOptions {
+    includeOpenFiles?: boolean;
+    includeActiveFile?: boolean;
+    includeCursorPosition?: boolean;
+    includeSelectedText?: boolean;
+    maxOpenFiles?: number;
+}
+export interface FileInfo {
+    path: string;
+    isActive?: boolean;
+    cursor?: {
+        line: number;
+        character: number;
+    };
+    selectedText?: string;
+}
+export interface IdeContext {
+    workspaceState?: {
+        openFiles: FileInfo[];
+    };
+}
+export declare class IdeContextModifier extends BaseMessageModifier {
+    private readonly options;
+    private lastSentIdeContext?;
+    private forceFullContext;
+    constructor(options?: IdeContextOptions);
+    modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
+    private getIdeContext;
+    private getIdeContextParts;
+    setForceFullContext(force: boolean): void;
+}

package/dist/processor-pieces/additionalModifiers/ideContextModifier.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdeContextModifier = void 0;
+const base_1 = require("../base");
+class IdeContextModifier extends base_1.BaseMessageModifier {
+    constructor(options = {}) {
+        super();
+        this.forceFullContext = true;
+        this.options = {
+            includeOpenFiles: options.includeOpenFiles !== false,
+            includeActiveFile: options.includeActiveFile !== false,
+            includeCursorPosition: options.includeCursorPosition !== false,
+            includeSelectedText: options.includeSelectedText !== false,
+            maxOpenFiles: options.maxOpenFiles || 10
+        };
+    }
+    modify(originalRequest, createdMessage) {
+        try {
+            // In a real implementation, this would get IDE context from a service
+            // For now, we'll create a mock context or try to get it from metadata
+            const ideContext = this.getIdeContext(createdMessage.metadata);
+            if (!ideContext) {
+                return Promise.resolve(createdMessage);
+            }
+            const { contextParts, newIdeContext } = this.getIdeContextParts(this.forceFullContext, ideContext);
+            if (contextParts.length === 0) {
+                return Promise.resolve(createdMessage);
+            }
+            const ideContextMessage = {
+                role: 'system',
+                content: contextParts.join('\n')
+            };
+            // Find existing system message or add new one
+            const messages = [...createdMessage.message.messages];
+            const systemMessageIndex = messages.findIndex(msg => msg.role === 'system');
+            if (systemMessageIndex !== -1) {
+                // Append to existing system message
+                messages[systemMessageIndex] = {
+                    ...messages[systemMessageIndex],
+                    content: `${messages[systemMessageIndex].content}\n\n${ideContextMessage.content}`
+                };
+            }
+            else {
+                // Add new system message
+                messages.unshift(ideContextMessage);
+            }
+            this.lastSentIdeContext = newIdeContext;
+            this.forceFullContext = false;
+            return Promise.resolve({
+                message: {
+                    ...createdMessage.message,
+                    messages
+                },
+                metadata: {
+                    ...createdMessage.metadata,
+                    ideContextAdded: true,
+                    ideContextType: this.forceFullContext ? 'full' : 'incremental'
+                }
+            });
+        }
+        catch (error) {
+            console.error('Error in IdeContextModifier:', error);
+            return Promise.resolve(createdMessage);
+        }
+    }
+    getIdeContext(metadata) {
+        // Try to get IDE context from the metadata parameter
+        if (metadata === null || metadata === void 0 ? void 0 : metadata.ideContext) {
+            return metadata.ideContext;
+        }
+        // Mock IDE context for demonstration
+        // In a real implementation, this would come from an IDE service
+        return {
+            workspaceState: {
+                openFiles: [
+                    {
+                        path: '/current/project/src/main.ts',
+                        isActive: true,
+                        cursor: { line: 42, character: 15 },
+                        selectedText: 'const result = '
+                    },
+                    {
+                        path: '/current/project/src/utils.ts',
+                        isActive: false
+                    },
+                    {
+                        path: '/current/project/README.md',
+                        isActive: false
+                    }
+                ]
+            }
+        };
+    }
+    getIdeContextParts(forceFullContext, currentIdeContext) {
+        var _a;
+        if (!((_a = currentIdeContext === null || currentIdeContext === void 0 ? void 0 : currentIdeContext.workspaceState) === null || _a === void 0 ? void 0 : _a.openFiles)) {
+            return { contextParts: [], newIdeContext: undefined };
+        }
+        if (forceFullContext || !this.lastSentIdeContext) {
+            // Send full context as JSON
+            const openFiles = currentIdeContext.workspaceState.openFiles;
+            const activeFile = openFiles.find((f) => f.isActive);
+            const otherOpenFiles = openFiles
+                .filter((f) => !f.isActive)
+                .map((f) => f.path)
+                .slice(0, this.options.maxOpenFiles - 1); // Reserve space for active file
+            const contextData = {};
+            if (activeFile && this.options.includeActiveFile) {
+                const activeFileData = {
+                    path: activeFile.path
+                };
+                if (this.options.includeCursorPosition && activeFile.cursor) {
+                    activeFileData.cursor = {
+                        line: activeFile.cursor.line,
+                        character: activeFile.cursor.character,
+                    };
+                }
+                if (this.options.includeSelectedText && activeFile.selectedText) {
+                    activeFileData.selectedText = activeFile.selectedText;
+                }
+                contextData['activeFile'] = activeFileData;
+            }
+            if (this.options.includeOpenFiles && otherOpenFiles.length > 0) {
+                contextData['otherOpenFiles'] = otherOpenFiles;
+            }
+            if (Object.keys(contextData).length === 0) {
+                return { contextParts: [], newIdeContext: currentIdeContext };
+            }
+            const jsonString = JSON.stringify(contextData, null, 2);
+            const contextParts = [
+                "Here is the user's editor context as a JSON object. This is for your information only.",
+                '```json',
+                jsonString,
+                '```',
+                "Don't acknowledge this context in your response unless specifically asked about it."
+            ];
+            return { contextParts, newIdeContext: currentIdeContext };
+        }
+        // For incremental updates, we would compare with lastSentIdeContext
+        // and only send changes. For now, we'll skip incremental updates.
+        return { contextParts: [], newIdeContext: currentIdeContext };
+    }
+    setForceFullContext(force) {
+        this.forceFullContext = force;
+    }
+}
+exports.IdeContextModifier = IdeContextModifier;

package/dist/processor-pieces/additionalModifiers/index.d.ts

@@ -0,0 +1,12 @@
+export { EnvironmentContextModifier, type EnvironmentContextOptions } from './environmentContextModifier';
+export { CoreSystemPromptModifier, type CoreSystemPromptOptions } from './coreSystemPromptModifier';
+export { DirectoryContextModifier, type DirectoryContextOptions } from './directoryContextModifier';
+export { IdeContextModifier, type IdeContextOptions, type FileInfo, type IdeContext } from './ideContextModifier';
+export { ChatCompressionModifier, type ChatCompressionOptions } from './chatCompressionModifier';
+export { AtFileProcessorModifier, type AtFileProcessorOptions } from './atFileProcessorModifier';
+export { ShellProcessorModifier, type ShellProcessorOptions } from './shellProcessorModifier';
+export { ArgumentProcessorModifier, type ArgumentProcessorOptions } from './argumentProcessorModifier';
+export { MemoryImportModifier, type MemoryImportOptions } from './memoryImportModifier';
+export { LoopDetectionModifier, type LoopDetectionOptions } from './loopDetectionModifier';
+export { ToolInjectionModifier, type ToolInjectionOptions } from './toolInjectionModifier';
+export { ChatRecordingModifier, type ChatRecordingOptions } from './chatRecordingModifier';

package/dist/processor-pieces/additionalModifiers/index.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatRecordingModifier = exports.ToolInjectionModifier = exports.LoopDetectionModifier = exports.MemoryImportModifier = exports.ArgumentProcessorModifier = exports.ShellProcessorModifier = exports.AtFileProcessorModifier = exports.ChatCompressionModifier = exports.IdeContextModifier = exports.DirectoryContextModifier = exports.CoreSystemPromptModifier = exports.EnvironmentContextModifier = void 0;
+// Gemini-CLI equivalent modifiers
+var environmentContextModifier_1 = require("./environmentContextModifier");
+Object.defineProperty(exports, "EnvironmentContextModifier", { enumerable: true, get: function () { return environmentContextModifier_1.EnvironmentContextModifier; } });
+var coreSystemPromptModifier_1 = require("./coreSystemPromptModifier");
+Object.defineProperty(exports, "CoreSystemPromptModifier", { enumerable: true, get: function () { return coreSystemPromptModifier_1.CoreSystemPromptModifier; } });
+var directoryContextModifier_1 = require("./directoryContextModifier");
+Object.defineProperty(exports, "DirectoryContextModifier", { enumerable: true, get: function () { return directoryContextModifier_1.DirectoryContextModifier; } });
+var ideContextModifier_1 = require("./ideContextModifier");
+Object.defineProperty(exports, "IdeContextModifier", { enumerable: true, get: function () { return ideContextModifier_1.IdeContextModifier; } });
+var chatCompressionModifier_1 = require("./chatCompressionModifier");
+Object.defineProperty(exports, "ChatCompressionModifier", { enumerable: true, get: function () { return chatCompressionModifier_1.ChatCompressionModifier; } });
+var atFileProcessorModifier_1 = require("./atFileProcessorModifier");
+Object.defineProperty(exports, "AtFileProcessorModifier", { enumerable: true, get: function () { return atFileProcessorModifier_1.AtFileProcessorModifier; } });
+var shellProcessorModifier_1 = require("./shellProcessorModifier");
+Object.defineProperty(exports, "ShellProcessorModifier", { enumerable: true, get: function () { return shellProcessorModifier_1.ShellProcessorModifier; } });
+var argumentProcessorModifier_1 = require("./argumentProcessorModifier");
+Object.defineProperty(exports, "ArgumentProcessorModifier", { enumerable: true, get: function () { return argumentProcessorModifier_1.ArgumentProcessorModifier; } });
+var memoryImportModifier_1 = require("./memoryImportModifier");
+Object.defineProperty(exports, "MemoryImportModifier", { enumerable: true, get: function () { return memoryImportModifier_1.MemoryImportModifier; } });
+var loopDetectionModifier_1 = require("./loopDetectionModifier");
+Object.defineProperty(exports, "LoopDetectionModifier", { enumerable: true, get: function () { return loopDetectionModifier_1.LoopDetectionModifier; } });
+var toolInjectionModifier_1 = require("./toolInjectionModifier");
+Object.defineProperty(exports, "ToolInjectionModifier", { enumerable: true, get: function () { return toolInjectionModifier_1.ToolInjectionModifier; } });
+var chatRecordingModifier_1 = require("./chatRecordingModifier");
+Object.defineProperty(exports, "ChatRecordingModifier", { enumerable: true, get: function () { return chatRecordingModifier_1.ChatRecordingModifier; } });

package/dist/processor-pieces/additionalModifiers/loopDetectionModifier.d.ts

@@ -0,0 +1,29 @@
+import { ProcessedMessage } from "@codebolt/types/agent";
+import { BaseMessageModifier } from "../base";
+import { FlatUserMessage } from "@codebolt/types/sdk";
+export interface LoopDetectionOptions {
+    maxSimilarMessages?: number;
+    similarityThreshold?: number;
+    timeWindowMs?: number;
+    enableLoopPrevention?: boolean;
+}
+interface MessageHistory {
+    content: string;
+    timestamp: number;
+    role: string;
+}
+export declare class LoopDetectionModifier extends BaseMessageModifier {
+    private readonly options;
+    private messageHistory;
+    private loopDetected;
+    constructor(options?: LoopDetectionOptions);
+    modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
+    private detectLoop;
+    private checkSimilarMessages;
+    private calculateSimilarity;
+    private levenshteinDistance;
+    private cleanOldMessages;
+    resetLoopDetection(): void;
+    getMessageHistory(): MessageHistory[];
+}
+export {};

package/dist/processor-pieces/additionalModifiers/loopDetectionModifier.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoopDetectionModifier = void 0;
+const base_1 = require("../base");
+class LoopDetectionModifier extends base_1.BaseMessageModifier {
+    constructor(options = {}) {
+        super();
+        this.messageHistory = [];
+        this.loopDetected = false;
+        this.options = {
+            maxSimilarMessages: options.maxSimilarMessages || 3,
+            similarityThreshold: options.similarityThreshold || 0.8,
+            timeWindowMs: options.timeWindowMs || 60000, // 1 minute
+            enableLoopPrevention: options.enableLoopPrevention !== false
+        };
+    }
+    modify(originalRequest, createdMessage) {
+        try {
+            if (!this.options.enableLoopPrevention) {
+                return Promise.resolve(createdMessage);
+            }
+            const currentTime = Date.now();
+            const messages = createdMessage.message.messages;
+            // Add current messages to history
+            for (const message of messages) {
+                if (typeof message.content === 'string') {
+                    this.messageHistory.push({
+                        content: message.content,
+                        timestamp: currentTime,
+                        role: message.role
+                    });
+                }
+            }
+            // Clean old messages from history
+            this.cleanOldMessages(currentTime);
+            // Check for loops
+            const loopDetected = this.detectLoop();
+            if (loopDetected && !this.loopDetected) {
+                this.loopDetected = true;
+                // Add loop detection warning
+                const warningMessage = {
+                    role: 'system',
+                    content: `[Loop Detection Warning] Similar messages detected in recent conversation. This may indicate a conversational loop. Consider rephrasing your request or providing more specific information.`
+                };
+                const updatedMessages = [...messages, warningMessage];
+                return Promise.resolve({
+                    message: {
+                        ...createdMessage.message,
+                        messages: updatedMessages
+                    },
+                    metadata: {
+                        ...createdMessage.metadata,
+                        loopDetected: true,
+                        loopDetectionWarningAdded: true
+                    }
+                });
+            }
+            // Reset loop detection if we haven't detected a loop recently
+            if (!loopDetected && this.loopDetected) {
+                this.loopDetected = false;
+            }
+            return Promise.resolve({
+                message: createdMessage.message,
+                metadata: {
+                    ...createdMessage.metadata,
+                    loopDetectionChecked: true,
+                    loopDetected: false
+                }
+            });
+        }
+        catch (error) {
+            console.error('Error in LoopDetectionModifier:', error);
+            return Promise.resolve(createdMessage);
+        }
+    }
+    detectLoop() {
+        if (this.messageHistory.length < this.options.maxSimilarMessages) {
+            return false;
+        }
+        // Get recent messages grouped by role
+        const recentUserMessages = this.messageHistory
+            .filter(msg => msg.role === 'user')
+            .slice(-this.options.maxSimilarMessages);
+        const recentAssistantMessages = this.messageHistory
+            .filter(msg => msg.role === 'assistant')
+            .slice(-this.options.maxSimilarMessages);
+        // Check for similar user messages
+        if (recentUserMessages.length >= this.options.maxSimilarMessages) {
+            const userLoop = this.checkSimilarMessages(recentUserMessages);
+            if (userLoop)
+                return true;
+        }
+        // Check for similar assistant messages
+        if (recentAssistantMessages.length >= this.options.maxSimilarMessages) {
+            const assistantLoop = this.checkSimilarMessages(recentAssistantMessages);
+            if (assistantLoop)
+                return true;
+        }
+        return false;
+    }
+    checkSimilarMessages(messages) {
+        if (messages.length < 2)
+            return false;
+        // Compare each message with every other message
+        for (let i = 0; i < messages.length - 1; i++) {
+            for (let j = i + 1; j < messages.length; j++) {
+                const similarity = this.calculateSimilarity(messages[i].content, messages[j].content);
+                if (similarity >= this.options.similarityThreshold) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    calculateSimilarity(text1, text2) {
+        // Simple similarity calculation using Levenshtein distance
+        const distance = this.levenshteinDistance(text1.toLowerCase(), text2.toLowerCase());
+        const maxLength = Math.max(text1.length, text2.length);
+        if (maxLength === 0)
+            return 1;
+        return 1 - (distance / maxLength);
+    }
+    levenshteinDistance(str1, str2) {
+        const matrix = [];
+        for (let i = 0; i <= str2.length; i++) {
+            matrix[i] = [i];
+        }
+        for (let j = 0; j <= str1.length; j++) {
+            matrix[0][j] = j;
+        }
+        for (let i = 1; i <= str2.length; i++) {
+            for (let j = 1; j <= str1.length; j++) {
+                if (str2.charAt(i - 1) === str1.charAt(j - 1)) {
+                    matrix[i][j] = matrix[i - 1][j - 1];
+                }
+                else {
+                    matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j] + 1);
+                }
+            }
+        }
+        return matrix[str2.length][str1.length];
+    }
+    cleanOldMessages(currentTime) {
+        const cutoffTime = currentTime - this.options.timeWindowMs;
+        this.messageHistory = this.messageHistory.filter(msg => msg.timestamp >= cutoffTime);
+    }
+    resetLoopDetection() {
+        this.messageHistory = [];
+        this.loopDetected = false;
+    }
+    getMessageHistory() {
+        return [...this.messageHistory];
+    }
+}
+exports.LoopDetectionModifier = LoopDetectionModifier;

package/dist/processor-pieces/additionalModifiers/memoryImportModifier.d.ts

@@ -0,0 +1,15 @@
+import { ProcessedMessage } from "@codebolt/types/agent";
+import { BaseMessageModifier } from "../base";
+import { FlatUserMessage } from "@codebolt/types/sdk";
+export interface MemoryImportOptions {
+    enableMemoryImport?: boolean;
+    maxFileSize?: number;
+    allowedExtensions?: string[];
+    basePath?: string;
+    maxImports?: number;
+}
+export declare class MemoryImportModifier extends BaseMessageModifier {
+    private readonly options;
+    constructor(options?: MemoryImportOptions);
+    modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
+}