@codebolt/agent 5.0.1 → 5.0.6

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

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

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

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

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

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

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

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

@@ -1,129 +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.MemoryImportModifier = void 0;
-const base_1 = require("../base");
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-class MemoryImportModifier extends base_1.BaseMessageModifier {
-    constructor(options = {}) {
-        super();
-        this.options = {
-            enableMemoryImport: options.enableMemoryImport !== false,
-            maxFileSize: options.maxFileSize || 1024 * 1024, // 1MB
-            allowedExtensions: options.allowedExtensions || ['.md', '.txt', '.json', '.yml', '.yaml', '.xml'],
-            basePath: options.basePath || process.cwd(),
-            maxImports: options.maxImports || 10
-        };
-    }
-    async modify(originalRequest, createdMessage) {
-        try {
-            if (!this.options.enableMemoryImport) {
-                return createdMessage;
-            }
-            // Get the user message content to process
-            const userMessage = createdMessage.message.messages.find(msg => msg.role === 'user');
-            if (!userMessage || typeof userMessage.content !== 'string') {
-                return createdMessage;
-            }
-            // Look for @path/to/file patterns (memory import syntax)
-            const memoryImportPattern = /@([^\s@]+(?:\.[a-zA-Z0-9]+)?)/g;
-            let content = userMessage.content;
-            const processedImports = [];
-            let match;
-            let importCount = 0;
-            while ((match = memoryImportPattern.exec(userMessage.content)) !== null && importCount < this.options.maxImports) {
-                const filePath = match[1];
-                const fullPath = path.isAbsolute(filePath) ? filePath : path.join(this.options.basePath, filePath);
-                try {
-                    // Check if file exists and is allowed
-                    const stats = await fs.promises.stat(fullPath);
-                    if (!stats.isFile()) {
-                        continue;
-                    }
-                    if (stats.size > this.options.maxFileSize) {
-                        content = content.replace(match[0], `[File too large: ${filePath}]`);
-                        continue;
-                    }
-                    const ext = path.extname(filePath);
-                    if (!this.options.allowedExtensions.includes(ext)) {
-                        content = content.replace(match[0], `[Unsupported file type: ${filePath}]`);
-                        continue;
-                    }
-                    // Read and import the file content
-                    const fileContent = await fs.promises.readFile(fullPath, 'utf-8');
-                    const importedContent = `--- Content from ${filePath} ---\n${fileContent}\n--- End of ${filePath} ---`;
-                    content = content.replace(match[0], importedContent);
-                    processedImports.push(filePath);
-                    importCount++;
-                }
-                catch (error) {
-                    // Replace with error message if file can't be read
-                    content = content.replace(match[0], `[Error reading ${filePath}: ${error instanceof Error ? error.message : 'unknown error'}]`);
-                }
-            }
-            if (processedImports.length === 0) {
-                return createdMessage;
-            }
-            // Update the user message with processed content
-            const messages = createdMessage.message.messages.map(msg => {
-                if (msg.role === 'user' && msg === userMessage) {
-                    return {
-                        ...msg,
-                        content
-                    };
-                }
-                return msg;
-            });
-            return Promise.resolve({
-                message: {
-                    ...createdMessage.message,
-                    messages
-                },
-                metadata: {
-                    ...createdMessage.metadata,
-                    memoryImportsProcessed: true,
-                    importedFiles: processedImports,
-                    totalImports: processedImports.length
-                }
-            });
-        }
-        catch (error) {
-            console.error('Error in MemoryImportModifier:', error);
-            return createdMessage;
-        }
-    }
-}
-exports.MemoryImportModifier = MemoryImportModifier;

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

@@ -1,25 +0,0 @@
-import { ProcessedMessage } from "@codebolt/types/agent";
-import { BaseMessageModifier } from "../base";
-import { FlatUserMessage } from "@codebolt/types/sdk";
-export interface ShellProcessorOptions {
-    enableShellExecution?: boolean;
-    maxExecutionTime?: number;
-    allowedCommands?: string[];
-    blockedCommands?: string[];
-    workingDirectory?: string;
-}
-export declare class ShellProcessorModifier extends BaseMessageModifier {
-    private readonly options;
-    private readonly execAsync;
-    private readonly SHELL_TRIGGER;
-    private readonly SHELL_CLOSE;
-    private readonly ARGS_PLACEHOLDER;
-    constructor(options?: ShellProcessorOptions);
-    modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
-    private processShellInjections;
-    private extractShellInjections;
-    private validateCommand;
-    private executeCommand;
-    private escapeShellArg;
-    private escapeRegex;
-}