@codebolt/codeboltjs 1.1.76 → 1.1.78

package/modules/llm.js

@@ -0,0 +1,39 @@
+"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("./websocket"));
+/**
+ * A module for interacting with language learning models (LLMs) via WebSocket.
+ */
+const cbllm = {
+    /**
+     * Sends an inference request to the LLM and returns the model's response.
+     * The model is selected based on the provided `llmrole`. If the specific model
+     * for the role is not found, it falls back to the default model for the current agent,
+     * and ultimately to the default application-wide LLM if necessary.
+     *
+     * @param {string} message - The input message or prompt to be sent to the LLM.
+     * @param {string} llmrole - The role of the LLM to determine which model to use.
+     * @returns {Promise<LLMResponse>} A promise that resolves with the LLM's response.
+     */
+    inference: async (message, llmrole) => {
+        return new Promise((resolve, reject) => {
+            websocket_1.default.getWebsocket.send(JSON.stringify({
+                "type": "inference",
+                "message": {
+                    prompt: message,
+                    llmrole
+                },
+            }));
+            websocket_1.default.getWebsocket.on('message', (data) => {
+                const response = JSON.parse(data);
+                if (response.type === "llmResponse") {
+                    resolve(response); // Resolve the Promise with the response data
+                }
+            });
+        });
+    }
+};
+exports.default = cbllm;

package/modules/mcp.d.ts

@@ -0,0 +1,8 @@
+declare const codeboltMCP: {
+    executeTool: (toolName: string, params: any, mcpServer?: string) => Promise<any>;
+    getMcpTools: (tools: string[]) => Promise<any>;
+    getAllMCPTools: (mpcName: string) => Promise<any>;
+    getMCPTool: (name: string) => Promise<any>;
+    getEnabledMCPS: () => Promise<any>;
+};
+export default codeboltMCP;

package/modules/mcp.js

@@ -0,0 +1,139 @@
+"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("./websocket"));
+const codeboltMCP = {
+    executeTool: (toolName, params, mcpServer) => {
+        return new Promise((resolve, reject) => {
+            websocket_1.default.getWebsocket.send(JSON.stringify({
+                "type": "mcpEvent",
+                "action": "executeTool",
+                "toolName": toolName,
+                "params": params
+            }));
+            websocket_1.default.getWebsocket.on('message', (data) => {
+                try {
+                    const response = JSON.parse(data);
+                    if (response.type === "executeToolResponse") {
+                        resolve(response.data);
+                    }
+                    else {
+                        reject(new Error("Unexpected response type"));
+                    }
+                }
+                catch (error) {
+                    reject(new Error("Failed to parse response"));
+                }
+            });
+            websocket_1.default.getWebsocket.on('error', (error) => {
+                reject(error);
+            });
+        });
+    },
+    getMcpTools: (tools) => {
+        return new Promise((resolve, reject) => {
+            websocket_1.default.getWebsocket.send(JSON.stringify({
+                "type": "mcpEvent",
+                "action": "getMcpTools",
+                "tools": tools
+            }));
+            websocket_1.default.getWebsocket.on('message', (data) => {
+                try {
+                    const response = JSON.parse(data);
+                    if (response.type === "getMcpToolsResponse") {
+                        resolve(response.data);
+                    }
+                    else {
+                        reject(new Error("Unexpected response type"));
+                    }
+                }
+                catch (error) {
+                    reject(new Error("Failed to parse response"));
+                }
+            });
+            websocket_1.default.getWebsocket.on('error', (error) => {
+                reject(error);
+            });
+        });
+    },
+    getAllMCPTools: (mpcName) => {
+        return new Promise((resolve, reject) => {
+            websocket_1.default.getWebsocket.send(JSON.stringify({
+                "type": "mcpEvent",
+                "action": "getAllMCPTools",
+                "mpcName": mpcName
+            }));
+            websocket_1.default.getWebsocket.on('message', (data) => {
+                try {
+                    const response = JSON.parse(data);
+                    if (response.type === "getAllMCPToolsResponse") {
+                        resolve(response.data);
+                    }
+                    else {
+                        reject(new Error("Unexpected response type"));
+                    }
+                }
+                catch (error) {
+                    reject(new Error("Failed to parse response"));
+                }
+            });
+            websocket_1.default.getWebsocket.on('error', (error) => {
+                reject(error);
+            });
+        });
+    },
+    getMCPTool: (name) => {
+        return new Promise((resolve, reject) => {
+            websocket_1.default.getWebsocket.send(JSON.stringify({
+                "type": "mcpEvent",
+                "action": "getMCPTool",
+                "mcpName": name
+            }));
+            websocket_1.default.getWebsocket.on('message', (data) => {
+                try {
+                    const response = JSON.parse(data);
+                    if (response.type === "getMCPToolResponse") {
+                        resolve(response.data);
+                    }
+                    else {
+                        reject(new Error("Unexpected response type"));
+                    }
+                }
+                catch (error) {
+                    reject(new Error("Failed to parse response"));
+                }
+            });
+            websocket_1.default.getWebsocket.on('error', (error) => {
+                reject(error);
+            });
+        });
+    },
+    getEnabledMCPS: () => {
+        return new Promise((resolve, reject) => {
+            websocket_1.default.getWebsocket.send(JSON.stringify({
+                "type": "mcpEvent",
+                "action": "getEnabledMCPS"
+            }));
+            websocket_1.default.getWebsocket.on('message', (data) => {
+                try {
+                    const response = JSON.parse(data);
+                    if (response.type === "getEnabledMCPSResponse") {
+                        resolve(response.data);
+                    }
+                    else {
+                        reject(new Error("Unexpected response type"));
+                    }
+                }
+                catch (error) {
+                    reject(new Error("Failed to parse response"));
+                }
+            });
+            websocket_1.default.getWebsocket.on('error', (error) => {
+                reject(error);
+            });
+        });
+    },
+};
+exports.default = codeboltMCP;

package/modules/outputparsers.d.ts

@@ -0,0 +1,24 @@
+/**
+ * A module for parsing output messages to identify errors and warnings.
+ */
+declare const cboutputparsers: {
+    /**
+     * Initializes the output parser module.
+     * Currently, this function does not perform any operations.
+     * @param {any} output - The output to be initialized.
+     */
+    init: (output: any) => void;
+    /**
+     * Parses the given output and returns all the error messages.
+     * @param {any} output - The output to parse for error messages.
+     * @returns {string[]} An array of error messages.
+     */
+    parseErrors: (output: any) => string[];
+    /**
+     * Parses the given output and returns all the warning messages.
+     * @param {any} output - The output to parse for warning messages.
+     * @returns {string[]} An array of warning messages.
+     */
+    parseWarnings: (output: any) => string[];
+};
+export default cboutputparsers;

package/modules/outputparsers.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * A module for parsing output messages to identify errors and warnings.
+ */
+const cboutputparsers = {
+    /**
+     * Initializes the output parser module.
+     * Currently, this function does not perform any operations.
+     * @param {any} output - The output to be initialized.
+     */
+    init: (output) => {
+        // Initialization code can be added here if necessary
+    },
+    /**
+     * Parses the given output and returns all the error messages.
+     * @param {any} output - The output to parse for error messages.
+     * @returns {string[]} An array of error messages.
+     */
+    parseErrors: (output) => {
+        return output.split('\n').filter((line) => line.includes('Error:'));
+    },
+    /**
+     * Parses the given output and returns all the warning messages.
+     * @param {any} output - The output to parse for warning messages.
+     * @returns {string[]} An array of warning messages.
+     */
+    parseWarnings: (output) => {
+        return output.split('\n').filter((line) => line.includes('Warning:'));
+    }
+};
+exports.default = cboutputparsers;

package/modules/project.d.ts

@@ -0,0 +1,21 @@
+import { GetProjectPathResponse } from '@codebolt/types';
+/**
+ * A module for interacting with project settings and paths.
+ */
+declare const cbproject: {
+    /**
+     * Placeholder for a method to get project settings.
+     * Currently, this method does not perform any operations.
+     * @param {any} output - The output where project settings would be stored.
+     */
+    getProjectSettings: (output: any) => void;
+    /**
+     * Retrieves the path of the current project.
+     * @returns {Promise<GetProjectPathResponse>} A promise that resolves with the project path response.
+     */
+    getProjectPath: () => Promise<GetProjectPathResponse>;
+    getRepoMap: (message: any) => Promise<GetProjectPathResponse>;
+    runProject: () => void;
+    getEditorFileStatus: () => Promise<unknown>;
+};
+export default cbproject;

package/modules/project.js

@@ -0,0 +1,72 @@
+"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("./websocket"));
+/**
+ * A module for interacting with project settings and paths.
+ */
+const cbproject = {
+    /**
+     * Placeholder for a method to get project settings.
+     * Currently, this method does not perform any operations.
+     * @param {any} output - The output where project settings would be stored.
+     */
+    getProjectSettings: (output) => {
+        // Implementation for getting project settings will be added here
+    },
+    /**
+     * Retrieves the path of the current project.
+     * @returns {Promise<GetProjectPathResponse>} A promise that resolves with the project path response.
+     */
+    getProjectPath: () => {
+        return new Promise((resolve, reject) => {
+            websocket_1.default.getWebsocket.send(JSON.stringify({
+                "type": "settingEvent",
+                "action": "getProjectPath"
+            }));
+            websocket_1.default.getWebsocket.on('message', (data) => {
+                const response = JSON.parse(data);
+                if (response.type === "getProjectPathResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+    getRepoMap: (message) => {
+        return new Promise((resolve, reject) => {
+            websocket_1.default.getWebsocket.send(JSON.stringify({
+                "type": "settingEvent",
+                "action": "getRepoMap",
+                message
+            }));
+            websocket_1.default.getWebsocket.on('message', (data) => {
+                const response = JSON.parse(data);
+                if (response.type === "getRepoMapResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+    runProject: () => {
+        websocket_1.default.getWebsocket.send(JSON.stringify({
+            "type": "runProject"
+        }));
+    },
+    getEditorFileStatus: () => {
+        return new Promise((resolve, reject) => {
+            websocket_1.default.getWebsocket.send(JSON.stringify({
+                "type": "settingEvent",
+                "action": "getEditorFileStatus",
+            }));
+            websocket_1.default.getWebsocket.on('message', (data) => {
+                const response = JSON.parse(data);
+                if (response.type === "getEditorFileStatusResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    }
+};
+exports.default = cbproject;

package/modules/rag.d.ts

@@ -0,0 +1,22 @@
+/**
+ * A module for managing files within the CodeBolt File System.
+ */
+declare const cbrag: {
+    /**
+     * Initializes the CodeBolt File System Module.
+     */
+    init: () => void;
+    /**
+     * Adds a file to the CodeBolt File System.
+     * @param {string} filename - The name of the file to add.
+     * @param {string} file_path - The path where the file should be added.
+     */
+    add_file: (filename: string, file_path: string) => void;
+    /**
+     * Retrieves related knowledge for a given query and filename.
+     * @param {string} query - The query to retrieve related knowledge for.
+     * @param {string} filename - The name of the file associated with the query.
+     */
+    retrieve_related_knowledge: (query: string, filename: string) => void;
+};
+export default cbrag;

package/modules/rag.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * A module for managing files within the CodeBolt File System.
+ */
+const cbrag = {
+    /**
+     * Initializes the CodeBolt File System Module.
+     */
+    init: () => {
+        console.log("Initializing CodeBolt File System Module");
+    },
+    /**
+     * Adds a file to the CodeBolt File System.
+     * @param {string} filename - The name of the file to add.
+     * @param {string} file_path - The path where the file should be added.
+     */
+    add_file: (filename, file_path) => {
+        // Implementation for adding a file will be added here
+    },
+    /**
+     * Retrieves related knowledge for a given query and filename.
+     * @param {string} query - The query to retrieve related knowledge for.
+     * @param {string} filename - The name of the file associated with the query.
+     */
+    retrieve_related_knowledge: (query, filename) => {
+        // Implementation for retrieving related knowledge will be added here
+    },
+};
+exports.default = cbrag;

package/modules/search.d.ts

@@ -0,0 +1,23 @@
+/**
+ * A module for handling search operations.
+ */
+declare const cbsearch: {
+    /**
+     * Initializes the search module with the specified search engine.
+     * @param {string} [engine="bing"] - The search engine to use for initializing the module.
+     */
+    init: (engine?: string) => void;
+    /**
+     * Performs a search operation for the given query.
+     * @param {string} query - The search query.
+     * @returns {Promise<string>} A promise that resolves with the search results.
+     */
+    search: (query: string) => Promise<string>;
+    /**
+     * Retrieves the first link from the search results for the given query.
+     * @param {string} query - The search query.
+     * @returns {Promise<string>} A promise that resolves with the first link of the search results.
+     */
+    get_first_link: (query: string) => Promise<string>;
+};
+export default cbsearch;

package/modules/search.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * A module for handling search operations.
+ */
+const cbsearch = {
+    /**
+     * Initializes the search module with the specified search engine.
+     * @param {string} [engine="bing"] - The search engine to use for initializing the module.
+     */
+    init: (engine = "bing") => {
+        console.log("Initializing Search Module with engine: " + engine);
+    },
+    /**
+     * Performs a search operation for the given query.
+     * @param {string} query - The search query.
+     * @returns {Promise<string>} A promise that resolves with the search results.
+     */
+    search: async (query) => {
+        console.log("Searching for " + query);
+        return new Promise((resolve, reject) => {
+            resolve("Search Results for " + query);
+        });
+    },
+    /**
+     * Retrieves the first link from the search results for the given query.
+     * @param {string} query - The search query.
+     * @returns {Promise<string>} A promise that resolves with the first link of the search results.
+     */
+    get_first_link: async (query) => {
+        console.log("Getting first link for " + query);
+        return new Promise((resolve, reject) => {
+            resolve("First Link for " + query);
+        });
+    }
+};
+exports.default = cbsearch;

package/modules/state.d.ts

@@ -0,0 +1,21 @@
+import { ApplicationState, AddToAgentStateResponse, GetAgentStateResponse } from '@codebolt/types';
+declare const cbstate: {
+    /**
+     * Retrieves the current application state from the server via WebSocket.
+     * @returns {Promise<ApplicationState>} A promise that resolves with the application state.
+     */
+    getApplicationState: () => Promise<ApplicationState>;
+    /**
+     * Adds a key-value pair to the agent's state on the server via WebSocket.
+     * @param {string} key - The key to add to the agent's state.
+     * @param {string} value - The value associated with the key.
+     * @returns {Promise<AddToAgentStateResponse>} A promise that resolves with the response to the addition request.
+     */
+    addToAgentState: (key: string, value: string) => Promise<AddToAgentStateResponse>;
+    /**
+     * Retrieves the current state of the agent from the server via WebSocket.
+     * @returns {Promise<GetAgentStateResponse>} A promise that resolves with the agent's state.
+     */
+    getAgentState: () => Promise<GetAgentStateResponse>;
+};
+export default cbstate;

package/modules/state.js

@@ -0,0 +1,68 @@
+"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("./websocket"));
+const cbstate = {
+    /**
+     * Retrieves the current application state from the server via WebSocket.
+     * @returns {Promise<ApplicationState>} A promise that resolves with the application state.
+     */
+    getApplicationState: async () => {
+        return new Promise((resolve, reject) => {
+            websocket_1.default.getWebsocket.send(JSON.stringify({
+                "type": "getAppState",
+            }));
+            websocket_1.default.getWebsocket.on('message', (data) => {
+                const response = JSON.parse(data);
+                if (response.type === "getAppStateResponse") {
+                    resolve(response); // Resolve the Promise with the response data
+                }
+            });
+        });
+    },
+    /**
+     * Adds a key-value pair to the agent's state on the server via WebSocket.
+     * @param {string} key - The key to add to the agent's state.
+     * @param {string} value - The value associated with the key.
+     * @returns {Promise<AddToAgentStateResponse>} A promise that resolves with the response to the addition request.
+     */
+    addToAgentState: async (key, value) => {
+        return new Promise((resolve, reject) => {
+            websocket_1.default.getWebsocket.send(JSON.stringify({
+                "type": "agentStateEvent",
+                "action": "addToAgentState",
+                payload: {
+                    key,
+                    value
+                }
+            }));
+            websocket_1.default.getWebsocket.on('message', (data) => {
+                const response = JSON.parse(data);
+                if (response.type === "addToAgentStateResponse") {
+                    resolve(response); // Resolve the Promise with the response data
+                }
+            });
+        });
+    },
+    /**
+     * Retrieves the current state of the agent from the server via WebSocket.
+     * @returns {Promise<GetAgentStateResponse>} A promise that resolves with the agent's state.
+     */
+    getAgentState: async () => {
+        return new Promise((resolve, reject) => {
+            websocket_1.default.getWebsocket.send(JSON.stringify({
+                "type": "agentStateEvent",
+                "action": "getAgentState",
+            }));
+            websocket_1.default.getWebsocket.on('message', (data) => {
+                const response = JSON.parse(data);
+                if (response.type === "getAgentStateResponse") {
+                    resolve(response); // Resolve the Promise with the response data
+                }
+            });
+        });
+    }
+};
+exports.default = cbstate;

package/modules/task.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Manages task operations via WebSocket communication.
+ */
+declare 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: (task: string) => Promise<any>;
+    /**
+     * Retrieves all tasks using a WebSocket message.
+     * @returns {Promise<GetTasksResponse>} A promise that resolves with the response from the get tasks event.
+     */
+    getTasks: () => Promise<any>;
+    /**
+     * 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: (task: string) => Promise<any>;
+};
+export default taskplaner;

package/modules/task.js

@@ -0,0 +1,75 @@
+"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("./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 new Promise((resolve, reject) => {
+            websocket_1.default.getWebsocket.send(JSON.stringify({
+                "type": "taskEvent",
+                "action": "addTask",
+                message: {
+                    "task": task
+                }
+            }));
+            websocket_1.default.getWebsocket.on('message', (data) => {
+                const response = JSON.parse(data);
+                if (response.type === "addTaskResponse") {
+                    resolve(response); // Resolve the promise with the response data from adding the task
+                }
+            });
+        });
+    },
+    /**
+     * 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 new Promise((resolve, reject) => {
+            websocket_1.default.getWebsocket.send(JSON.stringify({
+                "type": "taskEvent",
+                "action": "getTasks"
+            }));
+            websocket_1.default.getWebsocket.on('message', (data) => {
+                const response = JSON.parse(data);
+                if (response.type === "getTasksResponse") {
+                    resolve(response); // Resolve the promise with the response data from retrieving tasks
+                }
+            });
+        });
+    },
+    /**
+     * 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 new Promise((resolve, reject) => {
+            websocket_1.default.getWebsocket.send(JSON.stringify({
+                "type": "taskEvent",
+                "action": "updateTask",
+                message: {
+                    "task": task
+                }
+            }));
+            websocket_1.default.getWebsocket.on('message', (data) => {
+                const response = JSON.parse(data);
+                if (response.type === "updateTaskResponse") {
+                    resolve(response); // Resolve the promise with the response data from updating the task
+                }
+            });
+        });
+    }
+};
+exports.default = taskplaner;