@codebolt/agent 2.2.2 → 2.2.5

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

@@ -37,37 +37,49 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorkingDirectoryMessageModifier = void 0;
-const processor_1 = require("../../processor");
+const base_1 = require("../base");
 const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
 const path = __importStar(require("path"));
-class WorkingDirectoryMessageModifier extends processor_1.BaseMessageModifier {
+const fs = __importStar(require("fs/promises"));
+class WorkingDirectoryMessageModifier extends base_1.BaseMessageModifier {
     constructor(options = {}) {
         super({ context: options });
+        this.defaultIgnoredFolders = new Set(['node_modules', '.git', 'dist', '.codebolt', '.codeboltAgents']);
+        this.truncationIndicator = '...';
         this.showFolderStructureSummary = options.showFolderStructureSummary || false;
         this.listFiles = options.listFiles || false;
         this.listFilesDepth = options.listFilesDepth || 2;
-        this.listFilesLimit = options.listFilesLimit || 200;
+        this.listFilesLimit = options.listFilesLimit || 100;
         this.listFilesIgnoreFromGitignore = options.listFilesIgnoreFromGitignore || true;
-        this.listFilesIgnore = options.listFilesIgnore || ['node_modules', '.git', 'dist', 'build'];
+        this.listFilesIgnore = options.listFilesIgnore || ['node_modules', '.git', 'dist', '.codebolt', '.codeboltAgents'];
+        this.maxItems = options.maxItems || 200;
+        this.showFullDirectoryContext = options.showFullDirectoryContext || true;
     }
-    async modify(input) {
+    async modify(originalRequest, createdMessage) {
         try {
-            const { originalRequest, createdMessage, context } = input;
             const contextParts = [];
             // Get project information
             try {
-                const projectPathResponse = await codeboltjs_1.default.project.getProjectPath();
-                const projectPath = typeof projectPathResponse === 'string'
-                    ? projectPathResponse
-                    : (projectPathResponse === null || projectPathResponse === void 0 ? void 0 : projectPathResponse.path) || String(projectPathResponse) || '';
-                contextParts.push(`Project Directory: ${projectPath}`);
-                if (this.showFolderStructureSummary) {
-                    const summary = await this.generateFolderStructureSummary(projectPath);
-                    contextParts.push(`Folder Structure Summary:\n${summary}`);
+                const { projectPath } = await codeboltjs_1.default.project.getProjectPath();
+                if (!projectPath) {
+                    throw new Error('Project path not available');
                 }
-                if (this.listFiles) {
-                    const filesList = await this.generateFilesList(projectPath);
-                    contextParts.push(`Files List:\n${filesList}`);
+                // Generate comprehensive directory context similar to gemini-cli
+                if (this.showFullDirectoryContext) {
+                    const directoryContext = await this.getDirectoryContextString(projectPath);
+                    contextParts.push(directoryContext);
+                }
+                else {
+                    // Fallback to original behavior
+                    contextParts.push(`Project Directory: ${projectPath}`);
+                    if (this.showFolderStructureSummary) {
+                        const summary = await this.generateFolderStructureSummary(projectPath);
+                        contextParts.push(`Folder Structure Summary:\n${summary}`);
+                    }
+                    if (this.listFiles) {
+                        const filesList = await this.generateFilesList(projectPath);
+                        contextParts.push(`Files List:\n${filesList}`);
+                    }
                 }
             }
             catch (error) {
@@ -76,13 +88,30 @@ class WorkingDirectoryMessageModifier extends processor_1.BaseMessageModifier {
             }
             // Create context message if we have any context parts
             if (contextParts.length > 0) {
-                const contextMessage = {
-                    role: 'system',
-                    content: contextParts.join('\n\n'),
-                    name: 'working-directory-context'
-                };
+                const contextContent = contextParts.join('\n\n');
+                const messages = [...createdMessage.message.messages];
+                // Find existing system message
+                const systemMessageIndex = messages.findIndex(msg => msg.role === 'system');
+                if (systemMessageIndex !== -1) {
+                    // Update existing system message
+                    messages[systemMessageIndex] = {
+                        ...messages[systemMessageIndex],
+                        content: `${messages[systemMessageIndex].content}\n\n${contextContent}`
+                    };
+                }
+                else {
+                    // Add new system message at the top
+                    messages.unshift({
+                        role: 'system',
+                        content: contextContent
+                    });
+                }
                 return {
-                    messages: [contextMessage, ...createdMessage.messages],
+                    ...createdMessage,
+                    message: {
+                        ...createdMessage.message,
+                        messages
+                    },
                     metadata: {
                         ...createdMessage.metadata,
                         workingDirectoryContextAdded: true,
@@ -99,44 +128,14 @@ class WorkingDirectoryMessageModifier extends processor_1.BaseMessageModifier {
     }
     async generateFolderStructureSummary(projectPath) {
         try {
-            // Use CodeBolt's directory listing with recursive option
-            const response = await codeboltjs_1.default.fs.listDirectory({
-                path: projectPath,
-                show_hidden: false,
-                detailed: false,
-                limit: 200,
-                notifyUser: false
-            });
             const directories = new Set();
-            // Extract directories from the response
-            if (response && response.success) {
-                let entries;
-                if (typeof response.result === 'string') {
-                    // If result is a string, we'll need to parse it or work with what we have
-                    return response.result.split('\n').slice(0, 20).join('\n');
-                }
-                else if (response.result && response.result.entries) {
-                    entries = response.result.entries;
-                }
-                else if (response.entries) {
-                    entries = response.entries;
-                }
-                if (entries) {
-                    entries.forEach((entry) => {
-                        if (entry.type === 'directory' && !this.shouldIgnore(entry.path || entry.name)) {
-                            directories.add(entry.path || entry.name);
-                        }
-                        // Also get parent directories of files
-                        const dir = path.dirname(entry.path || entry.name);
-                        if (dir !== '.' && !this.shouldIgnore(dir)) {
-                            directories.add(dir);
-                        }
-                    });
-                }
-            }
-            const sortedDirs = Array.from(directories).sort();
+            await this.collectDirectories(projectPath, directories, 0, 3); // Max depth of 3
+            const sortedDirs = Array.from(directories)
+                .filter(dir => dir !== projectPath && !this.shouldIgnore(dir))
+                .sort()
+                .slice(0, 20);
             return sortedDirs.length > 0
-                ? sortedDirs.slice(0, 20).join('\n')
+                ? sortedDirs.join('\n')
                 : 'No accessible directories found';
         }
         catch (error) {
@@ -145,40 +144,12 @@ class WorkingDirectoryMessageModifier extends processor_1.BaseMessageModifier {
     }
     async generateFilesList(projectPath) {
         try {
-            // Use CodeBolt's directory listing to get files
-            const response = await codeboltjs_1.default.fs.listDirectory({
-                path: projectPath,
-                show_hidden: false,
-                detailed: false,
-                limit: this.listFilesLimit,
-                notifyUser: false
-            });
             const files = [];
-            // Extract files from the response
-            if (response && response.success) {
-                let entries;
-                if (typeof response.result === 'string') {
-                    // If result is a string, split and filter for files
-                    return response.result.split('\n')
-                        .filter((line) => !this.shouldIgnore(line))
-                        .slice(0, this.listFilesLimit)
-                        .join('\n');
-                }
-                else if (response.result && response.result.entries) {
-                    entries = response.result.entries;
-                }
-                else if (response.entries) {
-                    entries = response.entries;
-                }
-                if (entries) {
-                    entries.forEach((entry) => {
-                        if (entry.type === 'file' && !this.shouldIgnore(entry.path || entry.name)) {
-                            files.push(entry.path || entry.name);
-                        }
-                    });
-                }
-            }
-            const filteredFiles = files.slice(0, this.listFilesLimit);
+            await this.collectFiles(projectPath, files, 0, 2); // Max depth of 2
+            const filteredFiles = files
+                .filter(filePath => !this.shouldIgnore(filePath))
+                .slice(0, this.listFilesLimit)
+                .map(filePath => path.basename(filePath));
             return filteredFiles.length > 0
                 ? filteredFiles.join('\n')
                 : 'No accessible files found';
@@ -187,8 +158,235 @@ class WorkingDirectoryMessageModifier extends processor_1.BaseMessageModifier {
             return 'Unable to generate files list';
         }
     }
+    async collectDirectories(dirPath, directories, currentDepth, maxDepth) {
+        if (currentDepth >= maxDepth)
+            return;
+        try {
+            const entries = await fs.readdir(dirPath, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.isDirectory()) {
+                    const fullPath = path.join(dirPath, entry.name);
+                    if (!this.shouldIgnore(fullPath)) {
+                        directories.add(fullPath);
+                        await this.collectDirectories(fullPath, directories, currentDepth + 1, maxDepth);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            // Skip directories we can't read
+        }
+    }
+    async collectFiles(dirPath, files, currentDepth, maxDepth) {
+        if (currentDepth >= maxDepth || files.length >= this.listFilesLimit)
+            return;
+        try {
+            const entries = await fs.readdir(dirPath, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.isFile()) {
+                    const fullPath = path.join(dirPath, entry.name);
+                    if (!this.shouldIgnore(fullPath)) {
+                        files.push(fullPath);
+                        if (files.length >= this.listFilesLimit)
+                            break;
+                    }
+                }
+                else if (entry.isDirectory() && currentDepth < maxDepth - 1) {
+                    const fullPath = path.join(dirPath, entry.name);
+                    if (!this.shouldIgnore(fullPath)) {
+                        await this.collectFiles(fullPath, files, currentDepth + 1, maxDepth);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            // Skip directories we can't read
+        }
+    }
     shouldIgnore(filePath) {
-        return this.listFilesIgnore.some(ignore => filePath.includes(ignore) || path.basename(filePath) === ignore);
+        const basename = path.basename(filePath);
+        // Ignore any folder/file that starts with a dot
+        if (basename.startsWith('.')) {
+            return true;
+        }
+        return this.listFilesIgnore.some(ignore => filePath.includes(ignore) || basename === ignore);
+    }
+    // Comprehensive directory context methods exactly like gemini-cli
+    async getDirectoryContextString(projectPath) {
+        const folderStructure = await this.getFolderStructure(projectPath);
+        const workingDirPreamble = `I'm currently working in the directory: ${projectPath}`;
+        return `${workingDirPreamble}
+Here is the folder structure of the current working directories:
+
+${folderStructure}`;
+    }
+    async getFolderStructure(directory) {
+        const resolvedPath = path.resolve(directory);
+        try {
+            const structureRoot = await this.readFullStructure(resolvedPath);
+            if (!structureRoot) {
+                return `Error: Could not read directory "${resolvedPath}". Check path and permissions.`;
+            }
+            const structureLines = [];
+            this.formatStructure(structureRoot, '', true, true, structureLines);
+            const isTruncated = this.isTruncated(structureRoot);
+            let summary = `Showing up to ${this.maxItems} items (files + folders).`;
+            if (isTruncated) {
+                summary += ` Folders or files indicated with ${this.truncationIndicator} contain more items not shown, were ignored, or the display limit (${this.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}": ${error instanceof Error ? error.message : String(error)}`;
+        }
+    }
+    async readFullStructure(rootPath) {
+        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 >= this.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 >= this.maxItems) {
+                        folderInfo.hasMoreFiles = true;
+                        break;
+                    }
+                    const fileName = entry.name;
+                    const filePath = path.join(currentPath, fileName);
+                    if (!this.shouldIgnore(filePath)) {
+                        filesInCurrentDir.push(fileName);
+                        currentItemCount++;
+                        folderInfo.totalFiles++;
+                        folderInfo.totalChildren++;
+                    }
+                }
+            }
+            folderInfo.files = filesInCurrentDir;
+            // Process directories
+            for (const entry of entries) {
+                if (entry.isDirectory()) {
+                    if (currentItemCount >= this.maxItems) {
+                        folderInfo.hasMoreSubfolders = true;
+                        break;
+                    }
+                    const subFolderName = entry.name;
+                    const subFolderPath = path.join(currentPath, subFolderName);
+                    const isIgnored = this.defaultIgnoredFolders.has(subFolderName) ||
+                        subFolderName.startsWith('.') ||
+                        this.shouldIgnore(subFolderPath);
+                    if (isIgnored) {
+                        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;
+    }
+    formatStructure(node, currentIndent, isLastChildOfParent, isProcessingRootNode, builder) {
+        const connector = isLastChildOfParent ? '└───' : '├───';
+        if (!isProcessingRootNode || node.isIgnored) {
+            builder.push(`${currentIndent}${connector}${node.name}${path.sep}${node.isIgnored ? this.truncationIndicator : ''}`);
+        }
+        const indentForChildren = isProcessingRootNode
+            ? ''
+            : currentIndent + (isLastChildOfParent ? '    ' : '│   ');
+        // Render files
+        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}${this.truncationIndicator}`);
+        }
+        // Render subfolders
+        const subFolderCount = node.subFolders.length;
+        for (let i = 0; i < subFolderCount; i++) {
+            const isLastSubfolderAmongSiblings = i === subFolderCount - 1 && !node.hasMoreSubfolders;
+            this.formatStructure(node.subFolders[i], indentForChildren, isLastSubfolderAmongSiblings, false, builder);
+        }
+        if (node.hasMoreSubfolders) {
+            builder.push(`${indentForChildren}└───${this.truncationIndicator}`);
+        }
+    }
+    isTruncated(node) {
+        if (node.hasMoreFiles || node.hasMoreSubfolders || node.isIgnored) {
+            return true;
+        }
+        for (const sub of node.subFolders) {
+            if (this.isTruncated(sub)) {
+                return true;
+            }
+        }
+        return false;
     }
 }
 exports.WorkingDirectoryMessageModifier = WorkingDirectoryMessageModifier;

package/dist/processor-pieces/postInference/llmOutputValidityProcessor.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/processor-pieces/postInference/llmOutputValidityProcessor.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/processor-pieces/postInferenceProcessors/checkForNoToolCall.d.ts

@@ -0,0 +1,7 @@
+import { ProcessedMessage } from "@codebolt/types/agent";
+import { BasePostInferenceProcessor } from "../base";
+import { LLMResponse } from "@codebolt/types/sdk";
+export declare class CheckForNoToolCall extends BasePostInferenceProcessor {
+    constructor();
+    modify(llmMessageSent: ProcessedMessage, llmResponseMessage: LLMResponse, nextPrompt: ProcessedMessage): Promise<ProcessedMessage>;
+}

package/dist/processor-pieces/postInferenceProcessors/checkForNoToolCall.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CheckForNoToolCall = void 0;
+const base_1 = require("../base");
+class CheckForNoToolCall extends base_1.BasePostInferenceProcessor {
+    constructor() {
+        super();
+    }
+    modify(llmMessageSent, llmResponseMessage, nextPrompt) {
+        // Check if tool_calls exist in the LLM response
+        const hasToolCalls = llmResponseMessage.tool_calls && llmResponseMessage.tool_calls.length > 0;
+        if (!hasToolCalls) {
+            // Create a new message indicating no tool call was found
+            const noToolCallMessage = {
+                role: 'user',
+                content: 'no tool call found in request'
+            };
+            nextPrompt.message.messages.push(noToolCallMessage);
+        }
+        // If tool calls exist, return the nextPrompt unchanged
+        return Promise.resolve(nextPrompt);
+    }
+}
+exports.CheckForNoToolCall = CheckForNoToolCall;

package/dist/processor-pieces/postToolCall/advancedLoopDetectionProcessor.d.ts

@@ -0,0 +1,41 @@
+import { BaseProcessor, ProcessorInput, ProcessorOutput } from '../../processor';
+export interface AdvancedLoopDetectionProcessorOptions {
+    toolCallThreshold?: number;
+    contentLoopThreshold?: number;
+    contentChunkSize?: number;
+    maxHistoryLength?: number;
+    enableLLMDetection?: boolean;
+    llmCheckAfterTurns?: number;
+    defaultLLMCheckInterval?: number;
+}
+export declare class AdvancedLoopDetectionProcessor extends BaseProcessor {
+    private readonly toolCallThreshold;
+    private readonly contentLoopThreshold;
+    private readonly contentChunkSize;
+    private readonly maxHistoryLength;
+    private readonly enableLLMDetection;
+    private readonly llmCheckAfterTurns;
+    private readonly defaultLLMCheckInterval;
+    private lastToolCallKey;
+    private toolCallRepetitionCount;
+    private streamContentHistory;
+    private contentStats;
+    private lastContentIndex;
+    private loopDetected;
+    private inCodeBlock;
+    private turnsInCurrentPrompt;
+    private llmCheckInterval;
+    private lastCheckTurn;
+    constructor(options?: AdvancedLoopDetectionProcessorOptions);
+    processInput(input: ProcessorInput): Promise<ProcessorOutput[]>;
+    private getToolCallKey;
+    private checkToolCallLoop;
+    private checkContentLoop;
+    private truncateAndUpdate;
+    private analyzeContentChunksForLoop;
+    private hasMoreChunksToProcess;
+    private isLoopDetectedForChunk;
+    private isActualContentMatch;
+    private resetContentTracking;
+    reset(): void;
+}