@codebolt/agent 1.2.1 → 2.2.2

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,12 @@
+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

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

@@ -0,0 +1,34 @@
+import { ProcessedMessage } from "@codebolt/types/agent";
+import { BaseMessageModifier } from "../base";
+import { FlatUserMessage } from "@codebolt/types/sdk";
+export interface IdeContextOptions {
+    includeOpenFiles?: boolean;
+    includeActiveFile?: boolean;
+    includeCursorPosition?: boolean;
+    includeSelectedText?: boolean;
+    maxOpenFiles?: number;
+}
+export interface FileInfo {
+    path: string;
+    isActive?: boolean;
+    cursor?: {
+        line: number;
+        character: number;
+    };
+    selectedText?: string;
+}
+export interface IdeContext {
+    workspaceState?: {
+        openFiles: FileInfo[];
+    };
+}
+export declare class IdeContextModifier extends BaseMessageModifier {
+    private readonly options;
+    private lastSentIdeContext?;
+    private forceFullContext;
+    constructor(options?: IdeContextOptions);
+    modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
+    private getIdeContext;
+    private getIdeContextParts;
+    setForceFullContext(force: boolean): void;
+}

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

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdeContextModifier = void 0;
+const base_1 = require("../base");
+class IdeContextModifier extends base_1.BaseMessageModifier {
+    constructor(options = {}) {
+        super();
+        this.forceFullContext = true;
+        this.options = {
+            includeOpenFiles: options.includeOpenFiles !== false,
+            includeActiveFile: options.includeActiveFile !== false,
+            includeCursorPosition: options.includeCursorPosition !== false,
+            includeSelectedText: options.includeSelectedText !== false,
+            maxOpenFiles: options.maxOpenFiles || 10
+        };
+    }
+    modify(originalRequest, createdMessage) {
+        try {
+            // Get IDE context from the original request (activeFile, openedFiles)
+            const ideContext = this.getIdeContext(originalRequest, createdMessage.metadata);
+            if (!ideContext) {
+                return Promise.resolve(createdMessage);
+            }
+            const { contextParts, newIdeContext } = this.getIdeContextParts(this.forceFullContext, ideContext);
+            if (contextParts.length === 0) {
+                return Promise.resolve(createdMessage);
+            }
+            const ideContextMessage = {
+                role: 'system',
+                content: contextParts.join('\n')
+            };
+            // Find existing system message or add new one
+            const messages = [...createdMessage.message.messages];
+            const systemMessageIndex = messages.findIndex(msg => msg.role === 'system');
+            if (systemMessageIndex !== -1) {
+                // Append to existing system message
+                messages[systemMessageIndex] = {
+                    ...messages[systemMessageIndex],
+                    content: `${messages[systemMessageIndex].content}\n\n${ideContextMessage.content}`
+                };
+            }
+            else {
+                // Add new system message
+                messages.unshift(ideContextMessage);
+            }
+            this.lastSentIdeContext = newIdeContext;
+            this.forceFullContext = false;
+            return Promise.resolve({
+                message: {
+                    ...createdMessage.message,
+                    messages
+                },
+                metadata: {
+                    ...createdMessage.metadata,
+                    ideContextAdded: true,
+                    ideContextType: this.forceFullContext ? 'full' : 'incremental'
+                }
+            });
+        }
+        catch (error) {
+            console.error('Error in IdeContextModifier:', error);
+            return Promise.resolve(createdMessage);
+        }
+    }
+    getIdeContext(originalRequest, metadata) {
+        // Try to get IDE context from the metadata parameter first
+        if (metadata === null || metadata === void 0 ? void 0 : metadata.ideContext) {
+            return metadata.ideContext;
+        }
+        // Extract IDE context from the original message
+        const activeFile = originalRequest.activeFile;
+        const openedFiles = originalRequest.openedFiles;
+        if (!activeFile && (!openedFiles || openedFiles.length === 0)) {
+            return undefined;
+        }
+        const openFiles = [];
+        // Add active file if present (activeFile is just a path string)
+        if (activeFile) {
+            const activeFileInfo = {
+                path: activeFile,
+                isActive: true
+            };
+            openFiles.push(activeFileInfo);
+        }
+        // Add other opened files (openedFiles is array of path strings)
+        if (openedFiles && Array.isArray(openedFiles)) {
+            const otherFiles = openedFiles
+                .filter(filePath => filePath !== activeFile) // Exclude active file from others
+                .map(filePath => ({
+                path: filePath,
+                isActive: false
+            }));
+            openFiles.push(...otherFiles);
+        }
+        if (openFiles.length === 0) {
+            return undefined;
+        }
+        return {
+            workspaceState: {
+                openFiles
+            }
+        };
+    }
+    getIdeContextParts(forceFullContext, currentIdeContext) {
+        var _a;
+        if (!((_a = currentIdeContext === null || currentIdeContext === void 0 ? void 0 : currentIdeContext.workspaceState) === null || _a === void 0 ? void 0 : _a.openFiles)) {
+            return { contextParts: [], newIdeContext: undefined };
+        }
+        if (forceFullContext || !this.lastSentIdeContext) {
+            // Send full context as JSON
+            const openFiles = currentIdeContext.workspaceState.openFiles;
+            const activeFile = openFiles.find((f) => f.isActive);
+            const otherOpenFiles = openFiles
+                .filter((f) => !f.isActive)
+                .map((f) => f.path)
+                .slice(0, this.options.maxOpenFiles - 1); // Reserve space for active file
+            const contextData = {};
+            if (activeFile && this.options.includeActiveFile) {
+                const activeFileData = {
+                    path: activeFile.path
+                };
+                if (this.options.includeCursorPosition && activeFile.cursor) {
+                    activeFileData.cursor = {
+                        line: activeFile.cursor.line,
+                        character: activeFile.cursor.character,
+                    };
+                }
+                if (this.options.includeSelectedText && activeFile.selectedText) {
+                    activeFileData.selectedText = activeFile.selectedText;
+                }
+                contextData['activeFile'] = activeFileData;
+            }
+            if (this.options.includeOpenFiles && otherOpenFiles.length > 0) {
+                contextData['otherOpenFiles'] = otherOpenFiles;
+            }
+            if (Object.keys(contextData).length === 0) {
+                return { contextParts: [], newIdeContext: currentIdeContext };
+            }
+            const jsonString = JSON.stringify(contextData, null, 2);
+            const contextParts = [
+                "Here is the user's editor context as a JSON object. This is for your information only.",
+                '```json',
+                jsonString,
+                '```',
+                "Don't acknowledge this context in your response unless specifically asked about it."
+            ];
+            return { contextParts, newIdeContext: currentIdeContext };
+        }
+        // For incremental updates, we would compare with lastSentIdeContext
+        // and only send changes. For now, we'll skip incremental updates.
+        return { contextParts: [], newIdeContext: currentIdeContext };
+    }
+    setForceFullContext(force) {
+        this.forceFullContext = force;
+    }
+}
+exports.IdeContextModifier = IdeContextModifier;

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

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