@codebolt/agent 5.0.8 → 5.0.9

package/dist/processor/types/interfaces.js

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

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

@@ -1,22 +0,0 @@
-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

@@ -1,144 +0,0 @@
-"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/baseContextMessageModifier.d.ts

@@ -1,15 +0,0 @@
-import { BaseMessageModifier, MessageModifierInput, ProcessedMessage } from '../../processor';
-export interface BaseContextMessageModifierOptions {
-    prependmessage?: string;
-    datetime?: boolean;
-    osInfo?: boolean;
-    workingdir?: boolean;
-}
-export declare class BaseContextMessageModifier extends BaseMessageModifier {
-    private readonly prependMessage;
-    private readonly includeDateTime;
-    private readonly includeOsInfo;
-    private readonly includeWorkingDir;
-    constructor(options?: BaseContextMessageModifierOptions);
-    modify(input: MessageModifierInput): Promise<ProcessedMessage>;
-}

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

@@ -1,75 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseContextMessageModifier = void 0;
-const processor_1 = require("../../processor");
-const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
-const os_1 = __importDefault(require("os"));
-class BaseContextMessageModifier extends processor_1.BaseMessageModifier {
-    constructor(options = {}) {
-        super({ context: options });
-        this.prependMessage = options.prependmessage || '';
-        this.includeDateTime = options.datetime || false;
-        this.includeOsInfo = options.osInfo || false;
-        this.includeWorkingDir = options.workingdir || false;
-    }
-    async modify(input) {
-        try {
-            const { originalRequest, createdMessage, context } = input;
-            const contextParts = [];
-            // Add prepend message if provided
-            if (this.prependMessage) {
-                contextParts.push(this.prependMessage);
-            }
-            // Add date/time if requested
-            if (this.includeDateTime) {
-                const now = new Date();
-                contextParts.push(`Current Date/Time: ${now.toISOString()}`);
-            }
-            // Add OS info if requested
-            if (this.includeOsInfo) {
-                const osInfo = {
-                    platform: os_1.default.platform(),
-                    arch: os_1.default.arch(),
-                    version: os_1.default.version(),
-                    hostname: os_1.default.hostname()
-                };
-                contextParts.push(`Operating System: ${JSON.stringify(osInfo, null, 2)}`);
-            }
-            // Add working directory if requested
-            if (this.includeWorkingDir) {
-                try {
-                    const projectPath = await codeboltjs_1.default.project.getProjectPath();
-                    contextParts.push(`Working Directory: ${projectPath}`);
-                }
-                catch (error) {
-                    contextParts.push(`Working Directory: ${process.cwd()}`);
-                }
-            }
-            // Create context message if we have any context parts
-            if (contextParts.length > 0) {
-                const contextMessage = {
-                    role: 'system',
-                    content: contextParts.join('\n\n'),
-                    name: 'base-context'
-                };
-                return {
-                    messages: [contextMessage, ...createdMessage.messages],
-                    metadata: {
-                        ...createdMessage.metadata,
-                        baseContextAdded: true,
-                        contextParts: contextParts.length
-                    }
-                };
-            }
-            return createdMessage;
-        }
-        catch (error) {
-            console.error('Error in BaseContextMessageModifier:', error);
-            throw error;
-        }
-    }
-}
-exports.BaseContextMessageModifier = BaseContextMessageModifier;

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

@@ -1,11 +0,0 @@
-import { BaseMessageModifier, MessageModifierInput, ProcessedMessage } from '../../processor';
-export interface BaseSystemInstructionMessageModifierOptions {
-    systemInstruction?: string;
-    position?: 'start' | 'end';
-}
-export declare class BaseSystemInstructionMessageModifier extends BaseMessageModifier {
-    private readonly systemInstruction;
-    private readonly position;
-    constructor(options?: BaseSystemInstructionMessageModifierOptions);
-    modify(input: MessageModifierInput): Promise<ProcessedMessage>;
-}

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

@@ -1,46 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseSystemInstructionMessageModifier = void 0;
-const processor_1 = require("../../processor");
-class BaseSystemInstructionMessageModifier extends processor_1.BaseMessageModifier {
-    constructor(options = {}) {
-        super({ context: options });
-        this.systemInstruction = options.systemInstruction || 'You are a helpful assistant.';
-        this.position = options.position || 'start';
-    }
-    async modify(input) {
-        try {
-            const { originalRequest, createdMessage, context } = input;
-            // Create system instruction message
-            const systemMessage = {
-                role: 'system',
-                content: this.systemInstruction,
-                name: 'system-instruction'
-            };
-            let messages;
-            if (this.position === 'start') {
-                // Add system instruction at the beginning
-                messages = [systemMessage, ...createdMessage.messages];
-            }
-            else {
-                // Add system instruction at the end (before user message)
-                const userMessages = createdMessage.messages.filter(m => m.role === 'user');
-                const otherMessages = createdMessage.messages.filter(m => m.role !== 'user');
-                messages = [...otherMessages, systemMessage, ...userMessages];
-            }
-            return {
-                messages,
-                metadata: {
-                    ...createdMessage.metadata,
-                    systemInstructionAdded: true,
-                    systemInstructionPosition: this.position
-                }
-            };
-        }
-        catch (error) {
-            console.error('Error in BaseSystemInstructionMessageModifier:', error);
-            throw error;
-        }
-    }
-}
-exports.BaseSystemInstructionMessageModifier = BaseSystemInstructionMessageModifier;

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

@@ -1,12 +0,0 @@
-import { BaseMessageModifier, MessageModifierInput, ProcessedMessage } from '../../processor';
-export interface HandleUrlMessageModifierOptions {
-    googleSearchEnabled?: boolean;
-    fetchUrlContent?: boolean;
-}
-export declare class HandleUrlMessageModifier extends BaseMessageModifier {
-    private readonly googleSearchEnabled;
-    private readonly fetchUrlContent;
-    constructor(options?: HandleUrlMessageModifierOptions);
-    modify(input: MessageModifierInput): Promise<ProcessedMessage>;
-    private extractUrls;
-}

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

@@ -1,60 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HandleUrlMessageModifier = void 0;
-const processor_1 = require("../../processor");
-class HandleUrlMessageModifier extends processor_1.BaseMessageModifier {
-    constructor(options = {}) {
-        super({ context: options });
-        this.googleSearchEnabled = options.googleSearchEnabled || false;
-        this.fetchUrlContent = options.fetchUrlContent || false;
-    }
-    async modify(input) {
-        try {
-            const { originalRequest, createdMessage, context } = input;
-            // Check if the request contains URLs
-            const urls = this.extractUrls(originalRequest);
-            if (urls.length > 0) {
-                let contextContent = `URLs detected: ${urls.join(', ')}. ${this.googleSearchEnabled ? 'Google search is enabled.' : 'Google search is disabled.'}`;
-                // Fetch URL content if enabled
-                if (this.fetchUrlContent) {
-                    contextContent += '\n\nURL Content Fetching: Enabled (content would be fetched in a real implementation)';
-                    // In a real implementation, you would fetch the content here
-                    // const urlContents = await Promise.all(urls.map(url => this.fetchContent(url)));
-                }
-                // Add URL context to the message
-                const urlContextMessage = {
-                    role: 'system',
-                    content: contextContent,
-                    name: 'url-detector'
-                };
-                return {
-                    messages: [...createdMessage.messages, urlContextMessage],
-                    metadata: {
-                        ...createdMessage.metadata,
-                        urlsDetected: urls,
-                        googleSearchEnabled: this.googleSearchEnabled,
-                        fetchUrlContent: this.fetchUrlContent
-                    }
-                };
-            }
-            return createdMessage;
-        }
-        catch (error) {
-            console.error('Error in HandleUrlMessageModifier:', error);
-            throw error;
-        }
-    }
-    extractUrls(request) {
-        if (typeof request === 'string') {
-            const urlRegex = /https?:\/\/[^\s]+/g;
-            return request.match(urlRegex) || [];
-        }
-        if (typeof request === 'object' && request !== null) {
-            const requestString = JSON.stringify(request);
-            const urlRegex = /https?:\/\/[^\s]+/g;
-            return requestString.match(urlRegex) || [];
-        }
-        return [];
-    }
-}
-exports.HandleUrlMessageModifier = HandleUrlMessageModifier;

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

@@ -1,18 +0,0 @@
-import { BaseMessageModifier, MessageModifierInput, ProcessedMessage } from '../../processor';
-export interface ImageAttachmentMessageModifierOptions {
-    passImageAs?: 'URL' | 'Base64' | 'Path';
-    supportedFormats?: string[];
-    maxImageSize?: number;
-}
-export declare class ImageAttachmentMessageModifier extends BaseMessageModifier {
-    private readonly passImageAs;
-    private readonly supportedFormats;
-    private readonly maxImageSize;
-    constructor(options?: ImageAttachmentMessageModifierOptions);
-    modify(input: MessageModifierInput): Promise<ProcessedMessage>;
-    private extractImageReferences;
-    private isImagePath;
-    private processImage;
-    private processUrlImage;
-    private processLocalImage;
-}

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

@@ -1,222 +0,0 @@
-"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/workingDirectoryMessageModifier.d.ts

@@ -1,22 +0,0 @@
-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;
-}