@codebolt/codeboltjs 2.0.3 → 2.0.5

package/dist/modules/task.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const websocket_1 = __importDefault(require("../core/websocket"));
+// import {AddTaskResponse,GetTasksResponse,UpdateTasksResponse } from '@codebolt/types';
+/**
+ * Manages task operations via WebSocket communication.
+ */
+const taskplaner = {
+    /**
+     * Adds a task using a WebSocket message.
+     * @param {string} task - The task to be added.
+     * @returns {Promise<AddTaskResponse>} A promise that resolves with the response from the add task event.
+     */
+    addTask: async (task) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "taskEvent",
+            "action": "addTask",
+            message: {
+                "task": task
+            }
+        }, "addTaskResponse");
+    },
+    /**
+     * Retrieves all tasks using a WebSocket message.
+     * @returns {Promise<GetTasksResponse>} A promise that resolves with the response from the get tasks event.
+     */
+    getTasks: async () => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "taskEvent",
+            "action": "getTasks"
+        }, "getTasksResponse");
+    },
+    /**
+     * Updates an existing task using a WebSocket message.
+     * @param {string} task - The updated task information.
+     * @returns {Promise<UpdateTasksResponse>} A promise that resolves with the response from the update task event.
+     */
+    updateTask: async (task) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "taskEvent",
+            "action": "updateTask",
+            message: {
+                "task": task
+            }
+        }, "updateTaskResponse");
+    }
+};
+exports.default = taskplaner;

package/{modules → dist/modules}/terminal.d.ts

@@ -5,6 +5,7 @@ import { CommandError, TerminalInterruptResponse } from '@codebolt/types';
  * CustomEventEmitter class that extends the Node.js EventEmitter class.
  */
 declare class CustomEventEmitter extends EventEmitter {
+    cleanup?: () => void;
 }
 /**
  * A module for executing commands in a terminal-like environment via WebSocket.
@@ -19,7 +20,7 @@ declare const cbterminal: {
      * @param {string} command - The command to be executed.
      * @returns {Promise<CommandOutput|CommandError>} A promise that resolves with the command's output, error, or finish signal.
      */
-    executeCommand: (command: string, returnEmptyStringOnSuccess?: boolean) => Promise<unknown>;
+    executeCommand: (command: string, returnEmptyStringOnSuccess?: boolean) => Promise<any>;
     /**
      * Executes a given command and keeps running until an error occurs.
      * Listens for messages from the WebSocket and resolves the promise when an error is encountered.
@@ -41,6 +42,6 @@ declare const cbterminal: {
      * @param {string} command - The command to be executed.
      * @returns {EventEmitter} A promise that streams the output data during command execution.
      */
-    executeCommandWithStream(command: string, executeInMain?: boolean): EventEmitter;
+    executeCommandWithStream(command: string, executeInMain?: boolean): CustomEventEmitter;
 };
 export default cbterminal;

package/{modules → dist/modules}/terminal.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const websocket_1 = __importDefault(require("./websocket"));
+const websocket_1 = __importDefault(require("../core/websocket"));
 const events_1 = require("events");
 /**
  * CustomEventEmitter class that extends the Node.js EventEmitter class.
@@ -24,20 +24,11 @@ const cbterminal = {
      * @returns {Promise<CommandOutput|CommandError>} A promise that resolves with the command's output, error, or finish signal.
      */
     executeCommand: async (command, returnEmptyStringOnSuccess = false) => {
-        return new Promise((resolve, reject) => {
-            websocket_1.default.getWebsocket.send(JSON.stringify({
-                "type": "executeCommand",
-                "message": command,
-                returnEmptyStringOnSuccess
-            }));
-            let result = "";
-            websocket_1.default.getWebsocket.on('message', (data) => {
-                const response = JSON.parse(data);
-                if (response.type === "commandError" || response.type === "commandFinish") {
-                    resolve(response);
-                }
-            });
-        });
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "executeCommand",
+            "message": command,
+            returnEmptyStringOnSuccess
+        }, "commandError|commandFinish");
     },
     /**
      * Executes a given command and keeps running until an error occurs.
@@ -47,19 +38,11 @@ const cbterminal = {
      * @returns {Promise<CommandError>} A promise that resolves when an error occurs during command execution.
      */
     executeCommandRunUntilError: async (command, executeInMain = false) => {
-        return new Promise((resolve, reject) => {
-            websocket_1.default.getWebsocket.send(JSON.stringify({
-                "type": "executeCommandRunUntilError",
-                "message": command,
-                executeInMain
-            }));
-            websocket_1.default.getWebsocket.on('message', (data) => {
-                const response = JSON.parse(data);
-                if (response.type === "commandError") {
-                    resolve(response);
-                }
-            });
-        });
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "executeCommandRunUntilError",
+            "message": command,
+            executeInMain
+        }, "commandError");
     },
     /**
      * Sends a manual interrupt signal to the terminal.
@@ -67,17 +50,9 @@ const cbterminal = {
      * @returns {Promise<TerminalInterruptResponse>}
      */
     sendManualInterrupt() {
-        return new Promise((resolve, reject) => {
-            websocket_1.default.getWebsocket.send(JSON.stringify({
-                "type": "sendInterruptToTerminal"
-            }));
-            websocket_1.default.getWebsocket.on('message', (data) => {
-                const response = JSON.parse(data);
-                if (response.type === "terminalInterrupted") {
-                    resolve(response);
-                }
-            });
-        });
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "sendInterruptToTerminal"
+        }, "terminalInterrupted");
     },
     /**
      * Executes a given command and streams the output.
@@ -88,20 +63,34 @@ const cbterminal = {
      */
     executeCommandWithStream(command, executeInMain = false) {
         // Send the process started message
-        websocket_1.default.getWebsocket.send(JSON.stringify({
+        websocket_1.default.messageManager.send({
             "type": "executeCommandWithStream",
             "message": command,
             executeInMain
-        }));
-        // Register event listener for WebSocket messages
-        websocket_1.default.getWebsocket.on('message', (data) => {
-            const response = JSON.parse(data);
+        });
+        // Listen for streaming messages through the message manager
+        const handleStreamMessage = (response) => {
             if (response.type === "commandOutput" || response.type === "commandError" || response.type === "commandFinish") {
                 this.eventEmitter.emit(response.type, response);
             }
-        });
-        // Return an object that includes the event emitter and the stopProcess method
-        return this.eventEmitter;
+        };
+        websocket_1.default.messageManager.on('message', handleStreamMessage);
+        // Create a new event emitter instance for this stream
+        const streamEmitter = new CustomEventEmitter();
+        // Forward events from the main emitter to the stream emitter
+        const forwardEvent = (eventType) => {
+            this.eventEmitter.on(eventType, (data) => {
+                streamEmitter.emit(eventType, data);
+            });
+        };
+        forwardEvent('commandOutput');
+        forwardEvent('commandError');
+        forwardEvent('commandFinish');
+        // Add a cleanup method to remove the listener
+        streamEmitter.cleanup = () => {
+            websocket_1.default.messageManager.removeListener('message', handleStreamMessage);
+        };
+        return streamEmitter;
     }
 };
 exports.default = cbterminal;

package/dist/modules/tokenizer.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const websocket_1 = __importDefault(require("../core/websocket"));
+/**
+ * Tokenizer module for handling token-related operations.
+ */
+const tokenizer = {
+    /**
+     * Adds a token to the system via WebSocket.
+     * @param {string} key - The key associated with the token to be added.
+     * @returns {Promise<AddTokenResponse>} A promise that resolves with the response from the add token event.
+     */
+    addToken: async (key) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "tokenizerEvent",
+            "action": "addToken",
+            "message": {
+                item: key
+            },
+        }, "addTokenResponse");
+    },
+    /**
+     * Retrieves a token from the system via WebSocket.
+     * @param {string} key - The key associated with the token to be retrieved.
+     * @returns {Promise<GetTokenResponse>} A promise that resolves with the response from the get token event.
+     */
+    getToken: async (key) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "tokenizerEvent",
+            "action": "getToken",
+            "message": {
+                item: key
+            },
+        }, "getTokenResponse");
+    }
+};
+exports.default = tokenizer;

package/{modules → dist/modules}/tools.d.ts

@@ -23,12 +23,6 @@ declare const codeboltMCP: {
      * @returns Promise with the mentioned toolboxes
      */
     getMentionedToolBoxes: (userMessage: UserMessage) => Promise<any>;
-    /**
-     * Gets all available toolboxes.
-     *
-     * @returns Promise with all available toolboxes data
-     */
-    getAvailableToolBoxes: () => Promise<any>;
     /**
      * Searches for available toolboxes matching a query.
      *

package/dist/modules/tools.js

@@ -0,0 +1,117 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const websocket_1 = __importDefault(require("../core/websocket"));
+/**
+ * Object containing methods for interacting with Codebolt MCP (Model Context Protocol) tools.
+ * Provides functionality to discover, list, and execute tools.
+ */
+const codeboltMCP = {
+    /**
+     * Gets the list of currently enabled toolboxes.
+     *
+     * @returns Promise with the enabled toolboxes data
+     */
+    getEnabledToolBoxes: () => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "codebolttools",
+            "action": "getEnabledToolBoxes"
+        }, "getEnabledToolBoxesResponse");
+    },
+    /**
+     * Gets the list of locally available toolboxes.
+     *
+     * @returns Promise with the local toolboxes data
+     */
+    getLocalToolBoxes: () => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "codebolttools",
+            "action": "getLocalToolBoxes"
+        }, "getLocalToolBoxesResponse");
+    },
+    /**
+     * Gets toolboxes mentioned in a user message.
+     *
+     * @param userMessage - The user message to extract mentions from
+     * @returns Promise with the mentioned toolboxes
+     */
+    getMentionedToolBoxes: (userMessage) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "codebolttools",
+            "action": "getAvailableToolBoxes"
+        }, "getAvailableToolBoxesResponse");
+    },
+    /**
+     * Searches for available toolboxes matching a query.
+     *
+     * @param query - The search query string
+     * @returns Promise with matching toolboxes data
+     */
+    searchAvailableToolBoxes: (query) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "codebolttools",
+            "action": "searchAvailableToolBoxes",
+            "query": query
+        }, "searchAvailableToolBoxesResponse");
+    },
+    /**
+     * Lists all tools from the specified toolboxes.
+     *
+     * @param toolBoxes - Array of toolbox names to list tools from
+     * @returns Promise with tools from the specified toolboxes
+     */
+    listToolsFromToolBoxes: (toolBoxes) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "codebolttools",
+            "action": "listToolsFromToolBoxes",
+            "toolBoxes": toolBoxes
+        }, "listToolsFromToolBoxesResponse");
+    },
+    /**
+     * Configures a specific toolbox with provided configuration.
+     *
+     * @param name - The name of the toolbox to configure
+     * @param config - Configuration object for the toolbox
+     * @returns Promise with the configuration result
+     */
+    configureToolBox: (name, config) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "codebolttools",
+            "action": "configureToolBox",
+            "mcpName": name,
+            "config": config
+        }, "configureToolBoxResponse");
+    },
+    /**
+     * Gets detailed information about specific tools.
+     *
+     * @param tools - Array of toolbox and tool name pairs
+     * @returns Promise with detailed information about the tools
+     */
+    getTools: (tools) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "codebolttools",
+            "action": "getTools",
+            "toolboxes": tools
+        }, "getToolsResponse");
+    },
+    /**
+     * Executes a specific tool with provided parameters.
+     *
+     * @param toolbox - The name of the toolbox containing the tool
+     * @param toolName - The name of the tool to execute
+     * @param params - Parameters to pass to the tool
+     * @returns Promise with the execution result
+     */
+    executeTool: (toolbox, toolName, params) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "codebolttools",
+            "action": "executeTool",
+            "toolName": `${toolbox}--${toolName}`,
+            "params": params
+        }, "executeToolResponse");
+    }
+};
+exports.default = codeboltMCP;

package/dist/modules/utils.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const websocket_1 = __importDefault(require("../core/websocket"));
+const cbutils = {
+    editFileAndApplyDiff: (filePath, diff, diffIdentifier, prompt, applyModel) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "fsEvent",
+            "action": "editFileAndApplyDiff",
+            message: {
+                filePath,
+                diff,
+                diffIdentifier,
+                prompt,
+                applyModel
+            }
+        }, "editFileAndApplyDiffResponse");
+    }
+};
+exports.default = cbutils;

package/dist/modules/vectordb.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const websocket_1 = __importDefault(require("../core/websocket"));
+const VectorDB = {
+    /**
+     * Retrieves a vector from the vector database based on the provided key.
+     *
+     * @param {string} key - The key of the vector to retrieve.
+     * @returns {Promise<GetVectorResponse>} A promise that resolves with the retrieved vector.
+     */
+    getVector: async (key) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "vectordbEvent",
+            "action": "getVector",
+            "message": {
+                item: key
+            },
+        }, "getVectorResponse");
+    },
+    /**
+     * Adds a new vector item to the vector database.
+     *
+
+     * @param {any} item - The item to add to the vector.
+     * @returns {Promise<AddVectorItemResponse>} A promise that resolves when the item is successfully added.
+     */
+    addVectorItem: async (item) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "vectordbEvent",
+            "action": "addVectorItem",
+            "message": {
+                item: item
+            },
+        }, "addVectorItemResponse");
+    },
+    /**
+     * Queries a vector item from the vector database based on the provided key.
+     *
+     * @param {string} key - The key of the vector to query the item from.
+     * @returns {Promise<QueryVectorItemResponse>} A promise that resolves with the queried vector item.
+     */
+    queryVectorItem: async (key) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "vectordbEvent",
+            "action": "queryVectorItem",
+            "message": {
+                item: key
+            },
+        }, "qeryVectorItemResponse");
+    },
+    /**
+     * Queries a vector item from the vector database based on the provided key.
+     *
+     * @param {string} key - The key of the vector to query the item from.
+     * @returns {Promise<QueryVectorItemResponse>} A promise that resolves with the queried vector item.
+     */
+    queryVectorItems: async (items, dbPath) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "vectordbEvent",
+            "action": "queryVectorItems",
+            "message": {
+                items,
+                dbPath
+            },
+        }, "qeryVectorItemsResponse");
+    },
+};
+exports.default = VectorDB;

package/dist/utils.d.ts

@@ -0,0 +1,5 @@
+export { ToolBox } from './utils/toolBox';
+export { TaskInstruction } from './agentlib/taskInstruction';
+export { UserMessage } from './agentlib/usermessage';
+export { SystemPrompt } from './agentlib/systemprompt';
+export { Agent } from './agentlib/agent';

package/{utils.js → dist/utils.js}

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Agent = exports.SystemPrompt = exports.UserMessage = exports.TaskInstruction = exports.ToolBox = void 0;
-var toolBox_1 = require("./modules/toolBox");
+var toolBox_1 = require("./utils/toolBox");
 Object.defineProperty(exports, "ToolBox", { enumerable: true, get: function () { return toolBox_1.ToolBox; } });
-var taskInstruction_1 = require("./modules/agentlib/taskInstruction");
+var taskInstruction_1 = require("./agentlib/taskInstruction");
 Object.defineProperty(exports, "TaskInstruction", { enumerable: true, get: function () { return taskInstruction_1.TaskInstruction; } });
-var usermessage_1 = require("./modules/agentlib/usermessage");
+var usermessage_1 = require("./agentlib/usermessage");
 Object.defineProperty(exports, "UserMessage", { enumerable: true, get: function () { return usermessage_1.UserMessage; } });
-var systemprompt_1 = require("./modules/agentlib/systemprompt");
+var systemprompt_1 = require("./agentlib/systemprompt");
 Object.defineProperty(exports, "SystemPrompt", { enumerable: true, get: function () { return systemprompt_1.SystemPrompt; } });
-var agent_1 = require("./modules/agentlib/agent");
+var agent_1 = require("./agentlib/agent");
 Object.defineProperty(exports, "Agent", { enumerable: true, get: function () { return agent_1.Agent; } });

package/package.json

@@ -1,16 +1,25 @@
 {
   "name": "@codebolt/codeboltjs",
-  "version": "2.0.3",
+  "version": "2.0.5",
   "description": "",
   "keywords": [],
   "author": "",
-  "main": "index.js",
-  "types": "index.d.ts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/**/*",
+    "README.md",
+    "LICENSE"
+  ],
   "scripts": {
     "build": "tsc",
+    "build:webpack": "webpack",
+    "build:all": "npm run build && npm run build:webpack",
     "build:docs": "typedoc --plugin typedoc-plugin-missing-exports",
     "build:jsondocs": "typedoc --plugin typedoc-plugin-missing-exports --json out.json --pretty",
-    "test": "jest fs.test.js"
+    "test": "jest fs.test.js",
+    "clean": "rm -rf dist build",
+    "prepublishOnly": "npm run clean && npm run build"
   },
   "repository": {
     "type": "git",
@@ -57,12 +66,12 @@
   },
   "exports": {
     ".": {
-      "types": "./index.d.ts",
-      "default": "./index.js"
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
     },
     "./utils": {
-      "types": "./utils.d.ts",
-      "default": "./utils.js"
+      "types": "./dist/utils.d.ts",
+      "default": "./dist/utils.js"
     }
   }
 }

package/.codebolt/chat.json

@@ -1 +0,0 @@
-[]

package/.codebolt/debug.json

@@ -1 +0,0 @@
-[]

package/.codebolt/projectState.json

@@ -1,127 +0,0 @@
-{
-  "0": "{",
-  "1": "\n",
-  "2": " ",
-  "3": " ",
-  "4": "\"",
-  "5": "a",
-  "6": "c",
-  "7": "t",
-  "8": "i",
-  "9": "v",
-  "10": "e",
-  "11": "A",
-  "12": "g",
-  "13": "e",
-  "14": "n",
-  "15": "t",
-  "16": "\"",
-  "17": ":",
-  "18": " ",
-  "19": "f",
-  "20": "a",
-  "21": "l",
-  "22": "s",
-  "23": "e",
-  "24": ",",
-  "25": "\n",
-  "26": " ",
-  "27": " ",
-  "28": "\"",
-  "29": "p",
-  "30": "i",
-  "31": "n",
-  "32": "n",
-  "33": "e",
-  "34": "d",
-  "35": "A",
-  "36": "g",
-  "37": "e",
-  "38": "n",
-  "39": "t",
-  "40": "\"",
-  "41": ":",
-  "42": " ",
-  "43": "[",
-  "44": "]",
-  "45": "\n",
-  "46": "}",
-  "currentLayout": {
-    "grid": {
-      "root": {
-        "type": "branch",
-        "data": [
-          {
-            "type": "leaf",
-            "data": {
-              "views": [
-                "Code"
-              ],
-              "activeView": "Code",
-              "id": "1"
-            },
-            "size": 735
-          },
-          {
-            "type": "branch",
-            "data": [
-              {
-                "type": "leaf",
-                "data": {
-                  "views": [
-                    "Chat"
-                  ],
-                  "activeView": "Chat",
-                  "id": "2"
-                },
-                "size": 577
-              },
-              {
-                "type": "leaf",
-                "data": {
-                  "views": [
-                    "Preview"
-                  ],
-                  "activeView": "Preview",
-                  "id": "3"
-                },
-                "size": 283
-              }
-            ],
-            "size": 735
-          }
-        ],
-        "size": 860
-      },
-      "width": 1470,
-      "height": 860,
-      "orientation": "HORIZONTAL"
-    },
-    "panels": {
-      "Code": {
-        "id": "Code",
-        "contentComponent": "Code",
-        "tabComponent": "props.defaultTabComponent",
-        "title": "Code",
-        "renderer": "always"
-      },
-      "Chat": {
-        "id": "Chat",
-        "contentComponent": "Chat",
-        "tabComponent": "props.defaultTabComponent",
-        "title": "Chat",
-        "renderer": "always"
-      },
-      "Preview": {
-        "id": "Preview",
-        "contentComponent": "Preview",
-        "tabComponent": "props.defaultTabComponent",
-        "title": "Preview",
-        "renderer": "always"
-      }
-    },
-    "activeGroup": "1"
-  },
-  "pinnedAgent": [],
-  "activeAgent": false
-}