@codebolt/agent 1.2.1 → 2.2.3

package/dist/processor-pieces/base/basePreToolCallProcessor.js

@@ -0,0 +1,66 @@
+"use strict";
+/**
+ * Base Pre-Tool Call Processor Class
+ * Abstract base class for all pre-tool call processors
+ * These are called before the Tool Call
+ * Used to check if the Tool Call is proper and handle Local Tool Interceptor
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BasePreToolCallProcessor = void 0;
+class BasePreToolCallProcessor {
+    constructor() {
+        this.context = {};
+        // this.context = options.context || {};
+    }
+    // Optional tool interceptor method
+    async interceptTool(_toolName, _toolInput) {
+        return false; // Default: don't intercept
+    }
+    setContext(key, value) {
+        this.context[key] = value;
+    }
+    getContext(key) {
+        return this.context[key];
+    }
+    clearContext() {
+        this.context = {};
+    }
+    // Helper method to create intercepted tool result
+    createInterceptedTool(toolName, originalInput, result, reason) {
+        return {
+            toolName,
+            originalInput,
+            result,
+            intercepted: true,
+            reason,
+        };
+    }
+    // Helper method to validate tool call
+    validateToolCall(toolCall, validationRules) {
+        const errors = [];
+        const warnings = [];
+        const toolName = toolCall.function.name;
+        const relevantRules = validationRules.filter(rule => rule.toolName === toolName);
+        for (const rule of relevantRules) {
+            try {
+                if (!rule.validator(toolCall.function.arguments)) {
+                    errors.push(rule.errorMessage);
+                }
+            }
+            catch (error) {
+                warnings.push(`Validation rule for '${toolName}' failed to execute: ${error}`);
+            }
+        }
+        return {
+            isValid: errors.length === 0,
+            toolName,
+            errors,
+            warnings,
+            metadata: {
+                timestamp: new Date().toISOString(),
+                processor: this.constructor.name
+            }
+        };
+    }
+}
+exports.BasePreToolCallProcessor = BasePreToolCallProcessor;

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

@@ -0,0 +1,9 @@
+/**
+ * Base Processor Classes Index
+ * Exports all base processor classes for processor-pieces
+ */
+export { BaseMessageModifier } from './baseMessageModifier';
+export { BasePreInferenceProcessor } from './basePreInferenceProcessor';
+export { BasePostInferenceProcessor } from './basePostInferenceProcessor';
+export { BasePreToolCallProcessor } from './basePreToolCallProcessor';
+export { BasePostToolCallProcessor } from './basePostToolCallProcessor';

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

@@ -0,0 +1,18 @@
+"use strict";
+/**
+ * Base Processor Classes Index
+ * Exports all base processor classes for processor-pieces
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BasePostToolCallProcessor = exports.BasePreToolCallProcessor = exports.BasePostInferenceProcessor = exports.BasePreInferenceProcessor = exports.BaseMessageModifier = void 0;
+// Base processor classes
+var baseMessageModifier_1 = require("./baseMessageModifier");
+Object.defineProperty(exports, "BaseMessageModifier", { enumerable: true, get: function () { return baseMessageModifier_1.BaseMessageModifier; } });
+var basePreInferenceProcessor_1 = require("./basePreInferenceProcessor");
+Object.defineProperty(exports, "BasePreInferenceProcessor", { enumerable: true, get: function () { return basePreInferenceProcessor_1.BasePreInferenceProcessor; } });
+var basePostInferenceProcessor_1 = require("./basePostInferenceProcessor");
+Object.defineProperty(exports, "BasePostInferenceProcessor", { enumerable: true, get: function () { return basePostInferenceProcessor_1.BasePostInferenceProcessor; } });
+var basePreToolCallProcessor_1 = require("./basePreToolCallProcessor");
+Object.defineProperty(exports, "BasePreToolCallProcessor", { enumerable: true, get: function () { return basePreToolCallProcessor_1.BasePreToolCallProcessor; } });
+var basePostToolCallProcessor_1 = require("./basePostToolCallProcessor");
+Object.defineProperty(exports, "BasePostToolCallProcessor", { enumerable: true, get: function () { return basePostToolCallProcessor_1.BasePostToolCallProcessor; } });

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

@@ -0,0 +1 @@
+export * from './messageModifiers';

package/dist/processor-pieces/index.js

@@ -0,0 +1,59 @@
+"use strict";
+// // Reusable processors
+// export { ChatCompressionProcessor } from './postToolCall/chatCompressionProcessor';
+// export { LoopDetectionProcessor } from './postToolCall/loopDetectionProcessor';
+// export { ContextManagementProcessor } from './postToolCall/contextManagementProcessor';
+// export { AdvancedLoopDetectionProcessor } from './postToolCall/advancedLoopDetectionProcessor';
+// export { TokenManagementProcessor } from './postToolCall/tokenManagementProcessor';
+// export { ResponseValidationProcessor } from './postToolCall/responseValidationProcessor';
+// export { ChatRecordingProcessor } from './postToolCall/chatRecordingProcessor';
+// export { TelemetryProcessor } from './postToolCall/telemetryProcessor';
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// // Follow-up conversation processors
+// export { ConversationCompactorProcessor } from './postToolCall/conversationCompactorProcessor';
+// export { FollowUpConversationProcessor } from './postToolCall/followUpConversationProcessor';
+// export { ConversationContinuityProcessor } from './postToolCall/conversationContinuityProcessor';
+// // Pre-tool call processors
+// export {
+//     LocalToolInterceptorProcessor,
+//     ToolValidationProcessor,
+//     ToolParameterModifierProcessor,
+//     type LocalToolInterceptorInfo,
+//     type LocalToolInterceptorProcessorOptions,
+//     type LocalToolHandler,
+//     type ToolValidationInfo,
+//     type ToolValidationProcessorOptions,
+//     type ToolParameterModificationInfo,
+//     type ParameterTransformation,
+//     type ToolParameterModifierProcessorOptions
+// } from './preToolCall';
+// // Reusable message modifiers
+// export { HandleUrlMessageModifier } from './messageModifiers/handleUrlMessageModifier';
+// export { BaseContextMessageModifier } from './messageModifiers/baseContextMessageModifier';
+// export { WorkingDirectoryMessageModifier } from './messageModifiers/workingDirectoryMessageModifier';
+// export { BaseSystemInstructionMessageModifier } from './messageModifiers/baseSystemInstructionMessageModifier';
+// export { ImageAttachmentMessageModifier } from './messageModifiers/imageAttachmentMessageModifier';
+// export { AddToolsListMessageModifier } from './messageModifiers/addToolsListMessageModifier';
+// // Reusable tools
+// export { 
+//     FileReadTool, 
+//     FileWriteTool, 
+//     FileDeleteTool, 
+//     FileMoveTool, 
+//     FileCopyTool 
+// } from './tools/fileTools';
+__exportStar(require("./messageModifiers"), exports);

package/dist/processor-pieces/messageModifiers/addCurrentDirectoryRootFilesModifier.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 AddCurrentDirectoryRootFilesModifier extends BaseMessageModifier {
+    constructor();
+    modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage, context?: Record<string, unknown>): Promise<ProcessedMessage>;
+}

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

@@ -0,0 +1,93 @@
+"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.AddCurrentDirectoryRootFilesModifier = void 0;
+const base_1 = require("../base");
+const fs = __importStar(require("fs"));
+class AddCurrentDirectoryRootFilesModifier extends base_1.BaseMessageModifier {
+    constructor() {
+        super();
+    }
+    async modify(originalRequest, createdMessage, context) {
+        try {
+            // Use current working directory
+            const currentPath = process.cwd();
+            // Read directory contents
+            const files = await fs.promises.readdir(currentPath, { withFileTypes: true });
+            // Format files list with type indicators
+            const filesList = files
+                .map(file => {
+                return ` ${file.name}`;
+            })
+                .join('\n');
+            const filesContent = filesList || 'No files found';
+            // Find system message and append files list to it
+            const messages = [...createdMessage.message.messages];
+            const systemMessageIndex = messages.findIndex(message => message.role === 'system');
+            if (systemMessageIndex !== -1) {
+                // Update existing system message
+                messages[systemMessageIndex] = {
+                    ...messages[systemMessageIndex],
+                    content: `${messages[systemMessageIndex].content}\n\nCurrent directory root files:\n\n${filesContent}`
+                };
+            }
+            else {
+                // Add new system message if none exists
+                messages.unshift({
+                    role: 'system',
+                    content: `Current directory root files:\n\n${filesContent}`
+                });
+            }
+            // Return updated message
+            return {
+                message: {
+                    ...createdMessage.message,
+                    messages
+                },
+                metadata: {
+                    ...createdMessage.metadata,
+                    currentDirectoryFilesAdded: true,
+                    currentDirectoryPath: currentPath
+                }
+            };
+        }
+        catch (error) {
+            console.error('Error in AddCurrentDirectoryRootFilesModifier:', error);
+            // Return original message if there's an error
+            return createdMessage;
+        }
+    }
+}
+exports.AddCurrentDirectoryRootFilesModifier = AddCurrentDirectoryRootFilesModifier;

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

@@ -0,0 +1,31 @@
+import { ProcessedMessage } from "@codebolt/types/agent";
+import { BaseMessageModifier } from "../base";
+import { FlatUserMessage, Tool } from "@codebolt/types/sdk";
+export interface ToolList {
+    getAllTools(): Tool[];
+    addTool?(tool: Tool): void;
+    removeTool?(toolName: string): void;
+    getTool?(toolName: string): Tool | undefined;
+    getToolNames?(): string[];
+}
+export interface AddToolsListMessageModifierOptions {
+    toolsList?: ToolList;
+    addToolsLocation?: 'InsidePrompt' | 'Tool' | 'SystemMessage';
+    giveToolExamples?: boolean;
+    maxToolExamples?: number;
+    includeToolDescriptions?: boolean;
+}
+export declare class AddToolsListMessageModifier extends BaseMessageModifier {
+    private readonly toolsList?;
+    private readonly addToolsLocation;
+    private readonly giveToolExamples;
+    private readonly maxToolExamples;
+    private readonly includeToolDescriptions;
+    constructor(options?: AddToolsListMessageModifierOptions);
+    modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
+    private addToolsInsidePrompt;
+    private addToolsAsSystemMessage;
+    private addToolsAsToolCalls;
+    private generateToolsInfo;
+    private generateToolExample;
+}

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

@@ -0,0 +1,145 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AddToolsListMessageModifier = void 0;
+const base_1 = require("../base");
+const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
+class AddToolsListMessageModifier extends base_1.BaseMessageModifier {
+    constructor(options = {}) {
+        super({ context: options });
+        this.toolsList = options.toolsList;
+        this.addToolsLocation = options.addToolsLocation || 'SystemMessage';
+        this.giveToolExamples = options.giveToolExamples || false;
+        this.maxToolExamples = options.maxToolExamples || 2;
+        this.includeToolDescriptions = options.includeToolDescriptions !== false; // default true
+    }
+    async modify(originalRequest, createdMessage) {
+        try {
+            const toolsResponse = await codeboltjs_1.default.mcp.listMcpFromServers(['codebolt']);
+            const tools = (toolsResponse === null || toolsResponse === void 0 ? void 0 : toolsResponse.data) || [];
+            if (tools.length === 0) {
+                return createdMessage;
+            }
+            switch (this.addToolsLocation) {
+                case 'InsidePrompt':
+                    return this.addToolsInsidePrompt(createdMessage, tools);
+                case 'SystemMessage':
+                    return this.addToolsAsSystemMessage(createdMessage, tools);
+                case 'Tool':
+                    return this.addToolsAsToolCalls(createdMessage, tools);
+                default:
+                    return this.addToolsAsToolCalls(createdMessage, tools);
+            }
+        }
+        catch (error) {
+            console.error('Error in AddToolsListMessageModifier:', error);
+            throw error;
+        }
+    }
+    addToolsInsidePrompt(createdMessage, tools) {
+        const toolsInfo = this.generateToolsInfo(tools);
+        // Modify the last user message to include tools information
+        const modifiedMessages = createdMessage.message.messages.map((message, index) => {
+            if (message.role === 'user' && index === createdMessage.message.messages.length - 1) {
+                return {
+                    ...message,
+                    content: `${message.content}\n\n--- Available Tools ---\n${toolsInfo}`
+                };
+            }
+            return message;
+        });
+        return {
+            message: {
+                ...createdMessage.message,
+                messages: modifiedMessages
+            },
+            metadata: {
+                ...createdMessage.metadata,
+                toolsListAdded: true,
+                toolsLocation: 'InsidePrompt',
+                toolsCount: tools.length
+            }
+        };
+    }
+    addToolsAsSystemMessage(createdMessage, tools) {
+        const toolsInfo = this.generateToolsInfo(tools);
+        const toolsMessage = {
+            role: 'system',
+            content: `Available Tools:\n${toolsInfo}`
+        };
+        return {
+            message: {
+                ...createdMessage.message,
+                messages: [toolsMessage, ...createdMessage.message.messages]
+            },
+            metadata: {
+                ...createdMessage.metadata,
+                toolsListAdded: true,
+                toolsLocation: 'SystemMessage',
+                toolsCount: tools.length
+            }
+        };
+    }
+    addToolsAsToolCalls(createdMessage, tools) {
+        return {
+            message: {
+                ...createdMessage.message,
+                tools,
+                tool_choice: 'auto'
+            },
+            metadata: {
+                ...createdMessage.metadata,
+                toolsListAdded: true,
+                toolsLocation: 'Tool',
+                toolsCount: tools.length
+            }
+        };
+    }
+    generateToolsInfo(tools) {
+        const toolsInfo = [];
+        tools.forEach((tool, index) => {
+            let toolInfo = `${index + 1}. **${tool.function.name}**`;
+            if (this.includeToolDescriptions && tool.function.description) {
+                toolInfo += `\n   Description: ${tool.function.description}`;
+            }
+            if (tool.function.parameters) {
+                const params = typeof tool.function.parameters === 'object'
+                    ? Object.keys(tool.function.parameters).join(', ')
+                    : String(tool.function.parameters);
+                toolInfo += `\n   Parameters: ${params}`;
+            }
+            if (this.giveToolExamples && index < this.maxToolExamples) {
+                const example = this.generateToolExample(tool);
+                if (example) {
+                    toolInfo += `\n   Example: ${example}`;
+                }
+            }
+            toolsInfo.push(toolInfo);
+        });
+        return toolsInfo.join('\n\n');
+    }
+    generateToolExample(tool) {
+        // Generate simple examples based on tool name
+        const toolName = tool.function.name.toLowerCase();
+        if (toolName.includes('read') && toolName.includes('file')) {
+            return `${tool.function.name}({ filePath: "example.txt" })`;
+        }
+        if (toolName.includes('write') && toolName.includes('file')) {
+            return `${tool.function.name}({ filePath: "output.txt", content: "Hello World" })`;
+        }
+        if (toolName.includes('delete') && toolName.includes('file')) {
+            return `${tool.function.name}({ filePath: "temp.txt" })`;
+        }
+        if (toolName.includes('move') && toolName.includes('file')) {
+            return `${tool.function.name}({ sourcePath: "old.txt", destinationPath: "new.txt" })`;
+        }
+        if (toolName.includes('copy') && toolName.includes('file')) {
+            return `${tool.function.name}({ sourcePath: "source.txt", destinationPath: "copy.txt" })`;
+        }
+        // Generic example
+        return `${tool.function.name}({ /* parameters */ })`;
+    }
+}
+exports.AddToolsListMessageModifier = AddToolsListMessageModifier;

package/dist/processor-pieces/messageModifiers/advancedSystemInstructionMessageModifier.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 AdvancedSystemInstructionMessageModifier extends BaseMessageModifier {
+    private readonly systemInstruction;
+    constructor(systemInstruction?: string);
+    modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
+    private getAdvancedSystemPrompt;
+}

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

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdvancedSystemInstructionMessageModifier = void 0;
+const base_1 = require("../base");
+class AdvancedSystemInstructionMessageModifier extends base_1.BaseMessageModifier {
+    constructor(systemInstruction) {
+        super();
+        this.systemInstruction = systemInstruction || this.getAdvancedSystemPrompt();
+    }
+    async modify(originalRequest, createdMessage) {
+        try {
+            const systemMessage = {
+                role: 'system',
+                content: this.systemInstruction
+            };
+            const messages = [...(createdMessage.message.messages || [])];
+            const existingSystemIndex = messages.findIndex(msg => msg.role === 'system');
+            if (existingSystemIndex !== -1) {
+                messages[existingSystemIndex] = systemMessage;
+            }
+            else {
+                messages.unshift(systemMessage);
+            }
+            return {
+                message: {
+                    ...createdMessage.message,
+                    messages
+                },
+                metadata: {
+                    ...createdMessage.metadata
+                }
+            };
+        }
+        catch (error) {
+            console.error('Error in AdvancedSystemInstructionMessageModifier:', error);
+            throw error;
+        }
+    }
+    getAdvancedSystemPrompt() {
+        const advancedPrompt = `
+You are an advanced AI software engineering assistant with expertise in multiple programming languages, frameworks, and best practices. Your primary goal is to assist users efficiently and safely while adhering to the following guidelines:
+
+1. Code Quality and Best Practices:
+   - Write clean, efficient, and maintainable code
+   - Follow SOLID principles and design patterns when appropriate
+   - Implement proper error handling and logging
+   - Write unit tests for new functionality
+   - Ensure code is secure and follows cybersecurity best practices
+
+2. Project-Specific Considerations:
+   - Analyze and adhere to existing project structure, naming conventions, and coding style
+   - Use established libraries and frameworks within the project
+   - Consider scalability and performance implications of changes
+   - Maintain backward compatibility unless explicitly instructed otherwise
+
+3. Communication and Collaboration:
+   - Provide clear, concise explanations for your decisions and implementations
+   - Ask clarifying questions when requirements are ambiguous
+   - Suggest improvements or alternatives when appropriate
+   - Break down complex tasks into manageable steps
+
+4. Continuous Learning and Adaptation:
+   - Stay updated on latest industry trends and best practices
+   - Adapt your approach based on user feedback and project requirements
+   - Recommend modern tools and techniques when beneficial to the project
+
+5. Ethical Considerations:
+   - Respect intellectual property rights and licensing
+   - Avoid implementing features that could be used maliciously
+   - Promote inclusive and accessible code practices
+
+Remember to use the provided tools effectively, always prioritize user safety and project integrity, and strive for excellence in every task you undertake.
+`.trim();
+        return advancedPrompt;
+    }
+}
+exports.AdvancedSystemInstructionMessageModifier = AdvancedSystemInstructionMessageModifier;

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

@@ -0,0 +1,13 @@
+import { ProcessedMessage } from "@codebolt/types/agent";
+import { BaseMessageModifier } from "../base";
+import { FlatUserMessage } from "@codebolt/types/sdk";
+export interface ArgumentProcessorOptions {
+    appendRawInvocation?: boolean;
+    argumentSeparator?: string;
+    includeCommandName?: boolean;
+}
+export declare class ArgumentProcessorModifier extends BaseMessageModifier {
+    private readonly options;
+    constructor(options?: ArgumentProcessorOptions);
+    modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
+}

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

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArgumentProcessorModifier = void 0;
+const base_1 = require("../base");
+class ArgumentProcessorModifier extends base_1.BaseMessageModifier {
+    constructor(options = {}) {
+        super();
+        this.options = {
+            appendRawInvocation: options.appendRawInvocation !== false,
+            argumentSeparator: options.argumentSeparator || ' ',
+            includeCommandName: options.includeCommandName || false
+        };
+    }
+    modify(originalRequest, createdMessage) {
+        var _a;
+        try {
+            // Get arguments from metadata
+            const invocation = (_a = createdMessage.metadata) === null || _a === void 0 ? void 0 : _a.invocation;
+            if (!(invocation === null || invocation === void 0 ? void 0 : invocation.args)) {
+                return Promise.resolve(createdMessage);
+            }
+            // Find the user message to append arguments to
+            const userMessage = createdMessage.message.messages.find(msg => msg.role === 'user');
+            if (!userMessage || typeof userMessage.content !== 'string') {
+                return Promise.resolve(createdMessage);
+            }
+            let appendContent = '';
+            if (this.options.appendRawInvocation && invocation.raw) {
+                // Append the full raw command invocation
+                appendContent = `\n\nFull command: ${invocation.raw}`;
+            }
+            else {
+                // Append just the arguments
+                let argsToAppend = invocation.args;
+                if (this.options.includeCommandName && invocation.name) {
+                    argsToAppend = `${invocation.name}${this.options.argumentSeparator}${argsToAppend}`;
+                }
+                appendContent = `\n\nArguments: ${argsToAppend}`;
+            }
+            // Update the user message with appended arguments
+            const updatedMessages = createdMessage.message.messages.map(msg => {
+                if (msg.role === 'user' && typeof msg.content === 'string' && msg === userMessage) {
+                    return {
+                        ...msg,
+                        content: msg.content + appendContent
+                    };
+                }
+                return msg;
+            });
+            return Promise.resolve({
+                message: {
+                    ...createdMessage.message,
+                    messages: updatedMessages
+                },
+                metadata: {
+                    ...createdMessage.metadata,
+                    argumentsProcessed: true,
+                    argumentsAppended: appendContent.trim()
+                }
+            });
+        }
+        catch (error) {
+            console.error('Error in ArgumentProcessorModifier:', error);
+            return Promise.resolve(createdMessage);
+        }
+    }
+}
+exports.ArgumentProcessorModifier = ArgumentProcessorModifier;

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

@@ -0,0 +1,25 @@
+import { ProcessedMessage } from "@codebolt/types/agent";
+import { BaseMessageModifier } from "../base";
+import { FlatUserMessage } from "@codebolt/types/sdk";
+export interface AtFileProcessorOptions {
+    maxFileSize?: number;
+    allowedExtensions?: string[];
+    enableRecursiveSearch?: boolean;
+}
+export declare class AtFileProcessorModifier extends BaseMessageModifier {
+    private readonly options;
+    constructor(options?: AtFileProcessorOptions);
+    modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
+    private processMentionedPaths;
+    private buildContentParts;
+    private resolvePath;
+    private globSearch;
+    private findFiles;
+    private readManyFiles;
+    private readFileContent;
+    private getFilesInFolder;
+    private getFolderStructure;
+    private findLastUserMessage;
+    private getProjectPath;
+    private isNodeError;
+}