@codebolt/agent 1.2.1 → 2.2.3

package/dist/processor-pieces/messageModifiers/atFileProcessorModifier.js

@@ -0,0 +1,453 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AtFileProcessorModifier = void 0;
+const base_1 = require("../base");
+const fs = __importStar(require("node:fs/promises"));
+const path = __importStar(require("node:path"));
+const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
+const DEFAULT_FILE_FILTERING_OPTIONS = {
+    respectGitIgnore: true,
+    respectGeminiIgnore: true,
+};
+class AtFileProcessorModifier extends base_1.BaseMessageModifier {
+    constructor(options = {}) {
+        super();
+        this.options = {
+            maxFileSize: options.maxFileSize || 1024 * 1024, // 1MB default
+            allowedExtensions: options.allowedExtensions || ['.ts', '.js', '.d.ts', '.json', '.md', '.txt', '.yml', '.yaml', '.xml', '.html', '.css', '.py', '.java', '.cpp', '.c', '.h'],
+            enableRecursiveSearch: options.enableRecursiveSearch !== false
+        };
+    }
+    async modify(originalRequest, createdMessage) {
+        try {
+            const mentionedFiles = originalRequest.mentionedFiles || [];
+            const mentionedFolders = originalRequest.mentionedFolders || [];
+            if (mentionedFiles.length === 0 && mentionedFolders.length === 0) {
+                return createdMessage;
+            }
+            // Process mentioned files and folders
+            const result = await this.processMentionedPaths(mentionedFiles, mentionedFolders);
+            if (!result.success) {
+                return createdMessage;
+            }
+            // Update the user message with processed content
+            const messages = [...createdMessage.message.messages];
+            const lastUserMessageIndex = this.findLastUserMessage(messages);
+            if (lastUserMessageIndex !== -1 && result.processedContent) {
+                const lastUserMessage = messages[lastUserMessageIndex];
+                // Convert string content to array format if needed
+                let currentContent;
+                if (Array.isArray(lastUserMessage.content)) {
+                    currentContent = lastUserMessage.content;
+                }
+                else {
+                    // Convert string content to array format
+                    currentContent = [{ type: 'text', text: lastUserMessage.content }];
+                }
+                // Ensure processedContent is in array format
+                const newContent = Array.isArray(result.processedContent)
+                    ? result.processedContent
+                    : [{ type: 'text', text: result.processedContent }];
+                // Merge existing content with processed content
+                messages[lastUserMessageIndex] = {
+                    ...lastUserMessage,
+                    content: [...currentContent, ...newContent]
+                };
+            }
+            return {
+                message: {
+                    ...createdMessage.message,
+                    messages
+                },
+                metadata: {
+                    ...createdMessage.metadata,
+                    atFileProcessed: true,
+                    processedFiles: mentionedFiles,
+                    processedFolders: mentionedFolders,
+                    filesRead: result.filesRead || []
+                }
+            };
+        }
+        catch (error) {
+            console.error('Error in AtFileProcessorModifier:', error);
+            return createdMessage;
+        }
+    }
+    async processMentionedPaths(mentionedFiles, mentionedFolders) {
+        const filesRead = [];
+        const contextParts = [];
+        // Get workspace directories
+        let workspaceDirectories = [];
+        try {
+            const { projectPath } = await codeboltjs_1.default.project.getProjectPath();
+            workspaceDirectories = projectPath ? [projectPath] : [await this.getProjectPath()];
+        }
+        catch (error) {
+            workspaceDirectories = [await this.getProjectPath()];
+        }
+        // Process mentioned files using readManyFiles
+        if (mentionedFiles.length > 0) {
+            try {
+                const resolvedPaths = await Promise.all(mentionedFiles.map(async (filePath) => {
+                    try {
+                        await this.resolvePath(filePath, workspaceDirectories);
+                        return filePath; // Keep original path for readManyFiles
+                    }
+                    catch (error) {
+                        console.warn(`Could not resolve path: ${filePath}`);
+                        return filePath; // Still try to read it
+                    }
+                }));
+                const fileContents = await this.readManyFiles(resolvedPaths);
+                filesRead.push(...mentionedFiles);
+                if (fileContents.length > 0) {
+                    contextParts.push(`\n--- Content from referenced files ---`);
+                    for (const { path: filePath, content } of fileContents) {
+                        contextParts.push(`\nContent from @${filePath}:\n`);
+                        contextParts.push(content);
+                    }
+                }
+            }
+            catch (error) {
+                console.error('Error reading mentioned files:', error);
+                // Fallback to individual file reading
+                contextParts.push(`\n--- Content from referenced files ---`);
+                for (const filePath of mentionedFiles) {
+                    try {
+                        const resolvedPath = await this.resolvePath(filePath, workspaceDirectories);
+                        const content = await this.readFileContent(resolvedPath);
+                        filesRead.push(filePath);
+                        contextParts.push(`\nContent from @${filePath}:\n`);
+                        contextParts.push(content);
+                    }
+                    catch (error) {
+                        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                        contextParts.push(`\nContent from @${filePath}:\n`);
+                        contextParts.push(`[Error loading ${filePath}: ${errorMessage}]`);
+                    }
+                }
+            }
+        }
+        // Process mentioned folders
+        if (mentionedFolders.length > 0) {
+            contextParts.push(`\n--- Folder Structures ---`);
+            for (const folderPath of mentionedFolders) {
+                try {
+                    const resolvedPath = await this.resolvePath(folderPath, workspaceDirectories);
+                    const structure = await this.getFolderStructure(resolvedPath);
+                    filesRead.push(folderPath);
+                    contextParts.push(`\nStructure of @${folderPath}:\n`);
+                    contextParts.push(structure);
+                    // Also read files within the folder
+                    const filesInFolder = await this.getFilesInFolder(resolvedPath);
+                    // console.log(`Found ${filesInFolder.length} files in ${folderPath}:`, filesInFolder.map(f => path.basename(f)));
+                    if (filesInFolder.length > 0) {
+                        contextParts.push(`\n--- Files in ${folderPath} ---`);
+                        for (const filePath of filesInFolder) {
+                            try {
+                                // console.log(`Attempting to read file: ${filePath}`);
+                                const content = await this.readFileContent(filePath);
+                                const relativePath = path.relative(resolvedPath, filePath);
+                                const displayPath = `${folderPath}/${relativePath}`;
+                                contextParts.push(`\nContent from @${displayPath}:\n`);
+                                contextParts.push(content);
+                                // console.log(`Successfully read file: ${displayPath} (${content.length} chars)`);
+                            }
+                            catch (error) {
+                                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                                const relativePath = path.relative(resolvedPath, filePath);
+                                const displayPath = `${folderPath}/${relativePath}`;
+                                console.error(`Error reading file ${displayPath}:`, errorMessage);
+                                contextParts.push(`\nContent from @${displayPath}:\n`);
+                                contextParts.push(`[Error reading file: ${errorMessage}]`);
+                            }
+                        }
+                    }
+                    else {
+                        console.log(`No files found in ${folderPath} (resolved to ${resolvedPath})`);
+                    }
+                }
+                catch (error) {
+                    const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                    contextParts.push(`\nStructure of @${folderPath}:\n`);
+                    contextParts.push(`[Error reading folder ${folderPath}: ${errorMessage}]`);
+                }
+            }
+        }
+        return {
+            success: true,
+            processedContent: this.buildContentParts(contextParts),
+            filesRead
+        };
+    }
+    buildContentParts(contextParts) {
+        const contentParts = [];
+        for (const part of contextParts) {
+            contentParts.push({
+                type: 'text',
+                text: part
+            });
+        }
+        return contentParts;
+    }
+    async resolvePath(pathName, workspaceDirectories) {
+        // Try to resolve the path in workspace directories
+        for (const dir of workspaceDirectories) {
+            try {
+                const absolutePath = path.resolve(dir, pathName);
+                await fs.stat(absolutePath); // Check if path exists
+                return absolutePath;
+            }
+            catch (error) {
+                if (this.isNodeError(error) && error.code === 'ENOENT') {
+                    if (this.options.enableRecursiveSearch) {
+                        // Try glob search
+                        const globResult = await this.globSearch(pathName, dir);
+                        if (globResult) {
+                            return path.resolve(dir, globResult);
+                        }
+                    }
+                }
+            }
+        }
+        // Fallback to original path
+        const projectPath = await this.getProjectPath();
+        return path.isAbsolute(pathName) ? pathName : path.resolve(projectPath, pathName);
+    }
+    async globSearch(pathName, dir) {
+        // Simple glob search implementation
+        try {
+            const pattern = `**/*${pathName}*`;
+            const matches = await this.findFiles(dir, pattern);
+            if (matches.length > 0) {
+                return path.relative(dir, matches[0]);
+            }
+        }
+        catch (error) {
+            console.error('Glob search error:', error);
+        }
+        return null;
+    }
+    async findFiles(dir, pattern) {
+        // Simplified file finding - in real implementation would use proper glob
+        const matches = [];
+        const searchTerm = pattern.replace(/\*\*/g, '').replace(/\*/g, '');
+        try {
+            const entries = await fs.readdir(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.name.includes(searchTerm)) {
+                    matches.push(path.join(dir, entry.name));
+                }
+                if (entry.isDirectory() && !entry.name.startsWith('.')) {
+                    const subMatches = await this.findFiles(path.join(dir, entry.name), pattern);
+                    matches.push(...subMatches);
+                }
+            }
+        }
+        catch (error) {
+            // Ignore errors in subdirectories
+        }
+        return matches.slice(0, 10); // Limit results
+    }
+    async readManyFiles(pathSpecs) {
+        const results = [];
+        // Try to use read_many_files tool if available (like gemini-cli)
+        try {
+            // In a real implementation, this would use the actual tool registry
+            // For now, we'll simulate the tool behavior
+            const toolArgs = {
+                paths: pathSpecs,
+                useDefaultExcludes: true,
+                file_filtering_options: {
+                    respect_git_ignore: DEFAULT_FILE_FILTERING_OPTIONS.respectGitIgnore,
+                    respect_gemini_ignore: DEFAULT_FILE_FILTERING_OPTIONS.respectGeminiIgnore,
+                }
+            };
+            // Simulate read_many_files tool execution
+            for (const pathSpec of pathSpecs) {
+                try {
+                    if (pathSpec.includes('**') || pathSpec.includes('*')) {
+                        // Handle directory patterns
+                        const basePath = pathSpec.replace('/**', '').replace('**', '');
+                        const files = await this.findFiles(basePath, '**/*');
+                        for (const filePath of files.slice(0, 20)) { // Limit files
+                            try {
+                                const content = await this.readFileContent(filePath);
+                                const projectPath = await this.getProjectPath();
+                                results.push({ path: path.relative(projectPath, filePath), content });
+                            }
+                            catch (error) {
+                                results.push({ path: filePath, content: `[Error reading file: ${error}]` });
+                            }
+                        }
+                    }
+                    else {
+                        // Handle single file
+                        const projectPath = await this.getProjectPath();
+                        const resolvedPath = path.isAbsolute(pathSpec) ? pathSpec : path.resolve(projectPath, pathSpec);
+                        const content = await this.readFileContent(resolvedPath);
+                        results.push({ path: pathSpec, content });
+                    }
+                }
+                catch (error) {
+                    results.push({ path: pathSpec, content: `[Error reading: ${error}]` });
+                }
+            }
+        }
+        catch (error) {
+            console.error('Error in readManyFiles:', error);
+            // Fallback to individual file reading
+            for (const pathSpec of pathSpecs) {
+                try {
+                    const projectPath = await this.getProjectPath();
+                    const resolvedPath = path.isAbsolute(pathSpec) ? pathSpec : path.resolve(projectPath, pathSpec);
+                    const content = await this.readFileContent(resolvedPath);
+                    results.push({ path: pathSpec, content });
+                }
+                catch (error) {
+                    results.push({ path: pathSpec, content: `[Error reading: ${error}]` });
+                }
+            }
+        }
+        return results;
+    }
+    async readFileContent(filePath) {
+        // Check file size
+        const stats = await fs.stat(filePath);
+        if (stats.size > this.options.maxFileSize) {
+            throw new Error(`File too large: ${stats.size} bytes`);
+        }
+        // Check file extension
+        if (this.options.allowedExtensions.length > 0) {
+            const ext = path.extname(filePath).toLowerCase();
+            if (!this.options.allowedExtensions.includes(ext)) {
+                throw new Error(`File type not allowed: ${ext}`);
+            }
+        }
+        const content = await fs.readFile(filePath, 'utf-8');
+        return content;
+    }
+    async getFilesInFolder(folderPath) {
+        try {
+            const entries = await fs.readdir(folderPath, { withFileTypes: true });
+            const files = [];
+            for (const entry of entries) {
+                if (entry.isFile() && !entry.name.startsWith('.')) {
+                    // Check file extension if allowed extensions are specified
+                    if (this.options.allowedExtensions.length > 0) {
+                        const ext = path.extname(entry.name).toLowerCase();
+                        // console.log(`Checking file ${entry.name} with extension ${ext}. Allowed:`, this.options.allowedExtensions);
+                        if (this.options.allowedExtensions.includes(ext)) {
+                            files.push(path.join(folderPath, entry.name));
+                        }
+                        else {
+                            // console.log(`File ${entry.name} extension ${ext} not in allowed list`);
+                        }
+                    }
+                    else {
+                        files.push(path.join(folderPath, entry.name));
+                    }
+                }
+            }
+            // Limit number of files to avoid overwhelming output
+            return files.slice(0, 10);
+        }
+        catch (error) {
+            console.error('Error reading files in folder:', error);
+            return [];
+        }
+    }
+    async getFolderStructure(folderPath) {
+        // Check if folder exists and is readable
+        const stats = await fs.stat(folderPath);
+        if (!stats.isDirectory()) {
+            throw new Error(`${folderPath} is not a directory`);
+        }
+        // Read directory structure
+        const entries = await fs.readdir(folderPath, { withFileTypes: true });
+        const lines = [];
+        // Sort entries: directories first, then files
+        const sortedEntries = entries.sort((a, b) => {
+            if (a.isDirectory() && !b.isDirectory())
+                return -1;
+            if (!a.isDirectory() && b.isDirectory())
+                return 1;
+            return a.name.localeCompare(b.name);
+        });
+        for (const entry of sortedEntries.slice(0, 50)) { // Limit to 50 entries
+            if (entry.name.startsWith('.'))
+                continue; // Skip hidden files
+            if (entry.isDirectory()) {
+                lines.push(`${path.basename(folderPath)}/${entry.name}/`);
+            }
+            else {
+                const filePath = path.join(folderPath, entry.name);
+                const fileStats = await fs.stat(filePath);
+                const size = fileStats.size < 1024 ? `${fileStats.size}B` : `${Math.round(fileStats.size / 1024)}KB`;
+                lines.push(`${path.basename(folderPath)}/${entry.name} (${size})`);
+            }
+        }
+        if (entries.length > 50) {
+            lines.push(`... and ${entries.length - 50} more items`);
+        }
+        return lines.join('\n');
+    }
+    findLastUserMessage(messages) {
+        for (let i = messages.length - 1; i >= 0; i--) {
+            if (messages[i].role === 'user') {
+                return i;
+            }
+        }
+        return -1;
+    }
+    async getProjectPath() {
+        try {
+            const { projectPath } = await codeboltjs_1.default.project.getProjectPath();
+            return projectPath || process.cwd();
+        }
+        catch (error) {
+            console.warn('Failed to get project path from codebolt.project.getProjectPath(), falling back to process.cwd()');
+            return process.cwd();
+        }
+    }
+    isNodeError(error) {
+        return error instanceof Error && 'code' in error;
+    }
+}
+exports.AtFileProcessorModifier = AtFileProcessorModifier;

package/dist/processor-pieces/messageModifiers/baseContextMessageModifier.d.ts

@@ -0,0 +1,7 @@
+import { ProcessedMessage } from "@codebolt/types/agent";
+import { BaseMessageModifier } from "../base";
+import { FlatUserMessage } from "@codebolt/types/sdk";
+export declare class BaseContextMessageModifier extends BaseMessageModifier {
+    constructor();
+    modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
+}

package/dist/processor-pieces/messageModifiers/baseContextMessageModifier.js

@@ -0,0 +1,67 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseContextMessageModifier = void 0;
+const base_1 = require("../base");
+const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
+const os_1 = __importDefault(require("os"));
+class BaseContextMessageModifier extends base_1.BaseMessageModifier {
+    constructor() {
+        super();
+    }
+    async modify(originalRequest, createdMessage) {
+        const contextParts = [];
+        const now = new Date();
+        contextParts.push(`Current Date/Time: ${now.toISOString()}`);
+        const osInfo = {
+            platform: os_1.default.platform(),
+            arch: os_1.default.arch(),
+            version: os_1.default.version(),
+            hostname: os_1.default.hostname()
+        };
+        contextParts.push(`Operating System: ${JSON.stringify(osInfo, null, 2)}`);
+        try {
+            const { projectPath } = await codeboltjs_1.default.project.getProjectPath();
+            contextParts.push(`Working Directory: ${projectPath}`);
+        }
+        catch (error) {
+            contextParts.push(`Working Directory: ${process.cwd()}`);
+        }
+        if (contextParts.length > 0) {
+            const contextMessage = {
+                role: 'system',
+                content: contextParts.join('\n\n'),
+            };
+            // Create a copy of messages array
+            const messages = [...createdMessage.message.messages];
+            // Check if system message already exists in the messages array
+            const existingSystemMessageIndex = messages.findIndex(msg => msg.role == 'system');
+            if (existingSystemMessageIndex !== -1) {
+                // Append context to existing system message content
+                const existingContent = messages[existingSystemMessageIndex].content || '';
+                messages[existingSystemMessageIndex] = {
+                    ...messages[existingSystemMessageIndex],
+                    content: existingContent + '\n\n' + contextMessage.content
+                };
+            }
+            else {
+                // Add system message to the top of the array
+                messages.unshift(contextMessage);
+            }
+            // Return new ProcessedMessage object
+            return {
+                message: {
+                    ...createdMessage.message,
+                    messages
+                },
+                metadata: {
+                    ...createdMessage.metadata
+                }
+            };
+        }
+        return createdMessage;
+    }
+}
+exports.BaseContextMessageModifier = BaseContextMessageModifier;

package/dist/processor-pieces/messageModifiers/baseSystemInstructionMessageModifier.d.ts

@@ -0,0 +1,9 @@
+import { ProcessedMessage } from "@codebolt/types/agent";
+import { BaseMessageModifier } from "../base";
+import { FlatUserMessage } from "@codebolt/types/sdk";
+export declare class BaseSystemInstructionMessageModifier extends BaseMessageModifier {
+    private readonly systemInstruction;
+    constructor(systemInstruction?: string);
+    modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
+    private getCoreSystemPrompt;
+}

package/dist/processor-pieces/messageModifiers/baseSystemInstructionMessageModifier.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseSystemInstructionMessageModifier = void 0;
+const base_1 = require("../base");
+class BaseSystemInstructionMessageModifier extends base_1.BaseMessageModifier {
+    constructor(systemInstruction) {
+        super();
+        this.systemInstruction = systemInstruction || this.getCoreSystemPrompt();
+    }
+    async modify(originalRequest, createdMessage) {
+        try {
+            // Create system instruction message
+            const systemMessage = {
+                role: 'system',
+                content: this.systemInstruction
+            };
+            // Get existing messages
+            const messages = [...(createdMessage.message.messages || [])];
+            // Check if system message already exists
+            const existingSystemIndex = messages.findIndex(msg => msg.role === 'system');
+            if (existingSystemIndex !== -1) {
+                // Update existing system message
+                messages[existingSystemIndex] = systemMessage;
+            }
+            else {
+                // Add system message to first position
+                messages.unshift(systemMessage);
+            }
+            // Return new ProcessedMessage object
+            return {
+                message: {
+                    ...createdMessage.message,
+                    messages
+                },
+                metadata: {
+                    ...createdMessage.metadata
+                }
+            };
+        }
+        catch (error) {
+            console.error('Error in BaseSystemInstructionMessageModifier:', error);
+            throw error;
+        }
+    }
+    getCoreSystemPrompt() {
+        // Default system prompt similar to gemini-cli but simplified for CodeBolt context
+        const basePrompt = `
+You are an interactive AI agent specializing in software engineering tasks. Your primary goal is to help users safely and efficiently, adhering strictly to the following instructions and utilizing your available tools.
+
+# Core Mandates
+
+- **Conventions:** Rigorously adhere to existing project conventions when reading or modifying code. Analyze surrounding code, tests, and configuration first.
+- **Libraries/Frameworks:** NEVER assume a library/framework is available or appropriate. Verify its established usage within the project before employing it.
+- **Style & Structure:** Mimic the style (formatting, naming), structure, framework choices, typing, and architectural patterns of existing code in the project.
+- **Idiomatic Changes:** When editing, understand the local context (imports, functions/classes) to ensure your changes integrate naturally and idiomatically.
+- **Comments:** Add code comments sparingly. Focus on *why* something is done, especially for complex logic, rather than *what* is done.
+- **Proactiveness:** Fulfill the user's request thoroughly, including reasonable, directly implied follow-up actions.
+- **Confirm Ambiguity/Expansion:** Do not take significant actions beyond the clear scope of the request without confirming with the user.
+- **Explaining Changes:** After completing a code modification or file operation *do not* provide summaries unless asked.
+
+# Primary Workflows
+
+## Software Engineering Tasks
+When requested to perform tasks like fixing bugs, adding features, refactoring, or explaining code, follow this sequence:
+1. **Understand:** Think about the user's request and the relevant codebase context. Use search tools extensively to understand file structures, existing code patterns, and conventions.
+2. **Plan:** Build a coherent and grounded plan for how you intend to resolve the user's task. Share a concise yet clear plan with the user if it would help.
+3. **Implement:** Use the available tools to act on the plan, strictly adhering to the project's established conventions.
+4. **Verify:** If applicable and feasible, verify the changes using the project's testing procedures and build/lint commands.
+
+# Operational Guidelines
+
+## Tone and Style
+- **Concise & Direct:** Adopt a professional, direct, and concise tone.
+- **Minimal Output:** Aim for fewer than 3 lines of text output per response whenever practical.
+- **Clarity over Brevity:** While conciseness is key, prioritize clarity for essential explanations.
+- **No Chitchat:** Avoid conversational filler. Get straight to the action or answer.
+- **Formatting:** Use GitHub-flavored Markdown.
+
+## Security and Safety Rules
+- **Security First:** Always apply security best practices. Never introduce code that exposes, logs, or commits secrets, API keys, or other sensitive information.
+- **File Operations:** Always use absolute paths when referring to files with tools.
+
+# Final Reminder
+Your core function is efficient and safe assistance. Balance extreme conciseness with the crucial need for clarity, especially regarding safety and potential system modifications. Always prioritize user control and project conventions.
+ Do not ask for more information than necessary. Use the tools provided to accomplish the user's request efficiently and effectively. When you've completed your task, you must use the attempt_completion tool to present the result to the user. The user may provide feedback, which you can use to make improvements and try again.
+`.trim();
+        return basePrompt;
+    }
+}
+exports.BaseSystemInstructionMessageModifier = BaseSystemInstructionMessageModifier;

package/dist/processor-pieces/messageModifiers/chatCompressionModifier.d.ts

@@ -0,0 +1,19 @@
+import { ProcessedMessage } from "@codebolt/types/agent";
+import { BaseMessageModifier } from "../base";
+import { FlatUserMessage } from "@codebolt/types/sdk";
+export interface ChatCompressionOptions {
+    tokenThreshold?: number;
+    compressionRatio?: number;
+    preserveRecentMessages?: number;
+    enableCompression?: boolean;
+}
+export declare class ChatCompressionModifier extends BaseMessageModifier {
+    private readonly options;
+    private hasFailedCompressionAttempt;
+    constructor(options?: ChatCompressionOptions);
+    modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
+    private shouldCompressChat;
+    private compressMessages;
+    private createConversationSummary;
+    resetCompressionState(): void;
+}