@codebolt/agent 1.2.1 → 2.2.3

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

@@ -0,0 +1,355 @@
+"use strict";
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+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.getFolderStructure = getFolderStructure;
+exports.getDirectoryContextString = getDirectoryContextString;
+exports.getEnvironmentContext = getEnvironmentContext;
+exports.readMultipleFiles = readMultipleFiles;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const MAX_ITEMS = 200;
+const DEFAULT_IGNORED_FOLDERS = new Set(['node_modules', '.git', 'dist']);
+/**
+ * Simple gitignore pattern matcher (basic implementation)
+ * For production use, consider using a dedicated gitignore library
+ */
+function shouldIgnoreFile(filePath, options) {
+    if (!options.respectGitIgnore && !options.respectGeminiIgnore) {
+        return false;
+    }
+    // Basic ignore patterns - in production, you'd want to read actual .gitignore/.geminiignore files
+    const commonIgnorePatterns = [
+        /node_modules/,
+        /\.git/,
+        /dist/,
+        /build/,
+        /\.DS_Store/,
+        /\.env/,
+        /\.log$/,
+        /\.tmp$/,
+        /\.cache/
+    ];
+    return commonIgnorePatterns.some(pattern => pattern.test(filePath));
+}
+/**
+ * Reads the full folder structure recursively
+ */
+async function 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;
+    const processedPaths = new Set();
+    while (queue.length > 0) {
+        const { folderInfo, currentPath } = queue.shift();
+        if (processedPaths.has(currentPath)) {
+            continue;
+        }
+        processedPaths.add(currentPath);
+        if (currentItemCount >= options.maxItems) {
+            continue;
+        }
+        let entries;
+        try {
+            const rawEntries = await fs.readdir(currentPath, { withFileTypes: true });
+            entries = rawEntries.sort((a, b) => a.name.localeCompare(b.name));
+        }
+        catch (error) {
+            if (error.code === 'EACCES' || error.code === 'ENOENT') {
+                console.warn(`Warning: Could not read directory ${currentPath}: ${error.message}`);
+                if (currentPath === rootPath && error.code === 'ENOENT') {
+                    return null;
+                }
+                continue;
+            }
+            throw error;
+        }
+        const filesInCurrentDir = [];
+        const subFoldersInCurrentDir = [];
+        // Process files first
+        for (const entry of entries) {
+            if (entry.isFile()) {
+                if (currentItemCount >= options.maxItems) {
+                    folderInfo.hasMoreFiles = true;
+                    break;
+                }
+                const fileName = entry.name;
+                const filePath = path.join(currentPath, fileName);
+                if (shouldIgnoreFile(filePath, options)) {
+                    continue;
+                }
+                if (!options.fileIncludePattern || options.fileIncludePattern.test(fileName)) {
+                    filesInCurrentDir.push(fileName);
+                    currentItemCount++;
+                    folderInfo.totalFiles++;
+                    folderInfo.totalChildren++;
+                }
+            }
+        }
+        folderInfo.files = filesInCurrentDir;
+        // Process directories
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                if (currentItemCount >= options.maxItems) {
+                    folderInfo.hasMoreSubfolders = true;
+                    break;
+                }
+                const subFolderName = entry.name;
+                const subFolderPath = path.join(currentPath, subFolderName);
+                if (options.ignoredFolders.has(subFolderName) || shouldIgnoreFile(subFolderPath, options)) {
+                    const ignoredSubFolder = {
+                        name: subFolderName,
+                        path: subFolderPath,
+                        files: [],
+                        subFolders: [],
+                        totalChildren: 0,
+                        totalFiles: 0,
+                        isIgnored: true,
+                    };
+                    subFoldersInCurrentDir.push(ignoredSubFolder);
+                    currentItemCount++;
+                    folderInfo.totalChildren++;
+                    continue;
+                }
+                const subFolderNode = {
+                    name: subFolderName,
+                    path: subFolderPath,
+                    files: [],
+                    subFolders: [],
+                    totalChildren: 0,
+                    totalFiles: 0,
+                };
+                subFoldersInCurrentDir.push(subFolderNode);
+                currentItemCount++;
+                folderInfo.totalChildren++;
+                queue.push({ folderInfo: subFolderNode, currentPath: subFolderPath });
+            }
+        }
+        folderInfo.subFolders = subFoldersInCurrentDir;
+    }
+    return rootNode;
+}
+/**
+ * Formats a folder structure into a readable string representation
+ */
+function formatFolderStructure(folderInfo, prefix = '', isLast = true) {
+    const connector = isLast ? '└── ' : '├── ';
+    const extension = isLast ? '    ' : '│   ';
+    let result = `${prefix}${connector}${folderInfo.name}`;
+    if (folderInfo.isIgnored) {
+        result += ' (ignored)';
+    }
+    result += '\n';
+    // Add files
+    const allFiles = [...folderInfo.files];
+    if (folderInfo.hasMoreFiles) {
+        allFiles.push('...');
+    }
+    allFiles.forEach((file, index) => {
+        const isLastFile = index === allFiles.length - 1 && folderInfo.subFolders.length === 0;
+        const fileConnector = isLastFile ? '└── ' : '├── ';
+        result += `${prefix}${extension}${fileConnector}${file}\n`;
+    });
+    // Add subfolders
+    folderInfo.subFolders.forEach((subFolder, index) => {
+        const isLastSubFolder = index === folderInfo.subFolders.length - 1;
+        result += formatFolderStructure(subFolder, prefix + extension, isLastSubFolder);
+    });
+    if (folderInfo.hasMoreSubfolders) {
+        const moreConnector = '└── ';
+        result += `${prefix}${extension}${moreConnector}...\n`;
+    }
+    return result;
+}
+/**
+ * Standalone version of getFolderStructure
+ */
+async function getFolderStructure(targetPath, options = {}) {
+    var _a, _b, _c, _d, _e;
+    const mergedOptions = {
+        maxItems: (_a = options.maxItems) !== null && _a !== void 0 ? _a : MAX_ITEMS,
+        ignoredFolders: (_b = options.ignoredFolders) !== null && _b !== void 0 ? _b : DEFAULT_IGNORED_FOLDERS,
+        fileIncludePattern: (_c = options.fileIncludePattern) !== null && _c !== void 0 ? _c : /.*/,
+        respectGitIgnore: (_d = options.respectGitIgnore) !== null && _d !== void 0 ? _d : true,
+        respectGeminiIgnore: (_e = options.respectGeminiIgnore) !== null && _e !== void 0 ? _e : true,
+    };
+    try {
+        const folderInfo = await readFullStructure(targetPath, mergedOptions);
+        if (!folderInfo) {
+            return `Error: Directory not found or inaccessible: ${targetPath}`;
+        }
+        return formatFolderStructure(folderInfo).trim();
+    }
+    catch (error) {
+        return `Error reading folder structure: ${error.message}`;
+    }
+}
+/**
+ * Standalone version of getDirectoryContextString
+ */
+async function getDirectoryContextString(workspaceDirectories, options = {}) {
+    const folderStructures = await Promise.all(workspaceDirectories.map((dir) => getFolderStructure(dir, options)));
+    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}`;
+    }
+    return `${workingDirPreamble}
+Here is the folder structure of the current working directories:
+
+${folderStructure}`;
+}
+/**
+ * Standalone version of getEnvironmentContext
+ */
+async function getEnvironmentContext(options) {
+    const today = new Date().toLocaleDateString(undefined, {
+        weekday: 'long',
+        year: 'numeric',
+        month: 'long',
+        day: 'numeric',
+    });
+    const platform = process.platform;
+    const directoryContext = await getDirectoryContextString(options.workspaceDirectories, {
+        maxItems: options.maxItems,
+        ignoredFolders: options.ignoredFolders,
+        fileIncludePattern: options.fileIncludePattern,
+        respectGitIgnore: options.respectGitIgnore,
+        respectGeminiIgnore: options.respectGeminiIgnore,
+    });
+    const context = `
+This is the Gemini CLI. We are setting up the context for our chat.
+Today's date is ${today}.
+My operating system is: ${platform}
+${directoryContext}
+        `.trim();
+    const initialParts = [{ text: context }];
+    // Add full file context if requested
+    if (options.includeFullContext) {
+        try {
+            // This is a simplified version - in the original, this would use read_many_files tool
+            // For standalone use, you might want to implement your own file reading logic
+            const fullContextNote = `
+--- Full File Context (Standalone Version) ---
+Note: Full file context reading would require implementing file reading logic
+based on your specific needs. The original implementation uses the read_many_files tool
+from the Gemini CLI tool registry.
+`;
+            initialParts.push({ text: fullContextNote });
+        }
+        catch (error) {
+            console.error('Error reading full file context:', error);
+            initialParts.push({
+                text: '\n--- Error reading full file context ---',
+            });
+        }
+    }
+    return initialParts;
+}
+/**
+ * Utility function to read multiple files (basic implementation for full context)
+ * This is a simplified version - extend as needed for your use case
+ */
+async function readMultipleFiles(basePath, patterns = ['**/*'], options = {}) {
+    // This is a basic implementation - for production use, consider using a glob library
+    // like 'glob' or 'fast-glob' for pattern matching
+    try {
+        const files = [];
+        async function collectFiles(dirPath, currentDepth = 0) {
+            var _a;
+            if (currentDepth > 10)
+                return; // Prevent infinite recursion
+            try {
+                const entries = await fs.readdir(dirPath, { withFileTypes: true });
+                for (const entry of entries) {
+                    const fullPath = path.join(dirPath, entry.name);
+                    if (shouldIgnoreFile(fullPath, options)) {
+                        continue;
+                    }
+                    if (entry.isFile()) {
+                        files.push(fullPath);
+                    }
+                    else if (entry.isDirectory() && !((_a = options.ignoredFolders) === null || _a === void 0 ? void 0 : _a.has(entry.name))) {
+                        await collectFiles(fullPath, currentDepth + 1);
+                    }
+                }
+            }
+            catch (error) {
+                // Skip directories we can't read
+                console.warn(`Warning: Could not read directory ${dirPath}: ${error.message}`);
+            }
+        }
+        await collectFiles(basePath);
+        // Read file contents (limit to reasonable size)
+        const fileContents = [];
+        for (const filePath of files.slice(0, 100)) { // Limit to first 100 files
+            try {
+                const stats = await fs.stat(filePath);
+                if (stats.size > 100 * 1024) { // Skip files larger than 100KB
+                    fileContents.push(`${filePath}: [File too large, skipped]`);
+                    continue;
+                }
+                const content = await fs.readFile(filePath, 'utf-8');
+                const relativePath = path.relative(basePath, filePath);
+                fileContents.push(`--- ${relativePath} ---\n${content}\n`);
+            }
+            catch (error) {
+                fileContents.push(`${filePath}: [Error reading file: ${error.message}]`);
+            }
+        }
+        return fileContents.join('\n');
+    }
+    catch (error) {
+        return `Error reading multiple files: ${error.message}`;
+    }
+}

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

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

@@ -0,0 +1,260 @@
+"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.EnvironmentContextModifier = void 0;
+const base_1 = require("../base");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
+class EnvironmentContextModifier extends base_1.BaseMessageModifier {
+    constructor(options = {}) {
+        super();
+        this.defaultExcludePatterns = [
+            'node_modules/**',
+            '.git/**',
+            'dist/**',
+            'build/**',
+            '*.log',
+            '*.tmp',
+            '.DS_Store',
+            'coverage/**',
+            '.next/**',
+            '.nuxt/**',
+            '.codebolt',
+            '.codebolt/**',
+        ];
+        this.options = {
+            enableFullContext: options.enableFullContext || false,
+            maxFiles: options.maxFiles || 100,
+            maxFileSize: options.maxFileSize || 100 * 1024, // 100KB per file
+            includePatterns: options.includePatterns || ['**/*.ts', '**/*.js', '**/*.json', '**/*.md', '**/*.txt', '**/*.yml', '**/*.yaml'],
+            excludePatterns: [...this.defaultExcludePatterns, ...(options.excludePatterns || [])]
+        };
+    }
+    async modify(originalRequest, createdMessage) {
+        try {
+            // Get current date formatted to user's locale
+            const today = new Date().toLocaleDateString(undefined, {
+                weekday: 'long',
+                year: 'numeric',
+                month: 'long',
+                day: 'numeric',
+            });
+            const platform = process.platform;
+            const { projectPath } = await codeboltjs_1.default.project.getProjectPath();
+            if (!projectPath) {
+                return createdMessage;
+            }
+            const currentDir = projectPath;
+            // Get basic directory listing
+            let directoryListing = '';
+            try {
+                const files = await fs.promises.readdir(currentDir);
+                const fileList = files.slice(0, 20).join(', '); // Limit to first 20 files
+                const moreFiles = files.length > 20 ? ` ... and ${files.length - 20} more files` : '';
+                directoryListing = `Files in current directory: ${fileList}${moreFiles}`;
+            }
+            catch (error) {
+                directoryListing = 'Unable to read current directory';
+            }
+            const environmentContext = `
+This is the CodeBolt AI Agent. Setting up context for our chat.
+Today's date is ${today} (formatted according to the user's locale).
+Operating system: ${platform}
+Current working directory: ${currentDir}
+${directoryListing}
+            `.trim();
+            // Prepare context parts (same as gemini-cli)
+            const contextParts = [environmentContext];
+            // Add full file context if enabled (just like gemini-cli does)
+            if (this.options.enableFullContext) {
+                try {
+                    const fullContextContent = await this.generateFullContext(currentDir);
+                    if (fullContextContent) {
+                        contextParts.push(`\n--- Full File Context ---\n${fullContextContent}`);
+                    }
+                }
+                catch (error) {
+                    console.error('Error reading full file context:', error);
+                    contextParts.push('\n--- Error reading full file context ---');
+                }
+            }
+            const finalContent = contextParts.join('\n\n');
+            const contextMessage = {
+                role: 'user',
+                content: finalContent
+            };
+            // Push the context message to the messages array
+            const messages = [...createdMessage.message.messages];
+            messages.push(contextMessage);
+            return Promise.resolve({
+                message: {
+                    ...createdMessage.message,
+                    messages
+                },
+                metadata: {
+                    ...createdMessage.metadata,
+                    environmentContextAdded: true,
+                    fullContextAdded: this.options.enableFullContext,
+                    contextFilesCount: this.options.enableFullContext ? await this.countContextFiles(currentDir) : 0,
+                    environmentInfo: {
+                        date: today,
+                        platform,
+                        currentDir
+                    }
+                }
+            });
+        }
+        catch (error) {
+            console.error('Error in EnvironmentContextModifier:', error);
+            return createdMessage;
+        }
+    }
+    // Full context methods (integrated like gemini-cli)
+    async generateFullContext(basePath) {
+        try {
+            const files = await this.findRelevantFiles(basePath);
+            const contextParts = [];
+            let processedFiles = 0;
+            for (const filePath of files) {
+                if (processedFiles >= this.options.maxFiles) {
+                    contextParts.push(`\n... (${files.length - processedFiles} more files not shown due to limit)\n`);
+                    break;
+                }
+                try {
+                    const relativePath = path.relative(basePath, filePath);
+                    const stats = await fs.promises.stat(filePath);
+                    // Skip files that are too large
+                    if (stats.size > this.options.maxFileSize) {
+                        contextParts.push(`--- ${relativePath} ---\n[File too large: ${stats.size} bytes]\n`);
+                        processedFiles++;
+                        continue;
+                    }
+                    const content = await fs.promises.readFile(filePath, 'utf-8');
+                    contextParts.push(`--- ${relativePath} ---\n${content}\n`);
+                    processedFiles++;
+                }
+                catch (error) {
+                    const relativePath = path.relative(basePath, filePath);
+                    contextParts.push(`--- ${relativePath} ---\n[Error reading file: ${error instanceof Error ? error.message : 'Unknown error'}]\n`);
+                    processedFiles++;
+                }
+            }
+            return contextParts.join('\n');
+        }
+        catch (error) {
+            console.error('Error generating full context:', error);
+            return '';
+        }
+    }
+    async findRelevantFiles(basePath) {
+        const files = [];
+        try {
+            await this.walkDirectory(basePath, files, basePath);
+            return files.sort();
+        }
+        catch (error) {
+            console.error('Error finding relevant files:', error);
+            return [];
+        }
+    }
+    async walkDirectory(dir, files, basePath) {
+        try {
+            const entries = await fs.promises.readdir(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(dir, entry.name);
+                const relativePath = path.relative(basePath, fullPath);
+                // Check exclusion patterns
+                if (this.isExcluded(relativePath)) {
+                    continue;
+                }
+                if (entry.isDirectory()) {
+                    await this.walkDirectory(fullPath, files, basePath);
+                }
+                else if (entry.isFile()) {
+                    // Check inclusion patterns
+                    if (this.isIncluded(relativePath)) {
+                        files.push(fullPath);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            // Skip directories we can't read
+        }
+    }
+    isExcluded(relativePath) {
+        return this.options.excludePatterns.some(pattern => {
+            return this.matchesPattern(relativePath, pattern);
+        });
+    }
+    isIncluded(relativePath) {
+        return this.options.includePatterns.some(pattern => {
+            return this.matchesPattern(relativePath, pattern);
+        });
+    }
+    matchesPattern(filePath, pattern) {
+        // Simple glob pattern matching - in production, use a proper glob library
+        const regexPattern = pattern
+            .replace(/\*\*/g, '.*')
+            .replace(/\*/g, '[^/]*')
+            .replace(/\?/g, '.');
+        const regex = new RegExp(`^${regexPattern}$`);
+        return regex.test(filePath);
+    }
+    async countContextFiles(basePath) {
+        try {
+            const files = await this.findRelevantFiles(basePath);
+            return Math.min(files.length, this.options.maxFiles);
+        }
+        catch (error) {
+            return 0;
+        }
+    }
+    // Public methods to control full context
+    enableFullContext() {
+        this.options.enableFullContext = true;
+    }
+    disableFullContext() {
+        this.options.enableFullContext = false;
+    }
+    isFullContextEnabled() {
+        return this.options.enableFullContext || false;
+    }
+}
+exports.EnvironmentContextModifier = EnvironmentContextModifier;

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

@@ -0,0 +1,13 @@
+import { FlatUserMessage } from '@codebolt/types/sdk';
+import { BaseMessageModifier, 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(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
+    private extractUrls;
+}