@codebolt/agent 1.2.1 → 2.2.2

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

@@ -0,0 +1,222 @@
+"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.ImageAttachmentMessageModifier = void 0;
+const processor_1 = require("../../processor");
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+class ImageAttachmentMessageModifier extends processor_1.BaseMessageModifier {
+    constructor(options = {}) {
+        super({ context: options });
+        this.passImageAs = options.passImageAs || 'URL';
+        this.supportedFormats = options.supportedFormats || ['.png', '.jpg', '.jpeg', '.gif', '.webp', '.bmp'];
+        this.maxImageSize = options.maxImageSize || 10 * 1024 * 1024; // 10MB default
+    }
+    async modify(input) {
+        try {
+            const { originalRequest, createdMessage, context } = input;
+            // Extract image references from the request
+            const imageReferences = this.extractImageReferences(originalRequest);
+            if (imageReferences.length === 0) {
+                return createdMessage;
+            }
+            const processedImages = [];
+            for (const imageRef of imageReferences) {
+                try {
+                    const processedImage = await this.processImage(imageRef);
+                    if (processedImage) {
+                        processedImages.push(processedImage);
+                    }
+                }
+                catch (error) {
+                    console.error(`Error processing image ${imageRef}:`, error);
+                }
+            }
+            if (processedImages.length === 0) {
+                return createdMessage;
+            }
+            // Add image context message
+            const imageContextMessage = {
+                role: 'system',
+                content: `Images attached to this conversation (${this.passImageAs} format):\n${processedImages.map((img, idx) => `${idx + 1}. ${img.description || img.reference}`).join('\n')}`,
+                name: 'image-attachments'
+            };
+            // Modify user messages to include image references
+            const modifiedMessages = createdMessage.messages.map(message => {
+                if (message.role === 'user') {
+                    return {
+                        ...message,
+                        attachments: processedImages
+                    };
+                }
+                return message;
+            });
+            return {
+                messages: [imageContextMessage, ...modifiedMessages],
+                metadata: {
+                    ...createdMessage.metadata,
+                    imagesAttached: processedImages.length,
+                    imageFormat: this.passImageAs,
+                    processedImages
+                }
+            };
+        }
+        catch (error) {
+            console.error('Error in ImageAttachmentMessageModifier:', error);
+            throw error;
+        }
+    }
+    extractImageReferences(request) {
+        const imageRefs = [];
+        if (typeof request === 'string') {
+            // Look for image file paths or URLs
+            const imageRegex = /(?:\.png|\.jpg|\.jpeg|\.gif|\.webp|\.bmp|https?:\/\/[^\s]+\.(?:png|jpg|jpeg|gif|webp|bmp))/gi;
+            const matches = request.match(imageRegex);
+            if (matches) {
+                imageRefs.push(...matches);
+            }
+        }
+        if (typeof request === 'object' && request !== null) {
+            // Look for image properties in the request object
+            const searchForImages = (obj) => {
+                if (Array.isArray(obj)) {
+                    obj.forEach(searchForImages);
+                }
+                else if (typeof obj === 'object' && obj !== null) {
+                    Object.values(obj).forEach(value => {
+                        if (typeof value === 'string' && this.isImagePath(value)) {
+                            imageRefs.push(value);
+                        }
+                        else if (typeof value === 'object') {
+                            searchForImages(value);
+                        }
+                    });
+                }
+            };
+            searchForImages(request);
+        }
+        return [...new Set(imageRefs)]; // Remove duplicates
+    }
+    isImagePath(str) {
+        const ext = path.extname(str).toLowerCase();
+        return this.supportedFormats.includes(ext) || /^https?:\/\/[^\s]+\.(?:png|jpg|jpeg|gif|webp|bmp)/i.test(str);
+    }
+    async processImage(imageRef) {
+        try {
+            if (imageRef.startsWith('http')) {
+                // URL image
+                return this.processUrlImage(imageRef);
+            }
+            else {
+                // Local file path
+                return this.processLocalImage(imageRef);
+            }
+        }
+        catch (error) {
+            console.error(`Error processing image ${imageRef}:`, error);
+            return null;
+        }
+    }
+    async processUrlImage(url) {
+        switch (this.passImageAs) {
+            case 'URL':
+                return {
+                    type: 'url',
+                    reference: url,
+                    description: `Image from URL: ${url}`
+                };
+            case 'Base64':
+                // In a real implementation, you would fetch and convert to base64
+                return {
+                    type: 'base64',
+                    reference: url,
+                    description: `Image from URL (would be converted to base64): ${url}`,
+                    note: 'Base64 conversion not implemented for URLs in this demo'
+                };
+            case 'Path':
+                return {
+                    type: 'path',
+                    reference: url,
+                    description: `Image URL: ${url}`
+                };
+            default:
+                return null;
+        }
+    }
+    async processLocalImage(filePath) {
+        try {
+            // Check if file exists and get stats
+            const stats = await fs.stat(filePath);
+            if (stats.size > this.maxImageSize) {
+                console.warn(`Image ${filePath} is too large (${stats.size} bytes)`);
+                return null;
+            }
+            switch (this.passImageAs) {
+                case 'Path':
+                    return {
+                        type: 'path',
+                        reference: filePath,
+                        description: `Local image: ${path.basename(filePath)}`,
+                        size: stats.size
+                    };
+                case 'Base64':
+                    const imageBuffer = await fs.readFile(filePath);
+                    const base64 = imageBuffer.toString('base64');
+                    const ext = path.extname(filePath).substring(1);
+                    return {
+                        type: 'base64',
+                        reference: `data:image/${ext};base64,${base64}`,
+                        description: `Local image (base64): ${path.basename(filePath)}`,
+                        size: stats.size
+                    };
+                case 'URL':
+                    // Convert local path to file:// URL
+                    return {
+                        type: 'url',
+                        reference: `file://${path.resolve(filePath)}`,
+                        description: `Local image (file URL): ${path.basename(filePath)}`,
+                        size: stats.size
+                    };
+                default:
+                    return null;
+            }
+        }
+        catch (error) {
+            console.error(`Error processing local image ${filePath}:`, error);
+            return null;
+        }
+    }
+}
+exports.ImageAttachmentMessageModifier = ImageAttachmentMessageModifier;

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

@@ -0,0 +1,11 @@
+export { EnvironmentContextModifier, type EnvironmentContextOptions } from './environmentContextModifier';
+export { CoreSystemPromptModifier, type CoreSystemPromptOptions } from './coreSystemPromptModifier';
+export { DirectoryContextModifier, type DirectoryContextOptions } from './directoryContextModifier';
+export { IdeContextModifier, type IdeContextOptions, type FileInfo, type IdeContext } from './ideContextModifier';
+export { AtFileProcessorModifier, type AtFileProcessorOptions } from './atFileProcessorModifier';
+export { ArgumentProcessorModifier, type ArgumentProcessorOptions } from './argumentProcessorModifier';
+export { MemoryImportModifier, type MemoryImportOptions } from './memoryImportModifier';
+export { LoopDetectionModifier, type LoopDetectionOptions } from '../postInferenceProcessors/loopDetectionModifier';
+export { ToolInjectionModifier, type ToolInjectionOptions } from './toolInjectionModifier';
+export { ChatRecordingModifier, type ChatRecordingOptions } from './chatRecordingModifier';
+export { ChatHistoryMessageModifier, type ChatHistoryMessageModifierOptions } from './chatHistoryMessageModifier';

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatHistoryMessageModifier = exports.ChatRecordingModifier = exports.ToolInjectionModifier = exports.LoopDetectionModifier = exports.MemoryImportModifier = exports.ArgumentProcessorModifier = exports.AtFileProcessorModifier = exports.IdeContextModifier = exports.DirectoryContextModifier = exports.CoreSystemPromptModifier = exports.EnvironmentContextModifier = void 0;
+// Gemini-CLI equivalent modifiers
+var environmentContextModifier_1 = require("./environmentContextModifier");
+Object.defineProperty(exports, "EnvironmentContextModifier", { enumerable: true, get: function () { return environmentContextModifier_1.EnvironmentContextModifier; } });
+var coreSystemPromptModifier_1 = require("./coreSystemPromptModifier");
+Object.defineProperty(exports, "CoreSystemPromptModifier", { enumerable: true, get: function () { return coreSystemPromptModifier_1.CoreSystemPromptModifier; } });
+var directoryContextModifier_1 = require("./directoryContextModifier");
+Object.defineProperty(exports, "DirectoryContextModifier", { enumerable: true, get: function () { return directoryContextModifier_1.DirectoryContextModifier; } });
+var ideContextModifier_1 = require("./ideContextModifier");
+Object.defineProperty(exports, "IdeContextModifier", { enumerable: true, get: function () { return ideContextModifier_1.IdeContextModifier; } });
+var atFileProcessorModifier_1 = require("./atFileProcessorModifier");
+Object.defineProperty(exports, "AtFileProcessorModifier", { enumerable: true, get: function () { return atFileProcessorModifier_1.AtFileProcessorModifier; } });
+var argumentProcessorModifier_1 = require("./argumentProcessorModifier");
+Object.defineProperty(exports, "ArgumentProcessorModifier", { enumerable: true, get: function () { return argumentProcessorModifier_1.ArgumentProcessorModifier; } });
+var memoryImportModifier_1 = require("./memoryImportModifier");
+Object.defineProperty(exports, "MemoryImportModifier", { enumerable: true, get: function () { return memoryImportModifier_1.MemoryImportModifier; } });
+var loopDetectionModifier_1 = require("../postInferenceProcessors/loopDetectionModifier");
+Object.defineProperty(exports, "LoopDetectionModifier", { enumerable: true, get: function () { return loopDetectionModifier_1.LoopDetectionModifier; } });
+var toolInjectionModifier_1 = require("./toolInjectionModifier");
+Object.defineProperty(exports, "ToolInjectionModifier", { enumerable: true, get: function () { return toolInjectionModifier_1.ToolInjectionModifier; } });
+var chatRecordingModifier_1 = require("./chatRecordingModifier");
+Object.defineProperty(exports, "ChatRecordingModifier", { enumerable: true, get: function () { return chatRecordingModifier_1.ChatRecordingModifier; } });
+var chatHistoryMessageModifier_1 = require("./chatHistoryMessageModifier");
+Object.defineProperty(exports, "ChatHistoryMessageModifier", { enumerable: true, get: function () { return chatHistoryMessageModifier_1.ChatHistoryMessageModifier; } });

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

@@ -0,0 +1,15 @@
+import { ProcessedMessage } from "@codebolt/types/agent";
+import { BaseMessageModifier } from "../base";
+import { FlatUserMessage } from "@codebolt/types/sdk";
+export interface MemoryImportOptions {
+    enableMemoryImport?: boolean;
+    maxFileSize?: number;
+    allowedExtensions?: string[];
+    basePath?: string;
+    maxImports?: number;
+}
+export declare class MemoryImportModifier extends BaseMessageModifier {
+    private readonly options;
+    constructor(options?: MemoryImportOptions);
+    modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
+}

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

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

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

@@ -0,0 +1,20 @@
+import { ProcessedMessage } from "@codebolt/types/agent";
+import { BaseMessageModifier } from "../base";
+import { FlatUserMessage } from "@codebolt/types/sdk";
+export interface ToolInjectionOptions {
+    toolsLocation?: 'Tool' | 'SystemMessage' | 'InsidePrompt';
+    includeToolDescriptions?: boolean;
+    maxToolsInMessage?: number;
+    giveToolExamples?: boolean;
+    maxToolExamples?: number;
+}
+export declare class ToolInjectionModifier extends BaseMessageModifier {
+    private readonly options;
+    constructor(options?: ToolInjectionOptions);
+    modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
+    private addToolsInsidePrompt;
+    private addToolsAsSystemMessage;
+    private addToolsAsToolCalls;
+    private generateToolsInfo;
+    private generateToolExample;
+}

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

@@ -0,0 +1,152 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolInjectionModifier = void 0;
+const base_1 = require("../base");
+const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
+class ToolInjectionModifier extends base_1.BaseMessageModifier {
+    constructor(options = {}) {
+        super();
+        this.options = {
+            toolsLocation: options.toolsLocation || 'Tool',
+            includeToolDescriptions: options.includeToolDescriptions !== false,
+            maxToolsInMessage: options.maxToolsInMessage || 30,
+            giveToolExamples: options.giveToolExamples || false,
+            maxToolExamples: options.maxToolExamples || 2
+        };
+    }
+    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.options.toolsLocation) {
+                case 'InsidePrompt':
+                    //@ts-ignore
+                    return this.addToolsInsidePrompt(createdMessage, tools);
+                //@ts-ignore
+                case 'SystemMessage':
+                    //@ts-ignore
+                    return this.addToolsAsSystemMessage(createdMessage, tools);
+                case 'Tool':
+                    //@ts-ignore
+                    return this.addToolsAsToolCalls(createdMessage, tools);
+                default:
+                    //@ts-ignore
+                    return this.addToolsAsToolCalls(createdMessage, tools);
+            }
+        }
+        catch (error) {
+            console.error('Error in ToolInjectionModifier:', error);
+            return createdMessage;
+        }
+    }
+    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,
+                toolsInjected: 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,
+                toolsInjected: true,
+                toolsLocation: 'SystemMessage',
+                toolsCount: tools.length
+            }
+        };
+    }
+    addToolsAsToolCalls(createdMessage, tools) {
+        return {
+            message: {
+                ...createdMessage.message,
+                tools,
+                tool_choice: 'auto'
+            },
+            metadata: {
+                ...createdMessage.metadata,
+                toolsInjected: true,
+                toolsLocation: 'Tool',
+                toolsCount: tools.length
+            }
+        };
+    }
+    generateToolsInfo(tools) {
+        const toolsInfo = [];
+        tools.slice(0, this.options.maxToolsInMessage).forEach((tool, index) => {
+            let toolInfo = `${index + 1}. **${tool.function.name}**`;
+            if (this.options.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.options.giveToolExamples && index < this.options.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.ToolInjectionModifier = ToolInjectionModifier;

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

@@ -0,0 +1,22 @@
+import { BaseMessageModifier, MessageModifierInput, ProcessedMessage } from '../../processor';
+export interface WorkingDirectoryMessageModifierOptions {
+    showFolderStructureSummary?: boolean;
+    listFiles?: boolean;
+    listFilesDepth?: number;
+    listFilesLimit?: number;
+    listFilesIgnoreFromGitignore?: boolean;
+    listFilesIgnore?: string[];
+}
+export declare class WorkingDirectoryMessageModifier extends BaseMessageModifier {
+    private readonly showFolderStructureSummary;
+    private readonly listFiles;
+    private readonly listFilesDepth;
+    private readonly listFilesLimit;
+    private readonly listFilesIgnoreFromGitignore;
+    private readonly listFilesIgnore;
+    constructor(options?: WorkingDirectoryMessageModifierOptions);
+    modify(input: MessageModifierInput): Promise<ProcessedMessage>;
+    private generateFolderStructureSummary;
+    private generateFilesList;
+    private shouldIgnore;
+}