@codebolt/agent 2.2.2 → 2.2.3

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

@@ -0,0 +1,212 @@
+"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.AtFileProcessorModifier = void 0;
+const base_1 = require("../base");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class AtFileProcessorModifier extends base_1.BaseMessageModifier {
+    constructor(options = {}) {
+        super();
+        this.options = {
+            maxFileSize: options.maxFileSize || 1024 * 1024, // 1MB default
+            allowedExtensions: options.allowedExtensions || ['.ts', '.js', '.json', '.md', '.txt', '.yml', '.yaml', '.xml', '.html', '.css', '.py', '.java', '.cpp', '.c', '.h'],
+            basePath: options.basePath || process.cwd()
+        };
+    }
+    async modify(originalRequest, createdMessage) {
+        try {
+            const mentionedFiles = originalRequest.mentionedFiles || [];
+            const mentionedFolders = originalRequest.mentionedFolders || [];
+            if (mentionedFiles.length === 0 && mentionedFolders.length === 0) {
+                return createdMessage;
+            }
+            const contextParts = [];
+            // Process mentioned files
+            if (mentionedFiles.length > 0) {
+                const fileContents = await Promise.all(mentionedFiles.map(async (filePath) => {
+                    try {
+                        const content = await this.readFileContent(filePath);
+                        return `--- Content from ${filePath} ---\n${content}\n--- End of ${filePath} ---`;
+                    }
+                    catch (error) {
+                        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                        return `[Error loading ${filePath}: ${errorMessage}]`;
+                    }
+                }));
+                contextParts.push(`File Contents:\n${fileContents.join('\n\n')}`);
+            }
+            // Process mentioned folders
+            if (mentionedFolders.length > 0) {
+                const folderContents = await Promise.all(mentionedFolders.map(async (folderPath) => {
+                    try {
+                        const structure = await this.getFolderStructure(folderPath);
+                        return `--- Structure of ${folderPath} ---\n${structure}\n--- End of ${folderPath} ---`;
+                    }
+                    catch (error) {
+                        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                        return `[Error reading folder ${folderPath}: ${errorMessage}]`;
+                    }
+                }));
+                contextParts.push(`Folder Structures:\n${folderContents.join('\n\n')}`);
+            }
+            // Find the last user message and append context to it
+            const messages = [...createdMessage.message.messages];
+            let lastUserMessageIndex = -1;
+            for (let i = messages.length - 1; i >= 0; i--) {
+                if (messages[i].role === 'user') {
+                    lastUserMessageIndex = i;
+                    break;
+                }
+            }
+            if (lastUserMessageIndex !== -1) {
+                const lastUserMessage = messages[lastUserMessageIndex];
+                const currentContent = Array.isArray(lastUserMessage.content)
+                    ? lastUserMessage.content
+                    : [{ type: 'text', text: lastUserMessage.content }];
+                // Add context as additional content parts
+                const contextContent = {
+                    type: 'text',
+                    text: contextParts.join('\n\n')
+                };
+                messages[lastUserMessageIndex] = {
+                    ...lastUserMessage,
+                    content: [...currentContent, contextContent]
+                };
+            }
+            return Promise.resolve({
+                message: {
+                    ...createdMessage.message,
+                    messages
+                },
+                metadata: {
+                    ...createdMessage.metadata,
+                    atFileProcessed: true,
+                    processedFiles: mentionedFiles,
+                    processedFolders: mentionedFolders
+                }
+            });
+        }
+        catch (error) {
+            console.error('Error in AtFileProcessorModifier:', error);
+            return createdMessage;
+        }
+    }
+    async readFileContent(filePath) {
+        // Resolve path relative to base path
+        const resolvedPath = path.isAbsolute(filePath) ? filePath : path.resolve(this.options.basePath, filePath);
+        // Security check: ensure the file is within allowed directory
+        const relativePath = path.relative(this.options.basePath, resolvedPath);
+        if (relativePath.startsWith('..')) {
+            throw new Error(`Access denied: ${filePath} is outside the allowed directory`);
+        }
+        // Check if file exists
+        try {
+            await fs.promises.access(resolvedPath, fs.constants.R_OK);
+        }
+        catch (error) {
+            throw new Error(`File not found or not readable: ${filePath}`);
+        }
+        // Check file size
+        const stats = await fs.promises.stat(resolvedPath);
+        if (stats.size > this.options.maxFileSize) {
+            throw new Error(`File too large: ${filePath} (${stats.size} bytes, max ${this.options.maxFileSize} bytes)`);
+        }
+        // Check file extension if allowedExtensions is specified
+        if (this.options.allowedExtensions.length > 0) {
+            const ext = path.extname(resolvedPath).toLowerCase();
+            if (!this.options.allowedExtensions.includes(ext)) {
+                throw new Error(`File type not allowed: ${ext}`);
+            }
+        }
+        // Read and return file content
+        const content = await fs.promises.readFile(resolvedPath, 'utf-8');
+        return content;
+    }
+    async getFolderStructure(folderPath) {
+        // Resolve path relative to base path
+        const resolvedPath = path.isAbsolute(folderPath) ? folderPath : path.resolve(this.options.basePath, folderPath);
+        // Security check: ensure the folder is within allowed directory
+        const relativePath = path.relative(this.options.basePath, resolvedPath);
+        if (relativePath.startsWith('..')) {
+            throw new Error(`Access denied: ${folderPath} is outside the allowed directory`);
+        }
+        // Check if folder exists and is readable
+        try {
+            await fs.promises.access(resolvedPath, fs.constants.R_OK);
+            const stats = await fs.promises.stat(resolvedPath);
+            if (!stats.isDirectory()) {
+                throw new Error(`${folderPath} is not a directory`);
+            }
+        }
+        catch (error) {
+            throw new Error(`Folder not found or not readable: ${folderPath}`);
+        }
+        // Read directory structure
+        try {
+            const entries = await fs.promises.readdir(resolvedPath, { 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(`${folderPath}/${entry.name}/`);
+                }
+                else {
+                    const filePath = path.join(resolvedPath, entry.name);
+                    const stats = await fs.promises.stat(filePath);
+                    const size = stats.size < 1024 ? `${stats.size}B` : `${Math.round(stats.size / 1024)}KB`;
+                    lines.push(`${folderPath}/${entry.name} (${size})`);
+                }
+            }
+            if (entries.length > 50) {
+                lines.push(`... and ${entries.length - 50} more items`);
+            }
+            return lines.join('\n');
+        }
+        catch (error) {
+            throw new Error(`Error reading folder structure: ${error instanceof Error ? error.message : 'unknown error'}`);
+        }
+    }
+}
+exports.AtFileProcessorModifier = AtFileProcessorModifier;

package/dist/processor-pieces/additionalModifiers/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;
+}

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

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatCompressionModifier = void 0;
+const base_1 = require("../base");
+class ChatCompressionModifier extends base_1.BaseMessageModifier {
+    constructor(options = {}) {
+        super();
+        this.hasFailedCompressionAttempt = false;
+        this.options = {
+            tokenThreshold: options.tokenThreshold || 8000, // Approximate token threshold
+            compressionRatio: options.compressionRatio || 0.5, // Compress to 50% of original
+            preserveRecentMessages: options.preserveRecentMessages || 5,
+            enableCompression: options.enableCompression !== false
+        };
+    }
+    async modify(originalRequest, createdMessage) {
+        try {
+            if (!this.options.enableCompression || this.hasFailedCompressionAttempt) {
+                return createdMessage;
+            }
+            const messages = createdMessage.message.messages;
+            // Skip compression if we don't have enough messages
+            if (messages.length <= this.options.preserveRecentMessages) {
+                return createdMessage;
+            }
+            const shouldCompress = await this.shouldCompressChat(messages);
+            if (!shouldCompress) {
+                return createdMessage;
+            }
+            const compressedMessages = await this.compressMessages(messages);
+            return Promise.resolve({
+                message: {
+                    ...createdMessage.message,
+                    messages: compressedMessages
+                },
+                metadata: {
+                    ...createdMessage.metadata,
+                    chatCompressed: true,
+                    originalMessageCount: messages.length,
+                    compressedMessageCount: compressedMessages.length
+                }
+            });
+        }
+        catch (error) {
+            console.error('Error in ChatCompressionModifier:', error);
+            this.hasFailedCompressionAttempt = true;
+            return createdMessage;
+        }
+    }
+    async shouldCompressChat(messages) {
+        // Estimate token count (rough approximation: 4 characters per token)
+        const totalCharacters = messages.reduce((sum, msg) => {
+            return sum + (typeof msg.content === 'string' ? msg.content.length : JSON.stringify(msg.content).length);
+        }, 0);
+        const estimatedTokens = totalCharacters / 4;
+        return estimatedTokens > this.options.tokenThreshold;
+    }
+    async compressMessages(messages) {
+        const preserveCount = this.options.preserveRecentMessages;
+        const recentMessages = messages.slice(-preserveCount);
+        const messagesToCompress = messages.slice(0, -preserveCount);
+        if (messagesToCompress.length === 0) {
+            return messages;
+        }
+        // Create a summary of the messages to compress
+        const conversationSummary = this.createConversationSummary(messagesToCompress);
+        const compressionMessage = {
+            role: 'system',
+            content: `[Conversation Summary - Previous ${messagesToCompress.length} messages compressed]
+
+${conversationSummary}
+
+[End of Summary - Continuing with recent conversation...]`
+        };
+        return [compressionMessage, ...recentMessages];
+    }
+    createConversationSummary(messages) {
+        const summaryParts = [];
+        let currentTopic = '';
+        let userQuestions = [];
+        let assistantResponses = [];
+        for (const message of messages) {
+            const content = typeof message.content === 'string' ? message.content : JSON.stringify(message.content);
+            if (message.role === 'user') {
+                // Extract key questions or requests
+                if (content.length > 20) { // Only include substantial messages
+                    userQuestions.push(content.substring(0, 100) + (content.length > 100 ? '...' : ''));
+                }
+            }
+            else if (message.role === 'assistant') {
+                // Extract key responses or actions
+                if (content.length > 20) {
+                    assistantResponses.push(content.substring(0, 100) + (content.length > 100 ? '...' : ''));
+                }
+            }
+        }
+        if (userQuestions.length > 0) {
+            summaryParts.push(`Key user requests: ${userQuestions.slice(0, 3).join('; ')}`);
+        }
+        if (assistantResponses.length > 0) {
+            summaryParts.push(`Key assistant actions: ${assistantResponses.slice(0, 3).join('; ')}`);
+        }
+        summaryParts.push(`Total messages compressed: ${messages.length}`);
+        return summaryParts.join('\n');
+    }
+    resetCompressionState() {
+        this.hasFailedCompressionAttempt = false;
+    }
+}
+exports.ChatCompressionModifier = ChatCompressionModifier;

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

@@ -0,0 +1,23 @@
+import { ProcessedMessage } from "@codebolt/types/agent";
+import { BaseMessageModifier } from "../base";
+import { FlatUserMessage } from "@codebolt/types/sdk";
+export interface ChatRecordingOptions {
+    enableRecording?: boolean;
+    recordingPath?: string;
+    maxRecordingSize?: number;
+    includeMetadata?: boolean;
+    recordingFormat?: 'json' | 'markdown';
+}
+export declare class ChatRecordingModifier extends BaseMessageModifier {
+    private readonly options;
+    private recordingFile?;
+    constructor(options?: ChatRecordingOptions);
+    modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
+    private initializeRecording;
+    private recordMessages;
+    private writeRecord;
+    startRecording(customPath?: string): void;
+    stopRecording(): void;
+    getRecordingFile(): string | undefined;
+    isRecording(): boolean;
+}

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

@@ -0,0 +1,173 @@
+"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.ChatRecordingModifier = void 0;
+const base_1 = require("../base");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class ChatRecordingModifier extends base_1.BaseMessageModifier {
+    constructor(options = {}) {
+        super();
+        this.options = {
+            enableRecording: options.enableRecording || false,
+            recordingPath: options.recordingPath || path.join(process.cwd(), '.chat-recordings'),
+            maxRecordingSize: options.maxRecordingSize || 10 * 1024 * 1024, // 10MB
+            includeMetadata: options.includeMetadata !== false,
+            recordingFormat: options.recordingFormat || 'json'
+        };
+        if (this.options.enableRecording) {
+            this.initializeRecording();
+        }
+    }
+    async modify(originalRequest, createdMessage) {
+        try {
+            if (!this.options.enableRecording || !this.recordingFile) {
+                return createdMessage;
+            }
+            // Record the conversation
+            await this.recordMessages(createdMessage, originalRequest);
+            return Promise.resolve({
+                ...createdMessage,
+                metadata: {
+                    ...createdMessage.metadata,
+                    chatRecorded: true,
+                    recordingFile: this.recordingFile
+                }
+            });
+        }
+        catch (error) {
+            console.error('Error in ChatRecordingModifier:', error);
+            return createdMessage;
+        }
+    }
+    initializeRecording() {
+        try {
+            // Ensure recording directory exists
+            if (!fs.existsSync(this.options.recordingPath)) {
+                fs.mkdirSync(this.options.recordingPath, { recursive: true });
+            }
+            // Create recording file with timestamp
+            const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+            const extension = this.options.recordingFormat === 'markdown' ? 'md' : 'jsonl';
+            this.recordingFile = path.join(this.options.recordingPath, `chat-${timestamp}.${extension}`);
+            // Initialize file with header
+            if (this.options.recordingFormat === 'markdown') {
+                fs.writeFileSync(this.recordingFile, `# Chat Recording\n\nStarted: ${new Date().toISOString()}\n\n---\n\n`);
+            }
+        }
+        catch (error) {
+            console.error('Failed to initialize chat recording:', error);
+            this.recordingFile = undefined;
+        }
+    }
+    async recordMessages(createdMessage, originalRequest) {
+        var _a, _b;
+        if (!this.recordingFile)
+            return;
+        try {
+            // Check file size before writing
+            if (fs.existsSync(this.recordingFile)) {
+                const stats = fs.statSync(this.recordingFile);
+                if (stats.size > this.options.maxRecordingSize) {
+                    console.warn(`Chat recording file ${this.recordingFile} exceeds maximum size. Stopping recording.`);
+                    return;
+                }
+            }
+            const timestamp = new Date().toISOString();
+            // Record each message
+            for (const message of createdMessage.message.messages) {
+                const record = {
+                    timestamp,
+                    messageId: (_a = createdMessage.metadata) === null || _a === void 0 ? void 0 : _a.messageId,
+                    threadId: (_b = createdMessage.metadata) === null || _b === void 0 ? void 0 : _b.threadId,
+                    role: message.role,
+                    content: typeof message.content === 'string' ? message.content : JSON.stringify(message.content)
+                };
+                if (this.options.includeMetadata) {
+                    record.metadata = {
+                        originalRequest: {
+                            userMessage: originalRequest.userMessage,
+                            messageId: originalRequest.messageId,
+                            threadId: originalRequest.threadId
+                        },
+                        processedMetadata: createdMessage.metadata
+                    };
+                }
+                await this.writeRecord(record);
+            }
+        }
+        catch (error) {
+            console.error('Error recording chat messages:', error);
+        }
+    }
+    async writeRecord(record) {
+        if (!this.recordingFile)
+            return;
+        try {
+            if (this.options.recordingFormat === 'markdown') {
+                const content = `## ${record.role.toUpperCase()} - ${record.timestamp}\n\n${record.content}\n\n---\n\n`;
+                fs.appendFileSync(this.recordingFile, content);
+            }
+            else {
+                const jsonLine = JSON.stringify(record) + '\n';
+                fs.appendFileSync(this.recordingFile, jsonLine);
+            }
+        }
+        catch (error) {
+            console.error('Error writing chat record:', error);
+        }
+    }
+    startRecording(customPath) {
+        this.options.enableRecording = true;
+        if (customPath) {
+            this.options.recordingPath = customPath;
+        }
+        this.initializeRecording();
+    }
+    stopRecording() {
+        this.options.enableRecording = false;
+        if (this.recordingFile && this.options.recordingFormat === 'markdown') {
+            fs.appendFileSync(this.recordingFile, `\n---\n\nRecording ended: ${new Date().toISOString()}\n`);
+        }
+        this.recordingFile = undefined;
+    }
+    getRecordingFile() {
+        return this.recordingFile;
+    }
+    isRecording() {
+        return (this.options.enableRecording || false) && !!this.recordingFile;
+    }
+}
+exports.ChatRecordingModifier = ChatRecordingModifier;

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

@@ -0,0 +1,14 @@
+import { ProcessedMessage } from "@codebolt/types/agent";
+import { BaseMessageModifier } from "../base";
+import { FlatUserMessage } from "@codebolt/types/sdk";
+export interface CoreSystemPromptOptions {
+    customSystemPrompt?: string;
+    userMemory?: string;
+}
+export declare class CoreSystemPromptModifier extends BaseMessageModifier {
+    private readonly options;
+    constructor(options?: CoreSystemPromptOptions);
+    modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
+    private getCoreSystemPrompt;
+    private getDefaultSystemPrompt;
+}

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

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoreSystemPromptModifier = void 0;
+const base_1 = require("../base");
+class CoreSystemPromptModifier extends base_1.BaseMessageModifier {
+    constructor(options = {}) {
+        super();
+        this.options = options;
+    }
+    modify(originalRequest, createdMessage) {
+        var _a;
+        // Get user memory from metadata or options
+        const userMemory = ((_a = createdMessage.metadata) === null || _a === void 0 ? void 0 : _a.userMemory) || this.options.userMemory;
+        const systemPrompt = this.options.customSystemPrompt || this.getCoreSystemPrompt(userMemory);
+        const systemMessage = {
+            role: 'system',
+            content: systemPrompt
+        };
+        // Find existing system message or add new one
+        const messages = [...createdMessage.message.messages];
+        const systemMessageIndex = messages.findIndex(msg => msg.role === 'system');
+        if (systemMessageIndex !== -1) {
+            // Replace existing system message
+            messages[systemMessageIndex] = systemMessage;
+        }
+        else {
+            // Add new system message at the beginning
+            messages.unshift(systemMessage);
+        }
+        return Promise.resolve({
+            message: {
+                ...createdMessage.message,
+                messages
+            },
+            metadata: {
+                ...createdMessage.metadata,
+                coreSystemPromptAdded: true,
+                systemPromptSource: this.options.customSystemPrompt ? 'custom' : 'default',
+                hasUserMemory: !!userMemory
+            }
+        });
+    }
+    getCoreSystemPrompt(userMemory) {
+        const basePrompt = this.getDefaultSystemPrompt();
+        // Add user memory with separator if provided (exactly like gemini-cli)
+        const memorySuffix = userMemory && userMemory.trim().length > 0
+            ? `\n\n---\n\n${userMemory.trim()}`
+            : '';
+        return `${basePrompt}${memorySuffix}`;
+    }
+    getDefaultSystemPrompt() {
+        return `
+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.
+        `.trim();
+    }
+}
+exports.CoreSystemPromptModifier = CoreSystemPromptModifier;

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

@@ -0,0 +1,30 @@
+import { ProcessedMessage } from "@codebolt/types/agent";
+import { BaseMessageModifier } from "../base";
+import { FlatUserMessage } from "@codebolt/types/sdk";
+export interface DirectoryContextOptions {
+    workspaceDirectories?: string[];
+}
+export declare class DirectoryContextModifier extends BaseMessageModifier {
+    private readonly options;
+    constructor(options?: DirectoryContextOptions);
+    modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
+    /**
+     * Generates a string representation of a directory's structure,
+     * limiting the number of items displayed. Ignored folders are shown
+     * followed by '...' instead of their contents.
+     *
+     * @param directory The absolute or relative path to the directory.
+     * @param options Optional configuration settings.
+     * @returns A promise resolving to the formatted folder structure string.
+     */
+    private getFolderStructure;
+    private readFullStructure;
+    /**
+     * Reads the directory structure using BFS, respecting maxItems.
+     * @param node The current node in the reduced structure.
+     * @param indent The current indentation string.
+     * @param isLast Sibling indicator.
+     * @param builder Array to build the string lines.
+     */
+    private formatStructure;
+}