@codebolt/codeboltjs 1.1.95 → 1.1.97

package/{src/modules → bkp}/toolBox.bkp.ts

@@ -73,7 +73,6 @@ export const imageContent = async (
   }
   const { fileTypeFromBuffer } = await loadEsm('file-type');
   const mimeType = await fileTypeFromBuffer(rawData);
-  console.log(mimeType);
 
   const base64Data = rawData.toString("base64");
 
@@ -1074,7 +1073,6 @@ export class ToolBox extends FastMCPEventEmitter {
   ) {
     if (options.transportType === "stdio") {
       const transport = new StdioServerTransport();
-      // console.log("tools", this.#tools);
 
       const session = new FastMCPSession({
         name: this.#options.name,
@@ -1084,7 +1082,6 @@ export class ToolBox extends FastMCPEventEmitter {
         resourcesTemplates: this.#resourcesTemplates,
         prompts: this.#prompts,
       });
-      // console.log("session", session);
       await session.connect(transport);
 
       this.#sessions.push(session);

package/modules/agent.js

@@ -63,7 +63,7 @@ const codeboltAgent = {
             }));
             websocket_1.default.getWebsocket.on('message', (data) => {
                 const response = JSON.parse(data);
-                if (response.type === "taskCompletionResponse") {
+                if (response.type === "taskCompletionResponse" && response.agentId === agentId) {
                     resolve(response); // Resolve the Promise when the agent has been successfully started
                 }
             });

package/modules/agentlib/agent.d.ts

@@ -1,23 +1,86 @@
 import { SystemPrompt } from "./systemprompt";
 import { TaskInstruction } from "./taskInstruction";
+/**
+ * Agent class that manages conversations with LLMs and tool executions.
+ * Handles the conversation flow, tool calls, and task completions.
+ */
 declare class Agent {
+    /** Available tools for the agent to use */
     private tools;
+    /** Full conversation history for API calls */
     private apiConversationHistory;
+    /** Maximum number of conversation turns (0 means unlimited) */
     private maxRun;
+    /** System prompt that provides instructions to the model */
     private systemPrompt;
+    /** Messages from the user */
     private userMessage;
+    /** The next user message to be added to the conversation */
     private nextUserMessage;
+    /**
+     * Creates a new Agent instance.
+     *
+     * @param tools - The tools available to the agent
+     * @param systemPrompt - The system prompt providing instructions to the LLM
+     * @param maxRun - Maximum number of conversation turns (0 means unlimited)
+     */
     constructor(tools: any, systemPrompt: SystemPrompt, maxRun?: number);
+    /**
+     * Runs the agent on a specific task until completion or max runs reached.
+     *
+     * @param task - The task instruction to be executed
+     * @param successCondition - Optional function to determine if the task is successful
+     * @returns Promise with success status, error (if any), and the last assistant message
+     */
     run(task: TaskInstruction, successCondition?: () => boolean): Promise<{
         success: boolean;
         error: string | null;
         message: string | null;
     }>;
+    /**
+     * Attempts to make a request to the LLM with conversation history and tools.
+     *
+     * @param apiConversationHistory - The current conversation history
+     * @param tools - The tools available to the LLM
+     * @returns Promise with the LLM response
+     */
     private attemptLlmRequest;
+    /**
+     * Executes a tool with given name and input.
+     *
+     * @param toolName - The name of the tool to execute
+     * @param toolInput - The input parameters for the tool
+     * @returns Promise with tuple [userRejected, result]
+     */
     private executeTool;
+    /**
+     * Starts a sub-agent to handle a specific task.
+     *
+     * @param agentName - The name of the sub-agent to start
+     * @param params - Parameters for the sub-agent
+     * @returns Promise with tuple [userRejected, result]
+     */
     private startSubAgent;
+    /**
+     * Extracts tool details from a tool call object.
+     *
+     * @param tool - The tool call object from the LLM response
+     * @returns ToolDetails object with name, input, and ID
+     */
     private getToolDetail;
+    /**
+     * Creates a tool result object from the tool execution response.
+     *
+     * @param tool_call_id - The ID of the tool call
+     * @param content - The content returned by the tool
+     * @returns ToolResult object
+     */
     private getToolResult;
+    /**
+     * Fallback method for API requests in case of failures.
+     *
+     * @throws Error API request fallback not implemented
+     */
     private attemptApiRequest;
 }
 export { Agent };

package/modules/agentlib/agent.js

@@ -8,7 +8,18 @@ const chat_1 = __importDefault(require("./../chat"));
 const tools_1 = __importDefault(require("./../tools"));
 const llm_1 = __importDefault(require("./../llm"));
 const agent_1 = __importDefault(require("./../agent"));
+/**
+ * Agent class that manages conversations with LLMs and tool executions.
+ * Handles the conversation flow, tool calls, and task completions.
+ */
 class Agent {
+    /**
+     * Creates a new Agent instance.
+     *
+     * @param tools - The tools available to the agent
+     * @param systemPrompt - The system prompt providing instructions to the LLM
+     * @param maxRun - Maximum number of conversation turns (0 means unlimited)
+     */
     constructor(tools = [], systemPrompt, maxRun = 0) {
         this.tools = tools;
         this.userMessage = [];
@@ -16,6 +27,13 @@ class Agent {
         this.maxRun = maxRun;
         this.systemPrompt = systemPrompt;
     }
+    /**
+     * Runs the agent on a specific task until completion or max runs reached.
+     *
+     * @param task - The task instruction to be executed
+     * @param successCondition - Optional function to determine if the task is successful
+     * @returns Promise with success status, error (if any), and the last assistant message
+     */
     async run(task, successCondition = () => true) {
         var _a, _b;
         let mentaionedMCPSTool = await task.userMessage.getMentionedMcpsTools();
@@ -84,11 +102,8 @@ class Agent {
                                 else {
                                     let [serverName] = toolName.replace('--', ':').split(':');
                                     if (serverName == 'subagent') {
-                                        console.log("calling agent with params", toolName, toolInput);
                                         const agentResponse = await agent_1.default.startAgent(toolName.replace("subagent--", ''), toolInput.task);
-                                        console.log("got sub agent resonse  result", agentResponse);
                                         const [didUserReject, result] = [false, "tool result is successful"];
-                                        console.log("got sub agent resonse  result", didUserReject, result);
                                         let toolResult = this.getToolResult(toolUseId, result);
                                         toolResults.push({
                                             role: "tool",
@@ -106,9 +121,7 @@ class Agent {
                                         }
                                     }
                                     else {
-                                        console.log("calling tool with params", toolName, toolInput);
                                         const [didUserReject, result] = await this.executeTool(toolName, toolInput);
-                                        console.log("tool result", result);
                                         // toolResults.push(this.getToolResult(toolUseId, result));
                                         let toolResult = this.getToolResult(toolUseId, result);
                                         toolResults.push({
@@ -199,6 +212,13 @@ class Agent {
                 .pop()) === null || _b === void 0 ? void 0 : _b.content) || ''
         };
     }
+    /**
+     * Attempts to make a request to the LLM with conversation history and tools.
+     *
+     * @param apiConversationHistory - The current conversation history
+     * @param tools - The tools available to the LLM
+     * @returns Promise with the LLM response
+     */
     async attemptLlmRequest(apiConversationHistory, tools) {
         try {
             let systemPrompt = await this.systemPrompt.toPromptText();
@@ -217,18 +237,37 @@ class Agent {
             return completion;
         }
         catch (error) {
-            console.log(error);
             return this.attemptApiRequest();
         }
     }
+    /**
+     * Executes a tool with given name and input.
+     *
+     * @param toolName - The name of the tool to execute
+     * @param toolInput - The input parameters for the tool
+     * @returns Promise with tuple [userRejected, result]
+     */
     async executeTool(toolName, toolInput) {
         //codebolttools--readfile
         const [toolboxName, actualToolName] = toolName.split('--');
         return tools_1.default.executeTool(toolboxName, actualToolName, toolInput);
     }
+    /**
+     * Starts a sub-agent to handle a specific task.
+     *
+     * @param agentName - The name of the sub-agent to start
+     * @param params - Parameters for the sub-agent
+     * @returns Promise with tuple [userRejected, result]
+     */
     async startSubAgent(agentName, params) {
         return agent_1.default.startAgent(agentName, params.task);
     }
+    /**
+     * Extracts tool details from a tool call object.
+     *
+     * @param tool - The tool call object from the LLM response
+     * @returns ToolDetails object with name, input, and ID
+     */
     getToolDetail(tool) {
         return {
             toolName: tool.function.name,
@@ -236,6 +275,13 @@ class Agent {
             toolUseId: tool.id
         };
     }
+    /**
+     * Creates a tool result object from the tool execution response.
+     *
+     * @param tool_call_id - The ID of the tool call
+     * @param content - The content returned by the tool
+     * @returns ToolResult object
+     */
     getToolResult(tool_call_id, content) {
         let userMessage = undefined;
         try {
@@ -255,7 +301,11 @@ class Agent {
             userMessage
         };
     }
-    // Placeholder for error fallback method
+    /**
+     * Fallback method for API requests in case of failures.
+     *
+     * @throws Error API request fallback not implemented
+     */
     attemptApiRequest() {
         throw new Error("API request fallback not implemented");
     }

package/modules/agentlib/taskInstruction.d.ts

@@ -1,22 +1,59 @@
 import { UserMessage, UserMessageContent } from "./usermessage";
+/**
+ * Interface for tools that can be used within tasks.
+ * Each tool has a description and usage example.
+ */
 interface Tools {
     [key: string]: {
+        /** Description of what the tool does */
         description: string;
+        /** How to use the tool correctly */
         usage: string;
+        /** Optional example demonstrating tool usage */
         example?: string;
     };
 }
+/**
+ * Interface for user message structure.
+ * Contains message type and text content.
+ */
 interface UserMessages {
+    /** The type of user message */
     type: string;
+    /** The text content of the message */
     text: string;
 }
+/**
+ * Class representing a task instruction.
+ * Handles loading task data and converting it to prompts.
+ */
 declare class TaskInstruction {
+    /** Available tools for the task */
     tools: Tools;
+    /** Messages from the user for this task */
     userMessages: UserMessageContent[];
+    /** The user message object containing input */
     userMessage: UserMessage;
+    /** Path to the YAML file with task instructions */
     filepath: string;
+    /** The section reference within the YAML file */
     refsection: string;
+    /**
+     * Creates a new TaskInstruction instance.
+     *
+     * @param tools - Tools available for this task
+     * @param userMessage - User message containing task instructions
+     * @param filepath - Path to the YAML file with task data
+     * @param refsection - Section name within the YAML file
+     */
     constructor(tools: Tools | undefined, userMessage: UserMessage, filepath?: string, refsection?: string);
+    /**
+     * Converts the task instruction to a prompt format.
+     * Loads data from YAML file and combines with user message.
+     *
+     * @returns Promise with an array of user message content blocks
+     * @throws Error if there's an issue processing the task instruction
+     */
     toPrompt(): Promise<UserMessages[]>;
 }
 export { TaskInstruction };

package/modules/agentlib/taskInstruction.js

@@ -8,14 +8,34 @@ exports.TaskInstruction = void 0;
 const yaml = require('js-yaml');
 const fs = require('fs');
 const path = require('path');
+/**
+ * Class representing a task instruction.
+ * Handles loading task data and converting it to prompts.
+ */
 class TaskInstruction {
+    /**
+     * Creates a new TaskInstruction instance.
+     *
+     * @param tools - Tools available for this task
+     * @param userMessage - User message containing task instructions
+     * @param filepath - Path to the YAML file with task data
+     * @param refsection - Section name within the YAML file
+     */
     constructor(tools = {}, userMessage, filepath = "", refsection = "") {
+        /** Messages from the user for this task */
         this.userMessages = [];
         this.tools = tools;
         this.userMessage = userMessage;
         this.filepath = filepath;
         this.refsection = refsection;
     }
+    /**
+     * Converts the task instruction to a prompt format.
+     * Loads data from YAML file and combines with user message.
+     *
+     * @returns Promise with an array of user message content blocks
+     * @throws Error if there's an issue processing the task instruction
+     */
     async toPrompt() {
         try {
             this.userMessages = await this.userMessage.toPrompt();

package/modules/agentlib/usermessage.d.ts

@@ -1,32 +1,100 @@
+/**
+ * Interface representing an agent that can be referenced in user messages.
+ */
 interface agent {
+    /** Short description of the agent */
     description: string;
+    /** Title/name of the agent */
     title: string;
+    /** Numeric ID of the agent */
     id: number;
+    /** Agent identifier string */
     agent_id: string;
+    /** Unique identifier for the agent */
     unique_id: string;
+    /** Detailed description of the agent and its capabilities */
     longDescription: string;
 }
+/**
+ * Interface for the user message structure.
+ */
 interface Message {
+    /** The actual text content of the user message */
     userMessage: string;
+    /** Optional list of files mentioned in the message */
     mentionedFiles?: string[];
+    /** List of MCP (Model Context Protocol) tools mentioned */
     mentionedMCPs: string[];
+    /** List of agents mentioned in the message */
     mentionedAgents: agent[];
 }
+/**
+ * Interface for a single content block within a user message.
+ */
 export interface UserMessageContent {
+    /** Type of content (e.g., "text", "image") */
     type: string;
+    /** The text content */
     text: string;
 }
+/**
+ * Class that processes and manages user messages.
+ * Handles converting messages to prompts and extracting mentioned entities.
+ */
 declare class UserMessage {
+    /** The message content and metadata */
     message: Message;
+    /** Whether to override the default prompt generation */
     promptOverride: boolean;
+    /** Array of content blocks for the user message */
     userMessages: UserMessageContent[];
+    /** List of MCP tools mentioned in the message */
     mentionedMCPs: string[];
+    /**
+     * Creates a new UserMessage instance.
+     *
+     * @param message - The message content and metadata
+     * @param promptOverride - Whether to override default prompt generation
+     */
     constructor(message: Message, promptOverride?: boolean);
+    /**
+     * Gets files mentioned in the message.
+     * Currently a placeholder for implementation.
+     */
     getFiles(): void;
+    /**
+     * Converts the user message to a prompt format.
+     *
+     * @param bAttachFiles - Whether to attach file contents
+     * @param bAttachImages - Whether to attach images
+     * @param bAttachEnvironment - Whether to attach environment details
+     * @returns Promise with an array of content blocks for the prompt
+     */
     toPrompt(bAttachFiles?: boolean, bAttachImages?: boolean, bAttachEnvironment?: boolean): Promise<UserMessageContent[]>;
+    /**
+     * Gets agents mentioned in the message.
+     *
+     * @returns Array of agent objects
+     */
     getMentionedAgents(): agent[];
+    /**
+     * Gets MCP tools mentioned in the message.
+     *
+     * @returns Array of MCP tool names
+     */
     getMentionedMcps(): string[];
+    /**
+     * Gets MCP tools in a format suitable for the LLM.
+     *
+     * @returns Promise with an array of MCP tools
+     */
     getMentionedMcpsTools(): Promise<any>;
+    /**
+     * Gets environment details for the current working directory.
+     *
+     * @param cwd - The current working directory path
+     * @returns Promise with a string containing environment details
+     */
     private getEnvironmentDetail;
 }
 export { UserMessage };

package/modules/agentlib/usermessage.js

@@ -7,8 +7,24 @@ exports.UserMessage = void 0;
 const fs_1 = __importDefault(require("./../fs"));
 const project_1 = __importDefault(require("./../project"));
 const tools_1 = __importDefault(require("./../tools"));
+/**
+ * Class that processes and manages user messages.
+ * Handles converting messages to prompts and extracting mentioned entities.
+ */
 class UserMessage {
+    /**
+     * Creates a new UserMessage instance.
+     *
+     * @param message - The message content and metadata
+     * @param promptOverride - Whether to override default prompt generation
+     */
     constructor(message, promptOverride = false) {
+        /**
+         * Gets environment details for the current working directory.
+         *
+         * @param cwd - The current working directory path
+         * @returns Promise with a string containing environment details
+         */
         this.getEnvironmentDetail = async (cwd) => {
             let details = "";
             const { success, result } = await fs_1.default.listFile(cwd, true);
@@ -23,9 +39,21 @@ class UserMessage {
         this.userMessages = [];
         this.mentionedMCPs = message.mentionedMCPs || [];
     }
+    /**
+     * Gets files mentioned in the message.
+     * Currently a placeholder for implementation.
+     */
     getFiles() {
         // Implementation to be added
     }
+    /**
+     * Converts the user message to a prompt format.
+     *
+     * @param bAttachFiles - Whether to attach file contents
+     * @param bAttachImages - Whether to attach images
+     * @param bAttachEnvironment - Whether to attach environment details
+     * @returns Promise with an array of content blocks for the prompt
+     */
     async toPrompt(bAttachFiles = true, bAttachImages = true, bAttachEnvironment = true) {
         var _a;
         if (bAttachFiles) {
@@ -54,13 +82,28 @@ class UserMessage {
         }
         return this.userMessages;
     }
+    /**
+     * Gets agents mentioned in the message.
+     *
+     * @returns Array of agent objects
+     */
     getMentionedAgents() {
         //TODO : get config in tool format if neede
         return this.message.mentionedAgents || [];
     }
+    /**
+     * Gets MCP tools mentioned in the message.
+     *
+     * @returns Array of MCP tool names
+     */
     getMentionedMcps() {
         return this.message.mentionedMCPs || [];
     }
+    /**
+     * Gets MCP tools in a format suitable for the LLM.
+     *
+     * @returns Promise with an array of MCP tools
+     */
     async getMentionedMcpsTools() {
         if (this.mentionedMCPs.length > 0) {
             let tools = await tools_1.default.listToolsFromToolBoxes(this.mentionedMCPs);

package/modules/chat.js

@@ -79,7 +79,6 @@ const cbchat = {
                     const response = JSON.parse(data);
                     if (response.type === "messageResponse") {
                         eventEmitter.emit("userMessage", response, (message) => {
-                            console.log("Callback function invoked with message:", message);
                             websocket_1.default.getWebsocket.send(JSON.stringify({
                                 "type": "processStoped",
                                 "message": message
@@ -100,7 +99,6 @@ const cbchat = {
      * @param {string} message - The message to be sent.
      */
     sendMessage: (message, payload) => {
-        console.log(message);
         websocket_1.default.getWebsocket.send(JSON.stringify({
             "type": "sendMessage",
             "message": message,
@@ -138,7 +136,6 @@ const cbchat = {
         // Register event listener for WebSocket messages
         websocket_1.default.getWebsocket.on('message', (data) => {
             const message = JSON.parse(data);
-            console.log("Received message:", message);
             if (message.type === 'stopProcessClicked')
                 // Emit a custom event based on the message type
                 eventEmitter.emit("stopProcessClicked", message);
@@ -148,7 +145,6 @@ const cbchat = {
             event: eventEmitter,
             stopProcess: () => {
                 // Implement the logic to stop the process here
-                console.log("Stopping process...");
                 // For example, you might want to send a specific message to the server to stop the process
                 websocket_1.default.getWebsocket.send(JSON.stringify({
                     "type": "processStoped"
@@ -162,7 +158,6 @@ const cbchat = {
      */
     stopProcess: () => {
         // Implement the logic to stop the process here
-        console.log("Stopping process...");
         // For example, you might want to send a specific message to the server to stop the process
         websocket_1.default.getWebsocket.send(JSON.stringify({
             "type": "processStoped"
@@ -174,7 +169,6 @@ const cbchat = {
    */
     processFinished: () => {
         // Implement the logic to stop the process here
-        console.log("Process Finished ...");
         // For example, you might want to send a specific message to the server to stop the process
         websocket_1.default.getWebsocket.send(JSON.stringify({
             "type": "processFinished"

package/modules/codeparsers.js

@@ -9,7 +9,6 @@ const cbcodeparsers = {
      * @param file The file to parse for classes.
      */
     getClassesInFile: (file) => {
-        console.log('Code parsers initialized');
     },
     /**
      * Retrieves the functions in a given class within a file.
@@ -17,7 +16,6 @@ const cbcodeparsers = {
      * @param className The name of the class to parse for functions.
      */
     getFunctionsinClass: (file, className) => {
-        console.log('Code parsers initialized');
     },
     /**
      * Generates an Abstract Syntax Tree (AST) for a given file.

package/modules/codeutils.js

@@ -68,7 +68,6 @@ const cbcodeutils = {
                                 }
                                 else if (path_1.default.extname(file.name) === '.js') {
                                     const code = fs.readFileSync(path_1.default.join(directory, file.name), 'utf-8');
-                                    console.log(code);
                                     let tree = parser.parse(code);
                                     tree.rootNode.path = path_1.default.join(directory, file.name); // Set file path for t
                                     trees.push(tree);

package/modules/history.d.ts

@@ -1,13 +1,35 @@
+/**
+ * Enum representing different types of log messages.
+ */
 export declare enum logType {
+    /** Informational messages */
     info = "info",
+    /** Error messages */
     error = "error",
+    /** Warning messages */
     warning = "warning"
 }
+/**
+ * Object with methods for summarizing chat history.
+ * Provides functionality to create summaries of conversation history.
+ */
 export declare const chatSummary: {
+    /**
+     * Summarizes the entire chat history.
+     *
+     * @returns Promise with an array of message objects containing role and content
+     */
     summarizeAll: () => Promise<{
         role: string;
         content: string;
     }[]>;
+    /**
+     * Summarizes a specific part of the chat history.
+     *
+     * @param messages - Array of message objects to summarize
+     * @param depth - How far back in history to consider
+     * @returns Promise with an array of summarized message objects
+     */
     summarize: (messages: {
         role: string;
         content: string;

package/modules/history.js

@@ -5,13 +5,28 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.chatSummary = exports.logType = void 0;
 const websocket_1 = __importDefault(require("./websocket"));
+/**
+ * Enum representing different types of log messages.
+ */
 var logType;
 (function (logType) {
+    /** Informational messages */
     logType["info"] = "info";
+    /** Error messages */
     logType["error"] = "error";
+    /** Warning messages */
     logType["warning"] = "warning";
 })(logType || (exports.logType = logType = {}));
+/**
+ * Object with methods for summarizing chat history.
+ * Provides functionality to create summaries of conversation history.
+ */
 exports.chatSummary = {
+    /**
+     * Summarizes the entire chat history.
+     *
+     * @returns Promise with an array of message objects containing role and content
+     */
     summarizeAll: () => {
         return new Promise((resolve, reject) => {
             websocket_1.default.getWebsocket.send(JSON.stringify({
@@ -26,6 +41,13 @@ exports.chatSummary = {
             });
         });
     },
+    /**
+     * Summarizes a specific part of the chat history.
+     *
+     * @param messages - Array of message objects to summarize
+     * @param depth - How far back in history to consider
+     * @returns Promise with an array of summarized message objects
+     */
     summarize: (messages, depth) => {
         return new Promise((resolve, reject) => {
             websocket_1.default.getWebsocket.send(JSON.stringify({