@codebolt/codeboltjs 1.1.75 → 1.1.77

package/src/modules/fs.ts

@@ -0,0 +1,263 @@
+import cbws from './websocket';
+import {CreateFileResponse,CreateFolderResponse,ReadFileResponse,UpdateFileResponse,DeleteFileResponse,DeleteFolderResponse} from  '@codebolt/types'
+/**
+ * @module cbfs
+ * @description This module provides functionality to interact with the filesystem.
+ */
+const cbfs = {
+    /**
+     * @function createFile
+     * @description Creates a new file.
+     * @param {string} fileName - The name of the file to create.
+     * @param {string} source - The source content to write into the file.
+     * @param {string} filePath - The path where the file should be created.
+     * @returns {Promise<CreateFileResponse>} A promise that resolves with the server response.
+     */
+    createFile: (fileName: string, source: string, filePath: string): Promise<CreateFileResponse> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type":"fsEvent",
+                "action": "createFile",
+                "message": {
+                    fileName,
+                    source,
+                    filePath
+                },
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "createFileResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+    /**
+     * @function createFolder
+     * @description Creates a new folder.
+     * @param {string} folderName - The name of the folder to create.
+     * @param {string} folderPath - The path where the folder should be created.
+     * @returns {Promise<CreateFolderResponse>} A promise that resolves with the server response.
+     */
+    createFolder: (folderName: string, folderPath: string): Promise<CreateFolderResponse> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type":"fsEvent",
+                "action": "createFolder",
+                "message": {
+                    folderName,
+                    folderPath
+                },
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "createFolderResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+    /**
+     * @function readFile
+     * @description Reads the content of a file.
+     * @param {string} filename - The name of the file to read.
+     * @param {string} filePath - The path of the file to read.
+     * @returns {Promise<ReadFileResponse>} A promise that resolves with the server response.
+     */
+    readFile: (filePath: string): Promise<ReadFileResponse> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type":"fsEvent",
+                "action": "readFile",
+                "message": {
+                    filePath
+                },
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "readFileResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+    /**
+     * @function updateFile
+     * @description Updates the content of a file.
+     * @param {string} filename - The name of the file to update.
+     * @param {string} filePath - The path of the file to update.
+     * @param {string} newContent - The new content to write into the file.
+     * @returns {Promise<UpdateFileResponse>} A promise that resolves with the server response.
+     */
+    updateFile: (filename: string, filePath: string, newContent: string): Promise<UpdateFileResponse> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type":"fsEvent",
+                "action": "updateFile",
+                "message": {
+                    filename,
+                    filePath,
+                    newContent
+                },
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "commandOutput") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+    /**
+     * @function deleteFile
+     * @description Deletes a file.
+     * @param {string} filename - The name of the file to delete.
+     * @param {string} filePath - The path of the file to delete.
+     * @returns {Promise<DeleteFileResponse>} A promise that resolves with the server response.
+     */
+    deleteFile: (filename: string, filePath: string): Promise<DeleteFileResponse> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type":"fsEvent",
+                "action": "deleteFile",
+                "message": {
+                    filename,
+                    filePath
+                },
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "deleteFileResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+    /**
+     * @function deleteFolder
+     * @description Deletes a folder.
+     * @param {string} foldername - The name of the folder to delete.
+     * @param {string} folderpath - The path of the folder to delete.
+     * @returns {Promise<DeleteFolderResponse>} A promise that resolves with the server response.
+     */
+    deleteFolder: (foldername: string, folderpath: string): Promise<DeleteFolderResponse> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type":"fsEvent",
+                "action": "deleteFolder",
+                "message": {
+                    foldername,
+                    folderpath
+                },
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "deleteFolderResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+    /**
+     * @function listFile
+     * @description Lists all files.
+     * @returns {Promise<FileListResponse>} A promise that resolves with the list of files.
+     */
+    listFile: (folderPath:string,isRecursive=false) => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "fsEvent",
+                "action": "fileList",
+                message:{
+                    folderPath,
+                    isRecursive
+                }
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "fileListResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+    /**
+     * @function listCodeDefinitionNames
+     * @description Lists all code definition names in a given path.
+     * @param {string} path - The path to search for code definitions.
+     * @returns {Promise<{success: boolean, result: any}>} A promise that resolves with the list of code definition names.
+     */
+    listCodeDefinitionNames: (path: string): Promise<{success: boolean, result: any}> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "fsEvent",
+                "action": "listCodeDefinitionNames",
+                "message": {
+                    path
+                }
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "listCodeDefinitionNamesResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+
+    /**
+     * @function searchFiles
+     * @description Searches files in a given path using a regex pattern.
+     * @param {string} path - The path to search within.
+     * @param {string} regex - The regex pattern to search for.
+     * @param {string} filePattern - The file pattern to match files.
+     * @returns {Promise<{success: boolean, result: any}>} A promise that resolves with the search results.
+     */
+    searchFiles: (path: string, regex: string, filePattern: string): Promise<{success: boolean, result: any}> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "fsEvent",
+                "action": "searchFiles",
+                "message": {
+                    path,
+                    regex,
+                    filePattern
+                }
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "searchFilesResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+    /**
+     * @function writeToFile
+     * @description Writes content to a file.
+     * @param {string} relPath - The relative path of the file to write to.
+     * @param {string} newContent - The new content to write into the file.
+     * @returns {Promise<{success: boolean, result: any}>} A promise that resolves with the write operation result.
+     */
+    writeToFile: (relPath:string, newContent:string) => {
+        return new Promise((resolve, reject) => {
+             cbws.getWebsocket.send(JSON.stringify({
+                "type": "fsEvent",
+                "action": "writeToFile",
+                "message": {
+                    relPath,
+                    newContent
+                }
+            }));
+             cbws.getWebsocket.on('message', (data:string) => {
+                const response = JSON.parse(data);
+                if (response.type === "writeToFileResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+  
+};
+
+export default cbfs;

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;