@codebolt/agent 1.2.1 → 2.2.2

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

@@ -0,0 +1,453 @@
+"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.AtFileProcessorModifier = 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 DEFAULT_FILE_FILTERING_OPTIONS = {
+    respectGitIgnore: true,
+    respectGeminiIgnore: true,
+};
+class AtFileProcessorModifier extends base_1.BaseMessageModifier {
+    constructor(options = {}) {
+        super();
+        this.options = {
+            maxFileSize: options.maxFileSize || 1024 * 1024, // 1MB default
+            allowedExtensions: options.allowedExtensions || ['.ts', '.js', '.d.ts', '.json', '.md', '.txt', '.yml', '.yaml', '.xml', '.html', '.css', '.py', '.java', '.cpp', '.c', '.h'],
+            enableRecursiveSearch: options.enableRecursiveSearch !== false
+        };
+    }
+    async modify(originalRequest, createdMessage) {
+        try {
+            const mentionedFiles = originalRequest.mentionedFiles || [];
+            const mentionedFolders = originalRequest.mentionedFolders || [];
+            if (mentionedFiles.length === 0 && mentionedFolders.length === 0) {
+                return createdMessage;
+            }
+            // Process mentioned files and folders
+            const result = await this.processMentionedPaths(mentionedFiles, mentionedFolders);
+            if (!result.success) {
+                return createdMessage;
+            }
+            // Update the user message with processed content
+            const messages = [...createdMessage.message.messages];
+            const lastUserMessageIndex = this.findLastUserMessage(messages);
+            if (lastUserMessageIndex !== -1 && result.processedContent) {
+                const lastUserMessage = messages[lastUserMessageIndex];
+                // Convert string content to array format if needed
+                let currentContent;
+                if (Array.isArray(lastUserMessage.content)) {
+                    currentContent = lastUserMessage.content;
+                }
+                else {
+                    // Convert string content to array format
+                    currentContent = [{ type: 'text', text: lastUserMessage.content }];
+                }
+                // Ensure processedContent is in array format
+                const newContent = Array.isArray(result.processedContent)
+                    ? result.processedContent
+                    : [{ type: 'text', text: result.processedContent }];
+                // Merge existing content with processed content
+                messages[lastUserMessageIndex] = {
+                    ...lastUserMessage,
+                    content: [...currentContent, ...newContent]
+                };
+            }
+            return {
+                message: {
+                    ...createdMessage.message,
+                    messages
+                },
+                metadata: {
+                    ...createdMessage.metadata,
+                    atFileProcessed: true,
+                    processedFiles: mentionedFiles,
+                    processedFolders: mentionedFolders,
+                    filesRead: result.filesRead || []
+                }
+            };
+        }
+        catch (error) {
+            console.error('Error in AtFileProcessorModifier:', error);
+            return createdMessage;
+        }
+    }
+    async processMentionedPaths(mentionedFiles, mentionedFolders) {
+        const filesRead = [];
+        const contextParts = [];
+        // Get workspace directories
+        let workspaceDirectories = [];
+        try {
+            const { projectPath } = await codeboltjs_1.default.project.getProjectPath();
+            workspaceDirectories = projectPath ? [projectPath] : [await this.getProjectPath()];
+        }
+        catch (error) {
+            workspaceDirectories = [await this.getProjectPath()];
+        }
+        // Process mentioned files using readManyFiles
+        if (mentionedFiles.length > 0) {
+            try {
+                const resolvedPaths = await Promise.all(mentionedFiles.map(async (filePath) => {
+                    try {
+                        await this.resolvePath(filePath, workspaceDirectories);
+                        return filePath; // Keep original path for readManyFiles
+                    }
+                    catch (error) {
+                        console.warn(`Could not resolve path: ${filePath}`);
+                        return filePath; // Still try to read it
+                    }
+                }));
+                const fileContents = await this.readManyFiles(resolvedPaths);
+                filesRead.push(...mentionedFiles);
+                if (fileContents.length > 0) {
+                    contextParts.push(`\n--- Content from referenced files ---`);
+                    for (const { path: filePath, content } of fileContents) {
+                        contextParts.push(`\nContent from @${filePath}:\n`);
+                        contextParts.push(content);
+                    }
+                }
+            }
+            catch (error) {
+                console.error('Error reading mentioned files:', error);
+                // Fallback to individual file reading
+                contextParts.push(`\n--- Content from referenced files ---`);
+                for (const filePath of mentionedFiles) {
+                    try {
+                        const resolvedPath = await this.resolvePath(filePath, workspaceDirectories);
+                        const content = await this.readFileContent(resolvedPath);
+                        filesRead.push(filePath);
+                        contextParts.push(`\nContent from @${filePath}:\n`);
+                        contextParts.push(content);
+                    }
+                    catch (error) {
+                        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                        contextParts.push(`\nContent from @${filePath}:\n`);
+                        contextParts.push(`[Error loading ${filePath}: ${errorMessage}]`);
+                    }
+                }
+            }
+        }
+        // Process mentioned folders
+        if (mentionedFolders.length > 0) {
+            contextParts.push(`\n--- Folder Structures ---`);
+            for (const folderPath of mentionedFolders) {
+                try {
+                    const resolvedPath = await this.resolvePath(folderPath, workspaceDirectories);
+                    const structure = await this.getFolderStructure(resolvedPath);
+                    filesRead.push(folderPath);
+                    contextParts.push(`\nStructure of @${folderPath}:\n`);
+                    contextParts.push(structure);
+                    // Also read files within the folder
+                    const filesInFolder = await this.getFilesInFolder(resolvedPath);
+                    console.log(`Found ${filesInFolder.length} files in ${folderPath}:`, filesInFolder.map(f => path.basename(f)));
+                    if (filesInFolder.length > 0) {
+                        contextParts.push(`\n--- Files in ${folderPath} ---`);
+                        for (const filePath of filesInFolder) {
+                            try {
+                                console.log(`Attempting to read file: ${filePath}`);
+                                const content = await this.readFileContent(filePath);
+                                const relativePath = path.relative(resolvedPath, filePath);
+                                const displayPath = `${folderPath}/${relativePath}`;
+                                contextParts.push(`\nContent from @${displayPath}:\n`);
+                                contextParts.push(content);
+                                console.log(`Successfully read file: ${displayPath} (${content.length} chars)`);
+                            }
+                            catch (error) {
+                                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                                const relativePath = path.relative(resolvedPath, filePath);
+                                const displayPath = `${folderPath}/${relativePath}`;
+                                console.error(`Error reading file ${displayPath}:`, errorMessage);
+                                contextParts.push(`\nContent from @${displayPath}:\n`);
+                                contextParts.push(`[Error reading file: ${errorMessage}]`);
+                            }
+                        }
+                    }
+                    else {
+                        console.log(`No files found in ${folderPath} (resolved to ${resolvedPath})`);
+                    }
+                }
+                catch (error) {
+                    const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                    contextParts.push(`\nStructure of @${folderPath}:\n`);
+                    contextParts.push(`[Error reading folder ${folderPath}: ${errorMessage}]`);
+                }
+            }
+        }
+        return {
+            success: true,
+            processedContent: this.buildContentParts(contextParts),
+            filesRead
+        };
+    }
+    buildContentParts(contextParts) {
+        const contentParts = [];
+        for (const part of contextParts) {
+            contentParts.push({
+                type: 'text',
+                text: part
+            });
+        }
+        return contentParts;
+    }
+    async resolvePath(pathName, workspaceDirectories) {
+        // Try to resolve the path in workspace directories
+        for (const dir of workspaceDirectories) {
+            try {
+                const absolutePath = path.resolve(dir, pathName);
+                await fs.stat(absolutePath); // Check if path exists
+                return absolutePath;
+            }
+            catch (error) {
+                if (this.isNodeError(error) && error.code === 'ENOENT') {
+                    if (this.options.enableRecursiveSearch) {
+                        // Try glob search
+                        const globResult = await this.globSearch(pathName, dir);
+                        if (globResult) {
+                            return path.resolve(dir, globResult);
+                        }
+                    }
+                }
+            }
+        }
+        // Fallback to original path
+        const projectPath = await this.getProjectPath();
+        return path.isAbsolute(pathName) ? pathName : path.resolve(projectPath, pathName);
+    }
+    async globSearch(pathName, dir) {
+        // Simple glob search implementation
+        try {
+            const pattern = `**/*${pathName}*`;
+            const matches = await this.findFiles(dir, pattern);
+            if (matches.length > 0) {
+                return path.relative(dir, matches[0]);
+            }
+        }
+        catch (error) {
+            console.error('Glob search error:', error);
+        }
+        return null;
+    }
+    async findFiles(dir, pattern) {
+        // Simplified file finding - in real implementation would use proper glob
+        const matches = [];
+        const searchTerm = pattern.replace(/\*\*/g, '').replace(/\*/g, '');
+        try {
+            const entries = await fs.readdir(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.name.includes(searchTerm)) {
+                    matches.push(path.join(dir, entry.name));
+                }
+                if (entry.isDirectory() && !entry.name.startsWith('.')) {
+                    const subMatches = await this.findFiles(path.join(dir, entry.name), pattern);
+                    matches.push(...subMatches);
+                }
+            }
+        }
+        catch (error) {
+            // Ignore errors in subdirectories
+        }
+        return matches.slice(0, 10); // Limit results
+    }
+    async readManyFiles(pathSpecs) {
+        const results = [];
+        // Try to use read_many_files tool if available (like gemini-cli)
+        try {
+            // In a real implementation, this would use the actual tool registry
+            // For now, we'll simulate the tool behavior
+            const toolArgs = {
+                paths: pathSpecs,
+                useDefaultExcludes: true,
+                file_filtering_options: {
+                    respect_git_ignore: DEFAULT_FILE_FILTERING_OPTIONS.respectGitIgnore,
+                    respect_gemini_ignore: DEFAULT_FILE_FILTERING_OPTIONS.respectGeminiIgnore,
+                }
+            };
+            // Simulate read_many_files tool execution
+            for (const pathSpec of pathSpecs) {
+                try {
+                    if (pathSpec.includes('**') || pathSpec.includes('*')) {
+                        // Handle directory patterns
+                        const basePath = pathSpec.replace('/**', '').replace('**', '');
+                        const files = await this.findFiles(basePath, '**/*');
+                        for (const filePath of files.slice(0, 20)) { // Limit files
+                            try {
+                                const content = await this.readFileContent(filePath);
+                                const projectPath = await this.getProjectPath();
+                                results.push({ path: path.relative(projectPath, filePath), content });
+                            }
+                            catch (error) {
+                                results.push({ path: filePath, content: `[Error reading file: ${error}]` });
+                            }
+                        }
+                    }
+                    else {
+                        // Handle single file
+                        const projectPath = await this.getProjectPath();
+                        const resolvedPath = path.isAbsolute(pathSpec) ? pathSpec : path.resolve(projectPath, pathSpec);
+                        const content = await this.readFileContent(resolvedPath);
+                        results.push({ path: pathSpec, content });
+                    }
+                }
+                catch (error) {
+                    results.push({ path: pathSpec, content: `[Error reading: ${error}]` });
+                }
+            }
+        }
+        catch (error) {
+            console.error('Error in readManyFiles:', error);
+            // Fallback to individual file reading
+            for (const pathSpec of pathSpecs) {
+                try {
+                    const projectPath = await this.getProjectPath();
+                    const resolvedPath = path.isAbsolute(pathSpec) ? pathSpec : path.resolve(projectPath, pathSpec);
+                    const content = await this.readFileContent(resolvedPath);
+                    results.push({ path: pathSpec, content });
+                }
+                catch (error) {
+                    results.push({ path: pathSpec, content: `[Error reading: ${error}]` });
+                }
+            }
+        }
+        return results;
+    }
+    async readFileContent(filePath) {
+        // Check file size
+        const stats = await fs.stat(filePath);
+        if (stats.size > this.options.maxFileSize) {
+            throw new Error(`File too large: ${stats.size} bytes`);
+        }
+        // Check file extension
+        if (this.options.allowedExtensions.length > 0) {
+            const ext = path.extname(filePath).toLowerCase();
+            if (!this.options.allowedExtensions.includes(ext)) {
+                throw new Error(`File type not allowed: ${ext}`);
+            }
+        }
+        const content = await fs.readFile(filePath, 'utf-8');
+        return content;
+    }
+    async getFilesInFolder(folderPath) {
+        try {
+            const entries = await fs.readdir(folderPath, { withFileTypes: true });
+            const files = [];
+            for (const entry of entries) {
+                if (entry.isFile() && !entry.name.startsWith('.')) {
+                    // Check file extension if allowed extensions are specified
+                    if (this.options.allowedExtensions.length > 0) {
+                        const ext = path.extname(entry.name).toLowerCase();
+                        console.log(`Checking file ${entry.name} with extension ${ext}. Allowed:`, this.options.allowedExtensions);
+                        if (this.options.allowedExtensions.includes(ext)) {
+                            files.push(path.join(folderPath, entry.name));
+                        }
+                        else {
+                            console.log(`File ${entry.name} extension ${ext} not in allowed list`);
+                        }
+                    }
+                    else {
+                        files.push(path.join(folderPath, entry.name));
+                    }
+                }
+            }
+            // Limit number of files to avoid overwhelming output
+            return files.slice(0, 10);
+        }
+        catch (error) {
+            console.error('Error reading files in folder:', error);
+            return [];
+        }
+    }
+    async getFolderStructure(folderPath) {
+        // Check if folder exists and is readable
+        const stats = await fs.stat(folderPath);
+        if (!stats.isDirectory()) {
+            throw new Error(`${folderPath} is not a directory`);
+        }
+        // Read directory structure
+        const entries = await fs.readdir(folderPath, { withFileTypes: true });
+        const lines = [];
+        // Sort entries: directories first, then files
+        const sortedEntries = entries.sort((a, b) => {
+            if (a.isDirectory() && !b.isDirectory())
+                return -1;
+            if (!a.isDirectory() && b.isDirectory())
+                return 1;
+            return a.name.localeCompare(b.name);
+        });
+        for (const entry of sortedEntries.slice(0, 50)) { // Limit to 50 entries
+            if (entry.name.startsWith('.'))
+                continue; // Skip hidden files
+            if (entry.isDirectory()) {
+                lines.push(`${path.basename(folderPath)}/${entry.name}/`);
+            }
+            else {
+                const filePath = path.join(folderPath, entry.name);
+                const fileStats = await fs.stat(filePath);
+                const size = fileStats.size < 1024 ? `${fileStats.size}B` : `${Math.round(fileStats.size / 1024)}KB`;
+                lines.push(`${path.basename(folderPath)}/${entry.name} (${size})`);
+            }
+        }
+        if (entries.length > 50) {
+            lines.push(`... and ${entries.length - 50} more items`);
+        }
+        return lines.join('\n');
+    }
+    findLastUserMessage(messages) {
+        for (let i = messages.length - 1; i >= 0; i--) {
+            if (messages[i].role === 'user') {
+                return i;
+            }
+        }
+        return -1;
+    }
+    async getProjectPath() {
+        try {
+            const { projectPath } = await codeboltjs_1.default.project.getProjectPath();
+            return projectPath || process.cwd();
+        }
+        catch (error) {
+            console.warn('Failed to get project path from codebolt.project.getProjectPath(), falling back to process.cwd()');
+            return process.cwd();
+        }
+    }
+    isNodeError(error) {
+        return error instanceof Error && 'code' in error;
+    }
+}
+exports.AtFileProcessorModifier = AtFileProcessorModifier;

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,18 @@
+import { ProcessedMessage } from "@codebolt/types/agent";
+import { BaseMessageModifier } from "../base";
+import { FlatUserMessage } from "@codebolt/types/sdk";
+export interface ChatHistoryMessageModifierOptions {
+    enableChatHistory?: boolean;
+    maxHistoryMessages?: number;
+    includeSystemMessages?: boolean;
+    [key: string]: unknown;
+}
+export declare class ChatHistoryMessageModifier extends BaseMessageModifier {
+    private readonly enableChatHistory;
+    private readonly maxHistoryMessages;
+    private readonly includeSystemMessages;
+    constructor(options?: ChatHistoryMessageModifierOptions);
+    modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
+    private getChatHistory;
+    setMaxHistoryMessages(max: number): void;
+}