@codebolt/agent 5.0.2 → 5.0.7

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

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

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

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

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

@@ -1,93 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CoreSystemPromptModifier = void 0;
-const base_1 = require("../base");
-class CoreSystemPromptModifier extends base_1.BaseMessageModifier {
-    constructor(options = {}) {
-        super();
-        this.options = options;
-    }
-    modify(originalRequest, createdMessage) {
-        var _a;
-        // Get user memory from metadata or options
-        const userMemory = ((_a = createdMessage.metadata) === null || _a === void 0 ? void 0 : _a.userMemory) || this.options.userMemory;
-        const systemPrompt = this.options.customSystemPrompt || this.getCoreSystemPrompt(userMemory);
-        const systemMessage = {
-            role: 'system',
-            content: systemPrompt
-        };
-        // Find existing system message or add new one
-        const messages = [...createdMessage.message.messages];
-        const systemMessageIndex = messages.findIndex(msg => msg.role === 'system');
-        if (systemMessageIndex !== -1) {
-            // Replace existing system message
-            messages[systemMessageIndex] = systemMessage;
-        }
-        else {
-            // Add new system message at the beginning
-            messages.unshift(systemMessage);
-        }
-        return Promise.resolve({
-            message: {
-                ...createdMessage.message,
-                messages
-            },
-            metadata: {
-                ...createdMessage.metadata,
-                coreSystemPromptAdded: true,
-                systemPromptSource: this.options.customSystemPrompt ? 'custom' : 'default',
-                hasUserMemory: !!userMemory
-            }
-        });
-    }
-    getCoreSystemPrompt(userMemory) {
-        const basePrompt = this.getDefaultSystemPrompt();
-        // Add user memory with separator if provided (exactly like gemini-cli)
-        const memorySuffix = userMemory && userMemory.trim().length > 0
-            ? `\n\n---\n\n${userMemory.trim()}`
-            : '';
-        return `${basePrompt}${memorySuffix}`;
-    }
-    getDefaultSystemPrompt() {
-        return `
-You are an interactive AI agent specializing in software engineering tasks. Your primary goal is to help users safely and efficiently, adhering strictly to the following instructions and utilizing your available tools.
-
-# Core Mandates
-
-- **Conventions:** Rigorously adhere to existing project conventions when reading or modifying code. Analyze surrounding code, tests, and configuration first.
-- **Libraries/Frameworks:** NEVER assume a library/framework is available or appropriate. Verify its established usage within the project before employing it.
-- **Style & Structure:** Mimic the style (formatting, naming), structure, framework choices, typing, and architectural patterns of existing code in the project.
-- **Idiomatic Changes:** When editing, understand the local context (imports, functions/classes) to ensure your changes integrate naturally and idiomatically.
-- **Comments:** Add code comments sparingly. Focus on *why* something is done, especially for complex logic, rather than *what* is done.
-- **Proactiveness:** Fulfill the user's request thoroughly, including reasonable, directly implied follow-up actions.
-- **Confirm Ambiguity/Expansion:** Do not take significant actions beyond the clear scope of the request without confirming with the user.
-- **Explaining Changes:** After completing a code modification or file operation *do not* provide summaries unless asked.
-
-# Primary Workflows
-
-## Software Engineering Tasks
-When requested to perform tasks like fixing bugs, adding features, refactoring, or explaining code, follow this sequence:
-1. **Understand:** Think about the user's request and the relevant codebase context. Use search tools extensively to understand file structures, existing code patterns, and conventions.
-2. **Plan:** Build a coherent and grounded plan for how you intend to resolve the user's task. Share a concise yet clear plan with the user if it would help.
-3. **Implement:** Use the available tools to act on the plan, strictly adhering to the project's established conventions.
-4. **Verify:** If applicable and feasible, verify the changes using the project's testing procedures and build/lint commands.
-
-# Operational Guidelines
-
-## Tone and Style
-- **Concise & Direct:** Adopt a professional, direct, and concise tone.
-- **Minimal Output:** Aim for fewer than 3 lines of text output per response whenever practical.
-- **Clarity over Brevity:** While conciseness is key, prioritize clarity for essential explanations.
-- **No Chitchat:** Avoid conversational filler. Get straight to the action or answer.
-- **Formatting:** Use GitHub-flavored Markdown.
-
-## Security and Safety Rules
-- **Security First:** Always apply security best practices. Never introduce code that exposes, logs, or commits secrets, API keys, or other sensitive information.
-- **File Operations:** Always use absolute paths when referring to files with tools.
-
-# Final Reminder
-Your core function is efficient and safe assistance. Balance extreme conciseness with the crucial need for clarity, especially regarding safety and potential system modifications. Always prioritize user control and project conventions.
-        `.trim();
-    }
-}
-exports.CoreSystemPromptModifier = CoreSystemPromptModifier;

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

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

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

@@ -1,330 +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;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DirectoryContextModifier = void 0;
-const base_1 = require("../base");
-const fs = __importStar(require("node:fs/promises"));
-const path = __importStar(require("node:path"));
-const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
-const MAX_ITEMS = 200;
-const TRUNCATION_INDICATOR = '...';
-const DEFAULT_IGNORED_FOLDERS = new Set(['node_modules', '.git', 'dist']);
-// Error handling utility (simplified version of gemini-cli's getErrorMessage)
-function getErrorMessage(error) {
-    if (error instanceof Error) {
-        return error.message;
-    }
-    try {
-        return String(error);
-    }
-    catch {
-        return 'Failed to get error details';
-    }
-}
-// Node error type guard
-function isNodeError(error) {
-    return error instanceof Error && 'code' in error;
-}
-class DirectoryContextModifier extends base_1.BaseMessageModifier {
-    constructor(options = {}) {
-        super();
-        this.options = {
-            workspaceDirectories: options.workspaceDirectories || []
-        };
-    }
-    async modify(originalRequest, createdMessage) {
-        try {
-            // Get workspace directories from codebolt or use provided options
-            let workspaceDirectories = this.options.workspaceDirectories;
-            if (!workspaceDirectories || workspaceDirectories.length === 0) {
-                const { projectPath } = await codeboltjs_1.default.project.getProjectPath();
-                workspaceDirectories = projectPath ? [projectPath] : [];
-            }
-            if (workspaceDirectories.length === 0) {
-                return createdMessage;
-            }
-            const folderStructures = await Promise.all(workspaceDirectories.map((dir) => this.getFolderStructure(dir)));
-            const folderStructure = folderStructures.join('\n');
-            let workingDirPreamble;
-            if (workspaceDirectories.length === 1) {
-                workingDirPreamble = `I'm currently working in the directory: ${workspaceDirectories[0]}`;
-            }
-            else {
-                const dirList = workspaceDirectories.map((dir) => `  - ${dir}`).join('\n');
-                workingDirPreamble = `I'm currently working in the following directories:\n${dirList}`;
-            }
-            const directoryContext = `${workingDirPreamble}
-Here is the folder structure of the current working directories:
-
-${folderStructure}`;
-            const contextMessage = {
-                role: 'user', // Note: gemini-cli adds this as user message, not system
-                content: directoryContext
-            };
-            // Add as user message (like gemini-cli does)
-            const messages = [...createdMessage.message.messages, contextMessage];
-            return Promise.resolve({
-                message: {
-                    ...createdMessage.message,
-                    messages
-                },
-                metadata: {
-                    ...createdMessage.metadata,
-                    directoryContextAdded: true,
-                    workspaceDirectories
-                }
-            });
-        }
-        catch (error) {
-            console.error('Error in DirectoryContextModifier:', error);
-            return createdMessage;
-        }
-    }
-    /**
-     * Generates a string representation of a directory's structure,
-     * limiting the number of items displayed. Ignored folders are shown
-     * followed by '...' instead of their contents.
-     *
-     * @param directory The absolute or relative path to the directory.
-     * @param options Optional configuration settings.
-     * @returns A promise resolving to the formatted folder structure string.
-     */
-    async getFolderStructure(directory, options) {
-        var _a, _b;
-        const resolvedPath = path.resolve(directory);
-        const mergedOptions = {
-            maxItems: (_a = options === null || options === void 0 ? void 0 : options.maxItems) !== null && _a !== void 0 ? _a : MAX_ITEMS,
-            ignoredFolders: (_b = options === null || options === void 0 ? void 0 : options.ignoredFolders) !== null && _b !== void 0 ? _b : DEFAULT_IGNORED_FOLDERS,
-            fileIncludePattern: options === null || options === void 0 ? void 0 : options.fileIncludePattern,
-        };
-        try {
-            // 1. Read the structure using BFS, respecting maxItems
-            const structureRoot = await this.readFullStructure(resolvedPath, mergedOptions);
-            if (!structureRoot) {
-                return `Error: Could not read directory "${resolvedPath}". Check path and permissions.`;
-            }
-            // 2. Format the structure into a string
-            const structureLines = [];
-            // Pass true for isRoot for the initial call
-            this.formatStructure(structureRoot, '', true, true, structureLines);
-            // 3. Build the final output string
-            function isTruncated(node) {
-                if (node.hasMoreFiles || node.hasMoreSubfolders || node.isIgnored) {
-                    return true;
-                }
-                for (const sub of node.subFolders) {
-                    if (isTruncated(sub)) {
-                        return true;
-                    }
-                }
-                return false;
-            }
-            let summary = `Showing up to ${mergedOptions.maxItems} items (files + folders).`;
-            if (isTruncated(structureRoot)) {
-                summary += ` Folders or files indicated with ${TRUNCATION_INDICATOR} contain more items not shown, were ignored, or the display limit (${mergedOptions.maxItems} items) was reached.`;
-            }
-            return `${summary}\n\n${resolvedPath}${path.sep}\n${structureLines.join('\n')}`;
-        }
-        catch (error) {
-            console.error(`Error getting folder structure for ${resolvedPath}:`, error);
-            return `Error processing directory "${resolvedPath}": ${getErrorMessage(error)}`;
-        }
-    }
-    async readFullStructure(rootPath, options) {
-        const rootName = path.basename(rootPath);
-        const rootNode = {
-            name: rootName,
-            path: rootPath,
-            files: [],
-            subFolders: [],
-            totalChildren: 0,
-            totalFiles: 0,
-        };
-        const queue = [
-            { folderInfo: rootNode, currentPath: rootPath },
-        ];
-        let currentItemCount = 0;
-        // Count the root node itself as one item if we are not just listing its content
-        const processedPaths = new Set(); // To avoid processing same path if symlinks create loops
-        while (queue.length > 0) {
-            const { folderInfo, currentPath } = queue.shift();
-            if (processedPaths.has(currentPath)) {
-                continue;
-            }
-            processedPaths.add(currentPath);
-            if (currentItemCount >= options.maxItems) {
-                // If the root itself caused us to exceed, we can't really show anything.
-                // Otherwise, this folder won't be processed further.
-                // The parent that queued this would have set its own hasMoreSubfolders flag.
-                continue;
-            }
-            let entries;
-            try {
-                const rawEntries = await fs.readdir(currentPath, { withFileTypes: true });
-                // Sort entries alphabetically by name for consistent processing order
-                entries = rawEntries.sort((a, b) => a.name.localeCompare(b.name));
-            }
-            catch (error) {
-                if (isNodeError(error) &&
-                    (error.code === 'EACCES' || error.code === 'ENOENT')) {
-                    console.warn(`Warning: Could not read directory ${currentPath}: ${error.message}`);
-                    if (currentPath === rootPath && error.code === 'ENOENT') {
-                        return null; // Root directory itself not found
-                    }
-                    // For other EACCES/ENOENT on subdirectories, just skip them.
-                    continue;
-                }
-                throw error;
-            }
-            const filesInCurrentDir = [];
-            const subFoldersInCurrentDir = [];
-            // Process files first in the current directory
-            for (const entry of entries) {
-                if (entry.isFile()) {
-                    if (currentItemCount >= options.maxItems) {
-                        folderInfo.hasMoreFiles = true;
-                        break;
-                    }
-                    const fileName = entry.name;
-                    if (!options.fileIncludePattern ||
-                        options.fileIncludePattern.test(fileName)) {
-                        filesInCurrentDir.push(fileName);
-                        currentItemCount++;
-                        folderInfo.totalFiles++;
-                        folderInfo.totalChildren++;
-                    }
-                }
-            }
-            folderInfo.files = filesInCurrentDir;
-            // Then process directories and queue them
-            for (const entry of entries) {
-                if (entry.isDirectory()) {
-                    // Check if adding this directory ITSELF would meet or exceed maxItems
-                    // (currentItemCount refers to items *already* added before this one)
-                    if (currentItemCount >= options.maxItems) {
-                        folderInfo.hasMoreSubfolders = true;
-                        break; // Already at limit, cannot add this folder or any more
-                    }
-                    // If adding THIS folder makes us hit the limit exactly, and it might have children,
-                    // it's better to show '...' for the parent, unless this is the very last item slot.
-                    // This logic is tricky. Let's try a simpler: if we can't add this item, mark and break.
-                    const subFolderName = entry.name;
-                    const subFolderPath = path.join(currentPath, subFolderName);
-                    if (options.ignoredFolders.has(subFolderName)) {
-                        const ignoredSubFolder = {
-                            name: subFolderName,
-                            path: subFolderPath,
-                            files: [],
-                            subFolders: [],
-                            totalChildren: 0,
-                            totalFiles: 0,
-                            isIgnored: true,
-                        };
-                        subFoldersInCurrentDir.push(ignoredSubFolder);
-                        currentItemCount++; // Count the ignored folder itself
-                        folderInfo.totalChildren++; // Also counts towards parent's children
-                        continue;
-                    }
-                    const subFolderNode = {
-                        name: subFolderName,
-                        path: subFolderPath,
-                        files: [],
-                        subFolders: [],
-                        totalChildren: 0,
-                        totalFiles: 0,
-                    };
-                    subFoldersInCurrentDir.push(subFolderNode);
-                    currentItemCount++;
-                    folderInfo.totalChildren++; // Counts towards parent's children
-                    // Add to queue for processing its children later
-                    queue.push({ folderInfo: subFolderNode, currentPath: subFolderPath });
-                }
-            }
-            folderInfo.subFolders = subFoldersInCurrentDir;
-        }
-        return rootNode;
-    }
-    /**
-     * Reads the directory structure using BFS, respecting maxItems.
-     * @param node The current node in the reduced structure.
-     * @param indent The current indentation string.
-     * @param isLast Sibling indicator.
-     * @param builder Array to build the string lines.
-     */
-    formatStructure(node, currentIndent, isLastChildOfParent, isProcessingRootNode, builder) {
-        const connector = isLastChildOfParent ? '└───' : '├───';
-        // The root node of the structure (the one passed initially to getFolderStructure)
-        // is not printed with a connector line itself, only its name as a header.
-        // Its children are printed relative to that conceptual root.
-        // Ignored root nodes ARE printed with a connector.
-        if (!isProcessingRootNode || node.isIgnored) {
-            builder.push(`${currentIndent}${connector}${node.name}${path.sep}${node.isIgnored ? TRUNCATION_INDICATOR : ''}`);
-        }
-        // Determine the indent for the children of *this* node.
-        // If *this* node was the root of the whole structure, its children start with no indent before their connectors.
-        // Otherwise, children's indent extends from the current node's indent.
-        const indentForChildren = isProcessingRootNode
-            ? ''
-            : currentIndent + (isLastChildOfParent ? '    ' : '│   ');
-        // Render files of the current node
-        const fileCount = node.files.length;
-        for (let i = 0; i < fileCount; i++) {
-            const isLastFileAmongSiblings = i === fileCount - 1 &&
-                node.subFolders.length === 0 &&
-                !node.hasMoreSubfolders;
-            const fileConnector = isLastFileAmongSiblings ? '└───' : '├───';
-            builder.push(`${indentForChildren}${fileConnector}${node.files[i]}`);
-        }
-        if (node.hasMoreFiles) {
-            const isLastIndicatorAmongSiblings = node.subFolders.length === 0 && !node.hasMoreSubfolders;
-            const fileConnector = isLastIndicatorAmongSiblings ? '└───' : '├───';
-            builder.push(`${indentForChildren}${fileConnector}${TRUNCATION_INDICATOR}`);
-        }
-        // Render subfolders of the current node
-        const subFolderCount = node.subFolders.length;
-        for (let i = 0; i < subFolderCount; i++) {
-            const isLastSubfolderAmongSiblings = i === subFolderCount - 1 && !node.hasMoreSubfolders;
-            // Children are never the root node being processed initially.
-            this.formatStructure(node.subFolders[i], indentForChildren, isLastSubfolderAmongSiblings, false, builder);
-        }
-        if (node.hasMoreSubfolders) {
-            builder.push(`${indentForChildren}└───${TRUNCATION_INDICATOR}`);
-        }
-    }
-}
-exports.DirectoryContextModifier = DirectoryContextModifier;

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

@@ -1,26 +0,0 @@
-import { ProcessedMessage } from "@codebolt/types/agent";
-import { BaseMessageModifier } from "../base";
-import { FlatUserMessage } from "@codebolt/types/sdk";
-export interface EnvironmentContextOptions {
-    enableFullContext?: boolean;
-    maxFiles?: number;
-    maxFileSize?: number;
-    includePatterns?: string[];
-    excludePatterns?: string[];
-}
-export declare class EnvironmentContextModifier extends BaseMessageModifier {
-    private readonly options;
-    private readonly defaultExcludePatterns;
-    constructor(options?: EnvironmentContextOptions);
-    modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
-    private generateFullContext;
-    private findRelevantFiles;
-    private walkDirectory;
-    private isExcluded;
-    private isIncluded;
-    private matchesPattern;
-    private countContextFiles;
-    enableFullContext(): void;
-    disableFullContext(): void;
-    isFullContextEnabled(): boolean;
-}