@codebolt/codeboltjs 1.1.76 → 1.1.78

package/src/modules/git.ts

@@ -0,0 +1,237 @@
+import cbws from './websocket';
+
+/**
+ * A service for interacting with Git operations via WebSocket messages.
+ */
+const gitService = {
+    /**
+     * Initializes a new Git repository at the given path.
+     * @param {string} path - The file system path where the Git repository should be initialized.
+     * @returns {Promise<any>} A promise that resolves with the response from the init event.
+     */
+    init: async (path: string): Promise<any> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "gitEvent",
+                "action": "Init",
+                "path": path
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "InitResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+    /**
+     * Clones a Git repository from the given URL to the specified path.
+     * @param {string} url - The URL of the Git repository to clone.
+     * @param {string} path - The file system path where the repository should be cloned to.
+     * @returns {Promise<any>} A promise that resolves with the response from the clone event.
+     */
+    clone: async (url: string, path: string): Promise<any> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "gitEvent",
+                "action": "Clone",
+                "url": url,
+                "path": path
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "CloneResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+    /**
+     * Pulls the latest changes from the remote repository to the local repository at the given path.
+     * @param {string} path - The file system path of the local Git repository.
+     * @returns {Promise<any>} A promise that resolves with the response from the pull event.
+     */
+    pull: async (path: string): Promise<any> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "gitEvent",
+                "action": "Pull",
+                "path": path
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "PullResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+    /**
+     * Pushes local repository changes to the remote repository at the given path.
+     * @param {string} path - The file system path of the local Git repository.
+     * @returns {Promise<any>} A promise that resolves with the response from the push event.
+     */
+    push: async (path: string): Promise<any> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "gitEvent",
+                "action": "Push",
+                "path": path
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "PushResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+    /**
+     * Retrieves the status of the local repository at the given path.
+     * @param {string} path - The file system path of the local Git repository.
+     * @returns {Promise<any>} A promise that resolves with the response from the status event.
+     */
+    status: async (path: string): Promise<any> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "gitEvent",
+                "action": "Status",
+                "path": path
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "StatusResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+    /**
+     * Adds changes in the local repository to the staging area at the given path.
+     * @param {string} path - The file system path of the local Git repository.
+     * @returns {Promise<any>} A promise that resolves with the response from the add event.
+     */
+    add: async (path: string): Promise<any> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "gitEvent",
+                "action": "Add",
+                "path": path
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "AddResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+    /**
+     * Commits the staged changes in the local repository with the given commit message.
+     * @param {string} message - The commit message to use for the commit.
+     * @returns {Promise<any>} A promise that resolves with the response from the commit event.
+     */
+    commit: async (message: string): Promise<any> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "gitEvent",
+                "action": "Commit",
+                "message": message
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "gitCommitResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+    /**
+     * Checks out a branch or commit in the local repository at the given path.
+     * @param {string} path - The file system path of the local Git repository.
+     * @param {string} branch - The name of the branch or commit to check out.
+     * @returns {Promise<any>} A promise that resolves with the response from the checkout event.
+     */
+    checkout: async (path: string, branch: string): Promise<any> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "gitEvent",
+                "action": "Checkout",
+                "path": path,
+                "branch": branch
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "CheckoutResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+    /**
+     * Creates a new branch in the local repository at the given path.
+     * @param {string} path - The file system path of the local Git repository.
+     * @param {string} branch - The name of the new branch to create.
+     * @returns {Promise<any>} A promise that resolves with the response from the branch event.
+     */
+    branch: async (path: string, branch: string): Promise<any> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "gitEvent",
+                "action": "Branch",
+                "path": path,
+                "branch": branch
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "BranchResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+    /**
+     * Retrieves the commit logs for the local repository at the given path.
+     * @param {string} path - The file system path of the local Git repository.
+     * @returns {Promise<any>} A promise that resolves with the response from the logs event.
+     */
+    logs: async (path: string): Promise<any> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "gitEvent",
+                "action": "Logs",
+                "path": path
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "LogsResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+    /**
+     * Retrieves the diff of changes for a specific commit in the local repository.
+     * @param {string} commitHash - The hash of the commit to retrieve the diff for.
+     * @param {string} path - The file system path of the local Git repository.
+     * @returns {Promise<any>} A promise that resolves with the response from the diff event.
+     */
+    diff: async (commitHash: string, path: string): Promise<any> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "gitEvent",
+                "action": "Diff",
+                "path": path,
+                "commitHash": commitHash
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "DiffResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    }
+};
+
+export default gitService;

package/src/modules/history.ts

@@ -0,0 +1,61 @@
+import cbws from './websocket';
+
+export enum logType {
+    info = "info",
+    error = "error",
+    warning = "warning"
+}
+
+
+export const chatSummary = {
+
+    summarizeAll: (): Promise<{
+        role: string;
+        content: string;
+    }[]> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "chatSummaryEvent",
+                "action": "summarizeAll",
+
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "getSummarizeAllResponse") {
+                    resolve(response.payload); // Resolve the Promise with the response data
+                }
+            })
+        })
+
+
+    },
+    summarize: (messages: {
+        role: string;
+        content: string;
+    }[], depth: number): Promise<{
+        role: string;
+        content: string;
+    }[]> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "chatSummaryEvent",
+                "action": "summarize",
+                messages,
+                depth
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "getSummarizeResponse") {
+                    resolve(response.payload); // Resolve the Promise with the response data
+                }
+            })
+        })
+
+    }
+}
+
+
+export default chatSummary;
+
+
+

package/src/modules/knowledge.ts

@@ -0,0 +1,5 @@
+const cbKnowledge = {
+    // Methods related to knowledge handling can be added here
+};
+
+export default cbKnowledge;

package/src/modules/llm.ts

@@ -0,0 +1,36 @@
+import cbws from './websocket';
+import {LLMResponse } from '@codebolt/types';
+/**
+ * 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: string, llmrole: string): Promise<LLMResponse> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "inference",
+                "message": {
+                    prompt: message,
+                    llmrole
+                },
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "llmResponse") {
+                    resolve(response); // Resolve the Promise with the response data
+                }
+            });
+        });
+    }
+};
+
+export default cbllm;

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;