@codebolt/agent 2.2.2 → 2.2.5

package/dist/builderpattern/agent.js

@@ -258,9 +258,9 @@ class Agent {
     async executeTool(toolName, toolInput) {
         //codebolttools--readfile
         const [toolboxName, actualToolName] = toolName.split('--');
-        console.log("Toolbox name: ", toolboxName, "Actual tool name: ", actualToolName);
+        // console.log("Toolbox name: ", toolboxName, "Actual tool name: ", actualToolName);
         const { data } = await mcp.executeTool(toolboxName, actualToolName, toolInput);
-        console.log("Tool result: ", data);
+        // console.log("Tool result: ", data);
         return data;
     }
     /**

package/dist/builderpattern/followupquestionbuilder.js

@@ -143,7 +143,7 @@ class FollowUpPromptBuilder {
             return this.previousConversation;
         }
         try {
-            console.log("Summarizing conversation due to length:", this.previousConversation.length);
+            // console.log("Summarizing conversation due to length:", this.previousConversation.length);
             // Convert OpenAI messages to the format expected by chatSummary
             const messagesToSummarize = this.previousConversation.map(msg => ({
                 role: msg.role,

package/dist/builderpattern/llmoutputhandler.js

@@ -137,7 +137,7 @@ class LLMOutputHandler {
             let toolResults = [];
             let taskCompletedBlock;
             let userRejectedToolUse = false;
-            console.log("Calling run tool: ", JSON.stringify(this.llmResponse.completion));
+            // console.log("Calling run tool: ", JSON.stringify(this.llmResponse.completion));
             const contentBlock = this.llmResponse.completion.choices[0];
             // Validate contentBlock structure
             if (!contentBlock || !contentBlock.message) {
@@ -174,12 +174,12 @@ class LLMOutputHandler {
                                     }
                                 }
                                 else {
-                                    console.log("Executing tool: ", toolName, toolInput);
+                                    // console.log("Executing tool: ", toolName, toolInput);
                                     const [didUserReject, result] = await this.executeTool(toolName, toolInput);
-                                    console.log("Tool result: ", result);
+                                    // console.log("Tool result: ", result);
                                     // toolResults.push(this.getToolResult(toolUseId, result));
                                     let toolResult = this.getToolResult(toolUseId, result);
-                                    console.log("tool result after parsing", toolResult);
+                                    // console.log("tool result after parsing", toolResult);
                                     this.toolResults.push({
                                         role: "tool",
                                         tool_call_id: toolResult.tool_call_id,
@@ -367,9 +367,9 @@ class LLMOutputHandler {
         var _a;
         //codeboltmcp--readfile
         const [toolboxName, actualToolName] = toolName.split('--');
-        console.log("Toolbox name: ", toolboxName, "Actual tool name: ", actualToolName);
+        // console.log("Toolbox name: ", toolboxName, "Actual tool name: ", actualToolName);
         const data = await ((_a = this.codebolt) === null || _a === void 0 ? void 0 : _a.mcp.executeTool(toolboxName, actualToolName, toolInput));
-        console.log("Tool result: ", data);
+        // console.log("Tool result: ", data);
         return data;
     }
     /**
@@ -389,7 +389,7 @@ class LLMOutputHandler {
             // Only attempt to parse if content looks like JSON
             if (content.trim().startsWith('{') || content.trim().startsWith('[')) {
                 const parsed = JSON.parse(content);
-                console.log("Parsed Content: ", parsed);
+                // console.log("Parsed Content: ", parsed);
                 if (parsed && typeof parsed === 'object' && parsed.payload && parsed.payload.content) {
                     content = `The browser action has been executed. The screenshot have been captured for your analysis. The tool response is provided in the next user message`;
                     userMessage = parsed.payload.content;

package/dist/builderpattern/usermessage.d.ts

@@ -58,7 +58,12 @@ declare class UserMessage {
      *
      * @returns Promise with an array of MCP tools
      */
-    getMentionedMcpsTools(): Promise<any>;
+    getMentionedMcpsTools(): Promise<{
+        toolbox: string;
+        toolName: string;
+        description?: string;
+        parameters?: Record<string, unknown>;
+    }[] | undefined>;
     /**
      * Gets environment details for the current working directory.
      *

package/dist/composablepattern/document.js

@@ -3,39 +3,6 @@
  * @fileoverview Document handling for Composable Agent Pattern
  * @description Provides document processing, chunking, and embedding capabilities
  */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MDocument = void 0;
 /**
@@ -91,8 +58,8 @@ class MDocument {
      * @returns Promise<MDocument> instance
      */
     static async fromFile(filePath, metadata) {
-        const fs = await Promise.resolve().then(() => __importStar(require('fs/promises')));
-        const path = await Promise.resolve().then(() => __importStar(require('path')));
+        const fs = await import('fs/promises');
+        const path = await import('path');
         const content = await fs.readFile(filePath, 'utf-8');
         const extension = path.extname(filePath).toLowerCase();
         let type = 'text';

package/dist/local-tools/fileTools.d.ts

@@ -0,0 +1,26 @@
+import { BaseTool } from '../processor';
+export declare class FileReadTool extends BaseTool {
+    constructor();
+    execute(params: any, abortSignal?: AbortSignal): Promise<string>;
+    protected validateParameters(params: any): boolean;
+}
+export declare class FileWriteTool extends BaseTool {
+    constructor();
+    execute(params: any, abortSignal?: AbortSignal): Promise<string>;
+    protected validateParameters(params: any): boolean;
+}
+export declare class FileDeleteTool extends BaseTool {
+    constructor();
+    execute(params: any, abortSignal?: AbortSignal): Promise<string>;
+    protected validateParameters(params: any): boolean;
+}
+export declare class FileMoveTool extends BaseTool {
+    constructor();
+    execute(params: any, abortSignal?: AbortSignal): Promise<string>;
+    protected validateParameters(params: any): boolean;
+}
+export declare class FileCopyTool extends BaseTool {
+    constructor();
+    execute(params: any, abortSignal?: AbortSignal): Promise<string>;
+    protected validateParameters(params: any): boolean;
+}

package/dist/local-tools/fileTools.js

@@ -0,0 +1,162 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileCopyTool = exports.FileMoveTool = exports.FileDeleteTool = exports.FileWriteTool = exports.FileReadTool = void 0;
+const processor_1 = require("../processor");
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+class FileReadTool extends processor_1.BaseTool {
+    constructor() {
+        super('FileRead', 'Read content from a file', {
+            filePath: { type: 'string', required: true, description: 'Path to the file to read' }
+        });
+    }
+    async execute(params, abortSignal) {
+        await this.checkAbortSignal(abortSignal);
+        if (!this.validateParameters(params)) {
+            throw new Error('Invalid parameters: filePath is required');
+        }
+        const { filePath } = params;
+        const content = await fs.readFile(filePath, 'utf-8');
+        return content;
+    }
+    validateParameters(params) {
+        return params && typeof params.filePath === 'string' && params.filePath.trim() !== '';
+    }
+}
+exports.FileReadTool = FileReadTool;
+class FileWriteTool extends processor_1.BaseTool {
+    constructor() {
+        super('FileWrite', 'Write content to a file', {
+            filePath: { type: 'string', required: true, description: 'Path to the file to write' },
+            content: { type: 'string', required: true, description: 'Content to write to the file' }
+        });
+    }
+    async execute(params, abortSignal) {
+        await this.checkAbortSignal(abortSignal);
+        if (!this.validateParameters(params)) {
+            throw new Error('Invalid parameters: filePath and content are required');
+        }
+        const { filePath, content } = params;
+        // Ensure directory exists
+        const dir = path.dirname(filePath);
+        await fs.mkdir(dir, { recursive: true });
+        await fs.writeFile(filePath, content, 'utf-8');
+        return `Successfully wrote ${content.length} characters to ${filePath}`;
+    }
+    validateParameters(params) {
+        return params &&
+            typeof params.filePath === 'string' &&
+            params.filePath.trim() !== '' &&
+            typeof params.content === 'string';
+    }
+}
+exports.FileWriteTool = FileWriteTool;
+class FileDeleteTool extends processor_1.BaseTool {
+    constructor() {
+        super('FileDelete', 'Delete a file', {
+            filePath: { type: 'string', required: true, description: 'Path to the file to delete' }
+        });
+    }
+    async execute(params, abortSignal) {
+        await this.checkAbortSignal(abortSignal);
+        if (!this.validateParameters(params)) {
+            throw new Error('Invalid parameters: filePath is required');
+        }
+        const { filePath } = params;
+        await fs.unlink(filePath);
+        return `Successfully deleted ${filePath}`;
+    }
+    validateParameters(params) {
+        return params && typeof params.filePath === 'string' && params.filePath.trim() !== '';
+    }
+}
+exports.FileDeleteTool = FileDeleteTool;
+class FileMoveTool extends processor_1.BaseTool {
+    constructor() {
+        super('FileMove', 'Move a file from one location to another', {
+            sourcePath: { type: 'string', required: true, description: 'Source file path' },
+            destinationPath: { type: 'string', required: true, description: 'Destination file path' }
+        });
+    }
+    async execute(params, abortSignal) {
+        await this.checkAbortSignal(abortSignal);
+        if (!this.validateParameters(params)) {
+            throw new Error('Invalid parameters: sourcePath and destinationPath are required');
+        }
+        const { sourcePath, destinationPath } = params;
+        // Ensure destination directory exists
+        const dir = path.dirname(destinationPath);
+        await fs.mkdir(dir, { recursive: true });
+        await fs.rename(sourcePath, destinationPath);
+        return `Successfully moved ${sourcePath} to ${destinationPath}`;
+    }
+    validateParameters(params) {
+        return params &&
+            typeof params.sourcePath === 'string' &&
+            params.sourcePath.trim() !== '' &&
+            typeof params.destinationPath === 'string' &&
+            params.destinationPath.trim() !== '';
+    }
+}
+exports.FileMoveTool = FileMoveTool;
+class FileCopyTool extends processor_1.BaseTool {
+    constructor() {
+        super('FileCopy', 'Copy a file from one location to another', {
+            sourcePath: { type: 'string', required: true, description: 'Source file path' },
+            destinationPath: { type: 'string', required: true, description: 'Destination file path' }
+        });
+    }
+    async execute(params, abortSignal) {
+        await this.checkAbortSignal(abortSignal);
+        if (!this.validateParameters(params)) {
+            throw new Error('Invalid parameters: sourcePath and destinationPath are required');
+        }
+        const { sourcePath, destinationPath } = params;
+        // Ensure destination directory exists
+        const dir = path.dirname(destinationPath);
+        await fs.mkdir(dir, { recursive: true });
+        await fs.copyFile(sourcePath, destinationPath);
+        return `Successfully copied ${sourcePath} to ${destinationPath}`;
+    }
+    validateParameters(params) {
+        return params &&
+            typeof params.sourcePath === 'string' &&
+            params.sourcePath.trim() !== '' &&
+            typeof params.destinationPath === 'string' &&
+            params.destinationPath.trim() !== '';
+    }
+}
+exports.FileCopyTool = FileCopyTool;

package/dist/processor/types/interfaces.d.ts

@@ -1,52 +1,75 @@
+import type { FlatUserMessage } from '@codebolt/types';
 export interface ToolCall {
+    /** Unique identifier for this tool call */
     id: string;
+    /** The type of tool call */
+    type: 'function';
+    /** Function call details */
     function: {
+        /** Name of the function to call */
         name: string;
-        arguments: string | Record<string, any>;
+        /** Arguments for the function call as JSON string */
+        arguments: string;
     };
 }
 export interface Message {
-    role: 'user' | 'assistant' | 'tool' | 'system';
-    content: string | any[];
+    /** Role of the message sender */
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    /** Content of the message */
+    content: string | Array<{
+        type: string;
+        text: string;
+    }>;
+    /** Optional name for the message sender */
     name?: string;
-    tool_calls?: ToolCall[];
+    /** Tool call ID for tool messages */
     tool_call_id?: string;
-    [key: string]: any;
+    /** Tool calls for assistant messages */
+    tool_calls?: Array<{
+        id: string;
+        type: 'function';
+        function: {
+            name: string;
+            arguments: string;
+        };
+    }>;
 }
 export interface ProcessedMessage {
+    /** Array of messages in OpenAI format */
     messages: Message[];
-    metadata?: Record<string, any>;
+    /** Optional metadata about the processing */
+    metadata?: Record<string, unknown>;
 }
 export interface ProcessorInput {
     message: ProcessedMessage;
-    context?: Record<string, any>;
+    context?: Record<string, unknown>;
 }
 export interface ProcessorOutput {
     type: string;
-    value?: any;
+    value?: unknown;
 }
 export interface Processor {
     processInput(input: ProcessorInput): Promise<ProcessorOutput[]>;
-    setContext(key: string, value: any): void;
-    getContext(key: string): any;
+    setContext(key: string, value: unknown): void;
+    getContext(key: string): unknown;
     clearContext(): void;
 }
 export interface MessageModifierInput {
-    originalRequest: any;
+    originalRequest: FlatUserMessage;
     createdMessage: ProcessedMessage;
-    context?: Record<string, any>;
+    context?: Record<string, unknown>;
 }
 export interface MessageModifier {
     modify(input: MessageModifierInput): Promise<ProcessedMessage>;
-    setContext(key: string, value: any): void;
-    getContext(key: string): any;
+    setContext(key: string, value: unknown): void;
+    getContext(key: string): unknown;
     clearContext(): void;
 }
 export interface Tool {
     name: string;
     description: string;
-    parameters: Record<string, any>;
-    execute(params: any, abortSignal?: AbortSignal): Promise<any>;
+    parameters: Record<string, unknown>;
+    execute(params: unknown, abortSignal?: AbortSignal): Promise<unknown>;
 }
 export interface ToolList {
     getTool(name: string): Tool | undefined;
@@ -57,13 +80,13 @@ export interface ToolList {
 export interface AgentStepInput {
     message: ProcessedMessage;
     tools: Tool[];
-    context?: Record<string, any>;
+    context?: Record<string, unknown>;
 }
 export interface AgentStepOutput {
     response: ProcessedMessage;
     toolCalls?: Array<{
         tool: string;
-        parameters: any;
+        parameters: unknown;
     }>;
     finished: boolean;
 }
@@ -75,15 +98,15 @@ export interface IAgentStep {
 export interface ToolExecutionInput {
     toolCalls: Array<{
         tool: string;
-        parameters: any;
+        parameters: unknown;
     }>;
     tools: ToolList;
-    context?: Record<string, any>;
+    context?: Record<string, unknown>;
 }
 export interface ToolExecutionOutput {
     results: Array<{
         tool: string;
-        result: any;
+        result: unknown;
         error?: string;
     }>;
     success: boolean;

package/dist/processor-pieces/additionalModifiers/argumentProcessorModifier.d.ts

@@ -0,0 +1,13 @@
+import { ProcessedMessage } from "@codebolt/types/agent";
+import { BaseMessageModifier } from "../base";
+import { FlatUserMessage } from "@codebolt/types/sdk";
+export interface ArgumentProcessorOptions {
+    appendRawInvocation?: boolean;
+    argumentSeparator?: string;
+    includeCommandName?: boolean;
+}
+export declare class ArgumentProcessorModifier extends BaseMessageModifier {
+    private readonly options;
+    constructor(options?: ArgumentProcessorOptions);
+    modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
+}

package/dist/processor-pieces/additionalModifiers/argumentProcessorModifier.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArgumentProcessorModifier = void 0;
+const base_1 = require("../base");
+class ArgumentProcessorModifier extends base_1.BaseMessageModifier {
+    constructor(options = {}) {
+        super();
+        this.options = {
+            appendRawInvocation: options.appendRawInvocation !== false,
+            argumentSeparator: options.argumentSeparator || ' ',
+            includeCommandName: options.includeCommandName || false
+        };
+    }
+    modify(originalRequest, createdMessage) {
+        var _a;
+        try {
+            // Get arguments from metadata
+            const invocation = (_a = createdMessage.metadata) === null || _a === void 0 ? void 0 : _a.invocation;
+            if (!(invocation === null || invocation === void 0 ? void 0 : invocation.args)) {
+                return Promise.resolve(createdMessage);
+            }
+            // Find the user message to append arguments to
+            const userMessage = createdMessage.message.messages.find(msg => msg.role === 'user');
+            if (!userMessage || typeof userMessage.content !== 'string') {
+                return Promise.resolve(createdMessage);
+            }
+            let appendContent = '';
+            if (this.options.appendRawInvocation && invocation.raw) {
+                // Append the full raw command invocation
+                appendContent = `\n\nFull command: ${invocation.raw}`;
+            }
+            else {
+                // Append just the arguments
+                let argsToAppend = invocation.args;
+                if (this.options.includeCommandName && invocation.name) {
+                    argsToAppend = `${invocation.name}${this.options.argumentSeparator}${argsToAppend}`;
+                }
+                appendContent = `\n\nArguments: ${argsToAppend}`;
+            }
+            // Update the user message with appended arguments
+            const updatedMessages = createdMessage.message.messages.map(msg => {
+                if (msg.role === 'user' && typeof msg.content === 'string' && msg === userMessage) {
+                    return {
+                        ...msg,
+                        content: msg.content + appendContent
+                    };
+                }
+                return msg;
+            });
+            return Promise.resolve({
+                message: {
+                    ...createdMessage.message,
+                    messages: updatedMessages
+                },
+                metadata: {
+                    ...createdMessage.metadata,
+                    argumentsProcessed: true,
+                    argumentsAppended: appendContent.trim()
+                }
+            });
+        }
+        catch (error) {
+            console.error('Error in ArgumentProcessorModifier:', error);
+            return Promise.resolve(createdMessage);
+        }
+    }
+}
+exports.ArgumentProcessorModifier = ArgumentProcessorModifier;

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

@@ -0,0 +1,15 @@
+import { ProcessedMessage } from "@codebolt/types/agent";
+import { BaseMessageModifier } from "../base";
+import { FlatUserMessage } from "@codebolt/types/sdk";
+export interface AtFileProcessorOptions {
+    maxFileSize?: number;
+    allowedExtensions?: string[];
+    basePath?: string;
+}
+export declare class AtFileProcessorModifier extends BaseMessageModifier {
+    private readonly options;
+    constructor(options?: AtFileProcessorOptions);
+    modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
+    private readFileContent;
+    private getFolderStructure;
+}