@codebolt/agent 1.1.0 → 2.2.2

package/dist/processor/types/interfaces.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,12 @@
+/**
+ * Base Message Modifier Class
+ * Abstract base class for all message modifiers
+ * Message modifiers convert user messages to prompts for the LLM
+ */
+import { MessageModifier, MessageModifierOptions, ProcessedMessage } from '@codebolt/types/agent';
+import { FlatUserMessage } from '@codebolt/types/sdk';
+export declare abstract class BaseMessageModifier implements MessageModifier {
+    protected context: Record<string, unknown>;
+    constructor(options?: MessageModifierOptions);
+    abstract modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
+}

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

@@ -0,0 +1,15 @@
+"use strict";
+/**
+ * Base Message Modifier Class
+ * Abstract base class for all message modifiers
+ * Message modifiers convert user messages to prompts for the LLM
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseMessageModifier = void 0;
+class BaseMessageModifier {
+    constructor(options = {}) {
+        this.context = {};
+        this.context = options.context || {};
+    }
+}
+exports.BaseMessageModifier = BaseMessageModifier;

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

@@ -0,0 +1,13 @@
+/**
+ * Base Post-Inference Processor Class
+ * Abstract base class for all post-inference processors
+ * These are called after the LLM is called and we have gotten the response
+ * This is before the actual Tool Call is done
+ */
+import { PostInferenceProcessor, ProcessedMessage } from '@codebolt/types/agent';
+import { LLMResponse } from '@codebolt/types/sdk';
+export declare abstract class BasePostInferenceProcessor implements PostInferenceProcessor {
+    protected context: Record<string, unknown>;
+    constructor();
+    abstract modify(llmMessageSent: ProcessedMessage, llmResponseMessage: LLMResponse, nextPrompt: ProcessedMessage): Promise<ProcessedMessage>;
+}

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

@@ -0,0 +1,18 @@
+"use strict";
+/**
+ * Base Post-Inference Processor Class
+ * Abstract base class for all post-inference processors
+ * These are called after the LLM is called and we have gotten the response
+ * This is before the actual Tool Call is done
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BasePostInferenceProcessor = void 0;
+class BasePostInferenceProcessor {
+    // constructor(options: PostInferenceProcessorOptions = {}) {
+    //     this.context = options.context || {};
+    // }
+    constructor() {
+        this.context = {};
+    }
+}
+exports.BasePostInferenceProcessor = BasePostInferenceProcessor;

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

@@ -0,0 +1,15 @@
+/**
+ * Base Post-Tool Call Processor Class
+ * Abstract base class for all post-tool call processors
+ * These are called after the Tool Call
+ * Help in checking the tool call results and adding them to the LLM message
+ */
+import { PostToolCallProcessor, PostToolCallProcessorInput, PostToolCallProcessorOutput } from '@codebolt/types/agent';
+export declare abstract class BasePostToolCallProcessor implements PostToolCallProcessor {
+    protected context: Record<string, unknown>;
+    constructor();
+    abstract modify(input: PostToolCallProcessorInput): Promise<PostToolCallProcessorOutput>;
+    setContext(key: string, value: unknown): void;
+    getContext(key: string): unknown;
+    clearContext(): void;
+}

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

@@ -0,0 +1,25 @@
+"use strict";
+/**
+ * Base Post-Tool Call Processor Class
+ * Abstract base class for all post-tool call processors
+ * These are called after the Tool Call
+ * Help in checking the tool call results and adding them to the LLM message
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BasePostToolCallProcessor = void 0;
+class BasePostToolCallProcessor {
+    constructor() {
+        this.context = {};
+        // this.context = options.context || {};
+    }
+    setContext(key, value) {
+        this.context[key] = value;
+    }
+    getContext(key) {
+        return this.context[key];
+    }
+    clearContext() {
+        this.context = {};
+    }
+}
+exports.BasePostToolCallProcessor = BasePostToolCallProcessor;

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

@@ -0,0 +1,12 @@
+/**
+ * Base Pre-Inference Processor Class
+ * Abstract base class for all pre-inference processors
+ * These are called before the Agent calls the LLM
+ */
+import { PreInferenceProcessor, ProcessedMessage } from '@codebolt/types/agent';
+import { FlatUserMessage } from '@codebolt/types/sdk';
+export declare abstract class BasePreInferenceProcessor implements PreInferenceProcessor {
+    protected context: Record<string, unknown>;
+    constructor();
+    abstract modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
+}

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

@@ -0,0 +1,17 @@
+"use strict";
+/**
+ * Base Pre-Inference Processor Class
+ * Abstract base class for all pre-inference processors
+ * These are called before the Agent calls the LLM
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BasePreInferenceProcessor = void 0;
+class BasePreInferenceProcessor {
+    // constructor(options: PreInferenceProcessorOptions = {}) {
+    //     this.context = options.context || {};
+    // }
+    constructor() {
+        this.context = {};
+    }
+}
+exports.BasePreInferenceProcessor = BasePreInferenceProcessor;

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

@@ -0,0 +1,18 @@
+/**
+ * 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
+ */
+import { PreToolCallProcessor, PreToolCallProcessorInput, PreToolCallProcessorOutput, InterceptedTool, ToolValidationRule, ToolValidationResult, ToolCall } from '@codebolt/types/agent';
+export declare abstract class BasePreToolCallProcessor implements PreToolCallProcessor {
+    protected context: Record<string, unknown>;
+    constructor();
+    abstract modify(input: PreToolCallProcessorInput): Promise<PreToolCallProcessorOutput>;
+    interceptTool?(_toolName: string, _toolInput: unknown): Promise<boolean>;
+    setContext(key: string, value: unknown): void;
+    getContext(key: string): unknown;
+    clearContext(): void;
+    protected createInterceptedTool(toolName: string, originalInput: unknown, result?: unknown, reason?: string): InterceptedTool;
+    protected validateToolCall(toolCall: ToolCall, validationRules: ToolValidationRule[]): ToolValidationResult;
+}

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/addToolsListMessageModifier.d.ts

@@ -0,0 +1,22 @@
+import { BaseMessageModifier, MessageModifierInput, ProcessedMessage, ToolList } from '../../processor';
+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(input: MessageModifierInput): Promise<ProcessedMessage>;
+    private addToolsInsidePrompt;
+    private addToolsAsSystemMessage;
+    private addToolsAsToolCalls;
+    private generateToolsInfo;
+    private generateToolExample;
+}

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

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AddToolsListMessageModifier = void 0;
+const processor_1 = require("../../processor");
+class AddToolsListMessageModifier extends processor_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(input) {
+        try {
+            const { originalRequest, createdMessage, context } = input;
+            const tools = this.toolsList.getAllTools();
+            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 createdMessage;
+            }
+        }
+        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.messages.map((message, index) => {
+            if (message.role === 'user' && index === createdMessage.messages.length - 1) {
+                return {
+                    ...message,
+                    content: `${message.content}\n\n--- Available Tools ---\n${toolsInfo}`
+                };
+            }
+            return message;
+        });
+        return {
+            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}`,
+            name: 'tools-list'
+        };
+        return {
+            messages: [toolsMessage, ...createdMessage.messages],
+            metadata: {
+                ...createdMessage.metadata,
+                toolsListAdded: true,
+                toolsLocation: 'SystemMessage',
+                toolsCount: tools.length
+            }
+        };
+    }
+    addToolsAsToolCalls(createdMessage, tools) {
+        // This would create a message that lists tools as available tool calls
+        const toolsMessage = {
+            role: 'assistant',
+            content: 'I have access to the following tools:',
+            tool_calls: tools.map((tool, index) => ({
+                id: `tool-info-${index}`,
+                function: {
+                    name: tool.name,
+                    arguments: tool.parameters || {}
+                }
+            }))
+        };
+        return {
+            messages: [...createdMessage.messages, toolsMessage],
+            metadata: {
+                ...createdMessage.metadata,
+                toolsListAdded: true,
+                toolsLocation: 'Tool',
+                toolsCount: tools.length
+            }
+        };
+    }
+    generateToolsInfo(tools) {
+        const toolsInfo = [];
+        tools.forEach((tool, index) => {
+            let toolInfo = `${index + 1}. **${tool.name}**`;
+            if (this.includeToolDescriptions && tool.description) {
+                toolInfo += `\n   Description: ${tool.description}`;
+            }
+            if (tool.parameters) {
+                const params = typeof tool.parameters === 'object'
+                    ? Object.keys(tool.parameters).join(', ')
+                    : String(tool.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.name.toLowerCase();
+        if (toolName.includes('read') && toolName.includes('file')) {
+            return `${tool.name}({ filePath: "example.txt" })`;
+        }
+        if (toolName.includes('write') && toolName.includes('file')) {
+            return `${tool.name}({ filePath: "output.txt", content: "Hello World" })`;
+        }
+        if (toolName.includes('delete') && toolName.includes('file')) {
+            return `${tool.name}({ filePath: "temp.txt" })`;
+        }
+        if (toolName.includes('move') && toolName.includes('file')) {
+            return `${tool.name}({ sourcePath: "old.txt", destinationPath: "new.txt" })`;
+        }
+        if (toolName.includes('copy') && toolName.includes('file')) {
+            return `${tool.name}({ sourcePath: "source.txt", destinationPath: "copy.txt" })`;
+        }
+        // Generic example
+        return `${tool.name}({ /* parameters */ })`;
+    }
+}
+exports.AddToolsListMessageModifier = AddToolsListMessageModifier;

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;
+}