@codebolt/agent 1.1.0 → 2.2.2

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

@@ -0,0 +1,418 @@
+"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', 'build', '.next', '.cache', '.tmp', 'tmp']);
+// 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.gitignorePatterns = new Set();
+        this.gitignoreRegexes = [];
+        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;
+            }
+            // Load gitignore patterns from all workspace directories
+            await this.loadGitignorePatterns(workspaceDirectories);
+            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;
+        }
+    }
+    async loadGitignorePatterns(workspaceDirectories) {
+        this.gitignorePatterns.clear();
+        this.gitignoreRegexes = [];
+        for (const dir of workspaceDirectories) {
+            try {
+                const gitignorePath = path.join(dir, '.gitignore');
+                const content = await fs.readFile(gitignorePath, 'utf-8');
+                this.parseGitignoreContent(content);
+            }
+            catch (error) {
+                // .gitignore file doesn't exist or can't be read, continue
+                console.debug(`No .gitignore found in ${dir}`);
+            }
+        }
+    }
+    parseGitignoreContent(content) {
+        const lines = content.split('\n')
+            .map(line => line.trim())
+            .filter(line => line && !line.startsWith('#')); // Remove empty lines and comments
+        for (const line of lines) {
+            this.gitignorePatterns.add(line);
+            // Convert gitignore pattern to regex
+            let regexPattern = line
+                .replace(/\./g, '\\.') // Escape dots
+                .replace(/\*/g, '.*') // Convert * to .*
+                .replace(/\?/g, '.') // Convert ? to .
+                .replace(/\//g, '\\/'); // Escape slashes
+            // Handle directory patterns (ending with /)
+            if (line.endsWith('/')) {
+                regexPattern = regexPattern.slice(0, -2) + '$'; // Remove \/ and add end anchor
+            }
+            try {
+                this.gitignoreRegexes.push(new RegExp(regexPattern));
+            }
+            catch (error) {
+                console.warn(`Invalid gitignore pattern: ${line}`);
+            }
+        }
+    }
+    isGitIgnored(filePath, fileName) {
+        // Check against gitignore patterns
+        for (const regex of this.gitignoreRegexes) {
+            if (regex.test(fileName) || regex.test(filePath)) {
+                return true;
+            }
+        }
+        // Check exact matches
+        return this.gitignorePatterns.has(fileName) ||
+            this.gitignorePatterns.has(filePath) ||
+            this.gitignorePatterns.has(fileName + '/'); // Directory pattern
+    }
+    shouldIgnoreFile(fileName, filePath) {
+        // Check gitignore first
+        if (filePath && this.isGitIgnored(filePath, fileName)) {
+            return true;
+        }
+        // Ignore hidden files (except .gitignore itself)
+        if (fileName.startsWith('.') && fileName !== '.gitignore') {
+            return true;
+        }
+        // Ignore temporary files and caches
+        const ignoredPatterns = [
+            /^───.*\.tar\.zst$/, // Weird temporary files like ───0069a971db0f139f.tar.zst
+            /\.tmp$/,
+            /\.temp$/,
+            /\.cache$/,
+            /\.log$/,
+            /\.swp$/,
+            /\.bak$/,
+            /~$/,
+            /^#.*#$/,
+            /\.DS_Store$/,
+            /Thumbs\.db$/,
+            /desktop\.ini$/,
+        ];
+        return ignoredPatterns.some(pattern => pattern.test(fileName));
+    }
+    /**
+     * 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;
+                    // Skip hidden files, temporary files, and other unwanted files
+                    const filePath = path.join(currentPath, fileName);
+                    if (this.shouldIgnoreFile(fileName, filePath)) {
+                        continue;
+                    }
+                    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);
+                    // Check if folder should be ignored (built-in ignore list or gitignore)
+                    if (options.ignoredFolders.has(subFolderName) ||
+                        this.shouldIgnoreFile(subFolderName, subFolderPath)) {
+                        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/messageModifiers/environmentContextModifier.d.ts

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