@codebolt/agent 6.1.6 → 6.1.8

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

@@ -18,7 +18,6 @@ export declare class AtFileProcessorModifier extends BaseMessageModifier {
     private findFiles;
     private readManyFiles;
     private readFileContent;
-    private getFilesInFolder;
     private getFolderStructure;
     private findLastUserMessage;
     private getProjectPath;

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

@@ -182,40 +182,12 @@ class AtFileProcessorModifier extends base_1.BaseMessageModifier {
                     const resolvedPath = await this.resolvePath(folderPath, workspaceDirectories);
                     const structure = await this.getFolderStructure(resolvedPath);
                     filesRead.push(folderPath);
-                    contextParts.push(`\nStructure of @${folderPath}:\n`);
+                    contextParts.push(`\nDirectory listing for @${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(`\nDirectory listing for @${folderPath}:\n`);
                     contextParts.push(`[Error reading folder ${folderPath}: ${errorMessage}]`);
                 }
             }
@@ -360,26 +332,6 @@ class AtFileProcessorModifier extends base_1.BaseMessageModifier {
         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('.')) {
-                    const filePath = path.join(folderPath, entry.name);
-                    if (await this.isReadableTextFile(filePath)) {
-                        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);
@@ -388,30 +340,10 @@ class AtFileProcessorModifier extends base_1.BaseMessageModifier {
         }
         // 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`);
+        const maxDirectoryEntries = 1000;
+        const lines = entries.slice(0, maxDirectoryEntries).map((entry) => entry.name);
+        if (entries.length > maxDirectoryEntries) {
+            lines.push(`\u2026 and ${entries.length - maxDirectoryEntries} more entries`);
         }
         return lines.join('\n');
     }

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

@@ -0,0 +1,14 @@
+import { ProcessedMessage } from "@codebolt/types/agent";
+import { BaseMessageModifier } from "../base";
+import { FlatUserMessage } from "@codebolt/types/sdk";
+export interface CapabilityContextModifierOptions {
+    timeout?: number;
+}
+export declare class CapabilityContextModifier extends BaseMessageModifier {
+    private readonly options;
+    constructor(options?: CapabilityContextModifierOptions);
+    modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
+    private normalizeCapabilities;
+    private resolveCapabilityContext;
+    private formatCapabilityContext;
+}

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

@@ -0,0 +1,133 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CapabilityContextModifier = void 0;
+const base_1 = require("../base");
+const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
+const promptContext_1 = require("../../unified/base/promptContext");
+class CapabilityContextModifier extends base_1.BaseMessageModifier {
+    constructor(options = {}) {
+        super();
+        this.options = options;
+    }
+    async modify(originalRequest, createdMessage) {
+        const selectedCapabilities = this.normalizeCapabilities(originalRequest.selectedCapabilities);
+        if (selectedCapabilities.length === 0) {
+            return createdMessage;
+        }
+        const resolvedContexts = [];
+        const capabilityErrors = [];
+        for (const capabilityName of selectedCapabilities) {
+            const resolvedContext = await this.resolveCapabilityContext(capabilityName, originalRequest);
+            if (resolvedContext.context) {
+                resolvedContexts.push(resolvedContext.context);
+            }
+            if (resolvedContext.error) {
+                capabilityErrors.push(resolvedContext.error);
+            }
+        }
+        if (resolvedContexts.length === 0) {
+            return {
+                ...createdMessage,
+                metadata: {
+                    ...createdMessage.metadata,
+                    selectedCapabilities,
+                    selectedCapabilityErrors: capabilityErrors,
+                    selectedCapabilitiesProcessed: false,
+                },
+            };
+        }
+        const contextMessage = {
+            role: 'user',
+            content: this.formatCapabilityContext(resolvedContexts),
+        };
+        return {
+            ...(0, promptContext_1.appendUserContextMessage)(createdMessage, contextMessage),
+            metadata: {
+                ...createdMessage.metadata,
+                selectedCapabilities,
+                selectedCapabilitiesProcessed: true,
+                selectedCapabilityNames: resolvedContexts.map((context) => context.name),
+                selectedCapabilityErrors: capabilityErrors,
+            },
+        };
+    }
+    normalizeCapabilities(selectedCapabilities) {
+        if (!Array.isArray(selectedCapabilities)) {
+            return [];
+        }
+        return Array.from(new Set(selectedCapabilities
+            .map((capabilityName) => capabilityName.trim())
+            .filter(Boolean)));
+    }
+    async resolveCapabilityContext(capabilityName, originalRequest) {
+        var _a, _b;
+        try {
+            const capabilityDetail = await codeboltjs_1.default.capability.getCapabilityDetail(capabilityName);
+            if (!(capabilityDetail === null || capabilityDetail === void 0 ? void 0 : capabilityDetail.success) || !((_a = capabilityDetail.capability) === null || _a === void 0 ? void 0 : _a.type)) {
+                return {
+                    error: {
+                        name: capabilityName,
+                        error: (capabilityDetail === null || capabilityDetail === void 0 ? void 0 : capabilityDetail.error) || 'Capability detail did not include a capability type',
+                    },
+                };
+            }
+            const capabilityType = capabilityDetail.capability.type;
+            const response = await codeboltjs_1.default.capability.startCapability(capabilityName, capabilityType, {
+                arguments: originalRequest.userMessage,
+                input: originalRequest.userMessage,
+                task: originalRequest.userMessage,
+            }, this.options.timeout);
+            if (!(response === null || response === void 0 ? void 0 : response.success)) {
+                return {
+                    error: {
+                        name: capabilityName,
+                        error: (response === null || response === void 0 ? void 0 : response.error) || 'Capability did not return a successful response',
+                    },
+                };
+            }
+            const skillPrompt = ((_b = response.additionalContext) === null || _b === void 0 ? void 0 : _b['skillPrompt']) || response.result;
+            const prompt = typeof (skillPrompt === null || skillPrompt === void 0 ? void 0 : skillPrompt.prompt) === 'string' ? skillPrompt.prompt.trim() : '';
+            if (!prompt) {
+                return {
+                    error: {
+                        name: capabilityName,
+                        error: 'Capability response did not include prompt context',
+                    },
+                };
+            }
+            return {
+                context: {
+                    name: skillPrompt.skillName || capabilityName,
+                    type: capabilityType,
+                    prompt,
+                    refs: skillPrompt.refs,
+                    metadata: skillPrompt.metadata,
+                },
+            };
+        }
+        catch (error) {
+            return {
+                error: {
+                    name: capabilityName,
+                    error: error instanceof Error ? error.message : String(error),
+                },
+            };
+        }
+    }
+    formatCapabilityContext(resolvedContexts) {
+        const contextSections = resolvedContexts.map((context) => {
+            const refs = Array.isArray(context.refs) && context.refs.length > 0
+                ? `\n\nCapability references:\n${context.refs.map((ref) => `- ${JSON.stringify(ref)}`).join('\n')}`
+                : '';
+            return `--- Selected capability: ${context.name} (${context.type}) ---\n${context.prompt}${refs}`;
+        });
+        return [
+            'The user selected the following capabilities for this turn. Use this capability context while answering the user.',
+            ...contextSections,
+        ].join('\n\n');
+    }
+}
+exports.CapabilityContextModifier = CapabilityContextModifier;

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

@@ -3,6 +3,7 @@ export { CoreSystemPromptModifier, type CoreSystemPromptOptions } from './coreSy
 export { DirectoryContextModifier, type DirectoryContextOptions } from './directoryContextModifier';
 export { IdeContextModifier, type IdeContextOptions, type FileInfo, type IdeContext } from './ideContextModifier';
 export { AtFileProcessorModifier, type AtFileProcessorOptions } from './atFileProcessorModifier';
+export { CapabilityContextModifier, type CapabilityContextModifierOptions } from './capabilityContextModifier';
 export { ArgumentProcessorModifier, type ArgumentProcessorOptions } from './argumentProcessorModifier';
 export { MemoryImportModifier, type MemoryImportOptions } from './memoryImportModifier';
 export { LoopDetectionModifier, type LoopDetectionOptions } from '../postInferenceProcessors/loopDetectionModifier';

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MemoryTypeContextModifier = exports.RuleBasedContextModifier = exports.ContextAssemblyModifier = exports.ChatHistoryMessageModifier = exports.ChatRecordingModifier = exports.ToolInjectionModifier = exports.LoopDetectionModifier = exports.MemoryImportModifier = exports.ArgumentProcessorModifier = exports.AtFileProcessorModifier = exports.IdeContextModifier = exports.DirectoryContextModifier = exports.CoreSystemPromptModifier = exports.EnvironmentContextModifier = void 0;
+exports.MemoryTypeContextModifier = exports.RuleBasedContextModifier = exports.ContextAssemblyModifier = exports.ChatHistoryMessageModifier = exports.ChatRecordingModifier = exports.ToolInjectionModifier = exports.LoopDetectionModifier = exports.MemoryImportModifier = exports.ArgumentProcessorModifier = exports.CapabilityContextModifier = exports.AtFileProcessorModifier = exports.IdeContextModifier = exports.DirectoryContextModifier = exports.CoreSystemPromptModifier = exports.EnvironmentContextModifier = void 0;
 // Gemini-CLI equivalent modifiers
 var environmentContextModifier_1 = require("./environmentContextModifier");
 Object.defineProperty(exports, "EnvironmentContextModifier", { enumerable: true, get: function () { return environmentContextModifier_1.EnvironmentContextModifier; } });
@@ -12,6 +12,8 @@ var ideContextModifier_1 = require("./ideContextModifier");
 Object.defineProperty(exports, "IdeContextModifier", { enumerable: true, get: function () { return ideContextModifier_1.IdeContextModifier; } });
 var atFileProcessorModifier_1 = require("./atFileProcessorModifier");
 Object.defineProperty(exports, "AtFileProcessorModifier", { enumerable: true, get: function () { return atFileProcessorModifier_1.AtFileProcessorModifier; } });
+var capabilityContextModifier_1 = require("./capabilityContextModifier");
+Object.defineProperty(exports, "CapabilityContextModifier", { enumerable: true, get: function () { return capabilityContextModifier_1.CapabilityContextModifier; } });
 var argumentProcessorModifier_1 = require("./argumentProcessorModifier");
 Object.defineProperty(exports, "ArgumentProcessorModifier", { enumerable: true, get: function () { return argumentProcessorModifier_1.ArgumentProcessorModifier; } });
 var memoryImportModifier_1 = require("./memoryImportModifier");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codebolt/agent",
-  "version": "6.1.6",
+  "version": "6.1.8",
   "description": "CodeBolt Agent utilities for building and managing AI agents",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",