@codebolt/codeboltjs 1.1.75 → 1.1.77

package/src/modules/mcp.ts

@@ -0,0 +1,127 @@
+import cbws from './websocket';
+const codeboltMCP = {
+
+    executeTool: ( toolName: string, params: any,mcpServer?: string,): Promise<any> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "mcpEvent",
+                "action": "executeTool",
+                "toolName": toolName,
+                "params": params
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                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"));
+                }
+            });
+            cbws.getWebsocket.on('error', (error: Error) => {
+                reject(error);
+            });
+        });
+    },
+    getMcpTools: (tools: string[]): Promise<any> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "mcpEvent",
+                "action": "getMcpTools",
+                "tools": tools
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                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"));
+                }
+            });
+            cbws.getWebsocket.on('error', (error: Error) => {
+                reject(error);
+            });
+        });
+
+    },
+    getAllMCPTools: (mpcName: string): Promise<any> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "mcpEvent",
+                "action": "getAllMCPTools",
+                "mpcName": mpcName
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                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"));
+                }
+            });
+            cbws.getWebsocket.on('error', (error: Error) => {
+                reject(error);
+            });
+        });
+    },
+    getMCPTool: (name: string): Promise<any> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "mcpEvent",
+                "action": "getMCPTool",
+                "mcpName": name
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                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"));
+                }
+            });
+            cbws.getWebsocket.on('error', (error: Error) => {
+                reject(error);
+            });
+        });
+    },
+    getEnabledMCPS: (): Promise<any> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "mcpEvent",
+                "action": "getEnabledMCPS"
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                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"));
+                }
+            });
+            cbws.getWebsocket.on('error', (error: Error) => {
+                reject(error);
+            });
+        });
+    },
+}
+
+export default codeboltMCP;

package/src/modules/outputparsers.ts

@@ -0,0 +1,30 @@
+/**
+ * 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: any) => {
+        // 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: any): string[] => {
+        return output.split('\n').filter((line: string) => 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: any): string[] => {
+        return output.split('\n').filter((line: string) => line.includes('Warning:'));
+    }
+};
+export default cboutputparsers;

package/src/modules/project.ts

@@ -0,0 +1,68 @@
+import cbws from './websocket';
+import { GetProjectPathResponse } from '@codebolt/types';
+/**
+ * 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: any) => {
+        // 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: (): Promise<GetProjectPathResponse> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "settingEvent",
+                "action": "getProjectPath"
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "getProjectPathResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+    getRepoMap: (message: any): Promise<GetProjectPathResponse> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "settingEvent",
+                "action": "getRepoMap",
+                message
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "getRepoMapResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+    runProject: () => {
+        cbws.getWebsocket.send(JSON.stringify({
+            "type": "runProject"
+        }));
+    },
+    getEditorFileStatus:()=>{
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "settingEvent",
+                "action": "getEditorFileStatus",
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "getEditorFileStatusResponse") {
+                    resolve(response);
+                }
+            });
+        }); 
+    }
+};
+export default cbproject

package/src/modules/rag.ts

@@ -0,0 +1,28 @@
+/**
+ * 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: string, file_path: string) => {
+        // 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: string, filename: string) => {
+        // Implementation for retrieving related knowledge will be added here
+    },
+};
+export default cbrag;

package/src/modules/search.ts

@@ -0,0 +1,35 @@
+/**
+ * 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: string = "bing"): void => {
+        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: string): Promise<string> => {
+        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: string): Promise<string> => {
+        console.log("Getting first link for " + query);
+        return new Promise((resolve, reject) => {
+            resolve("First Link for " + query);
+        });
+    }
+};
+export default cbsearch;

package/src/modules/state.ts

@@ -0,0 +1,69 @@
+import cbws from './websocket';
+import {ApplicationState,AddToAgentStateResponse,GetAgentStateResponse } from '@codebolt/types';
+
+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 (): Promise<ApplicationState> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "getAppState",
+                
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                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: string, value: string): Promise<AddToAgentStateResponse> => {
+      return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "agentStateEvent",
+                "action":"addToAgentState",
+                payload:{
+                    key,
+                    value
+                }
+                
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                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 (): Promise<GetAgentStateResponse> => {
+       return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "agentStateEvent",
+                "action":"getAgentState",
+                
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "getAgentStateResponse") {
+                    resolve(response); // Resolve the Promise with the response data
+                }
+            });
+        });  
+    }
+};
+
+export default cbstate;

package/src/modules/task.ts

@@ -0,0 +1,73 @@
+import cbws from './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: string): Promise<any> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "taskEvent",
+                "action":"addTask",
+                message:{
+                    "task": task
+                }
+               
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                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 (): Promise<any> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type":"taskEvent",
+                "action": "getTasks"
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                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: string): Promise<any> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "taskEvent",
+                "action": "updateTask",
+                message: {
+                    "task": task
+                }
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "updateTaskResponse") {
+                    resolve(response); // Resolve the promise with the response data from updating the task
+                }
+            });
+        });
+    }
+};
+
+export default taskplaner;

package/src/modules/terminal.ts

@@ -0,0 +1,114 @@
+import cbws from './websocket';
+import { EventEmitter } from 'events';
+import {CommandError,CommandFinish,CommandOutput,TerminalInterruptResponse,TerminalInterrupted } from '@codebolt/types';
+/**
+ * CustomEventEmitter class that extends the Node.js EventEmitter class.
+ */
+class CustomEventEmitter extends EventEmitter {}
+/**
+ * A module for executing commands in a terminal-like environment via WebSocket.
+ */
+const cbterminal = {
+    eventEmitter: new CustomEventEmitter(),
+
+    /**
+     * Executes a given command and returns the result.
+     * Listens for messages from the WebSocket that indicate the output, error, or finish state
+     * of the executed command and resolves the promise accordingly.
+     *
+     * @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: async (command:string, returnEmptyStringOnSuccess:boolean = false) => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "executeCommand",
+                "message": command,
+                returnEmptyStringOnSuccess
+            }));
+            let result = "";
+            cbws.getWebsocket.on('message', (data:string) => {
+                const response = JSON.parse(data);
+                if (response.type === "commandError" || response.type === "commandFinish" ) {
+                   resolve(response)
+                }
+            });
+        });
+    },
+
+    /**
+     * 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.
+     *
+     * @param {string} command - The command to be executed.
+     * @returns {Promise<CommandError>} A promise that resolves when an error occurs during command execution.
+     */
+    executeCommandRunUntilError: async (command: string,executeInMain=false): Promise<CommandError> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "executeCommandRunUntilError",
+                "message": command,
+                executeInMain
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if ( response.type === "commandError") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+
+  
+    /**
+     * Sends a manual interrupt signal to the terminal.
+     *
+     * @returns {Promise<TerminalInterruptResponse>} 
+     */
+    sendManualInterrupt(): Promise<TerminalInterruptResponse>  {
+       
+        return new Promise((resolve, reject) => {
+           cbws.getWebsocket.send(JSON.stringify({
+            "type": "sendInterruptToTerminal"
+        }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "terminalInterrupted") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+
+    /**
+     * Executes a given command and streams the output.
+     * Listens for messages from the WebSocket and streams the output data.
+     *
+     * @param {string} command - The command to be executed.
+     * @returns {EventEmitter} A promise that streams the output data during command execution.
+     */
+    executeCommandWithStream(command: string,executeInMain=false):EventEmitter {
+         // Send the process started message
+         cbws.getWebsocket.send(JSON.stringify({
+            "type": "executeCommandWithStream",
+            "message": command
+            ,executeInMain
+        }));
+        // Register event listener for WebSocket messages
+        cbws.getWebsocket.on('message', (data: string) => {
+            const response = JSON.parse(data);
+            console.log("Received message:", 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
+    
+    }
+   
+
+ 
+};
+export default cbterminal;

package/src/modules/tokenizer.ts

@@ -0,0 +1,56 @@
+import { AddTokenResponse, GetTokenResponse } from '@codebolt/types';
+import cbws from './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: string): Promise<AddTokenResponse> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type":"tokenizerEvent",
+                "action": "addToken",
+                "message": {
+                    item: key
+                },
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "addTokenResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+
+    /**
+     * 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: string): Promise<GetTokenResponse> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type":"tokenizerEvent",
+                "action": "getToken",
+                "message": {
+                    item: key
+                },
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "getTokenResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    }
+}
+
+export default tokenizer