@codebolt/codeboltjs 1.0.0 → 1.0.1

package/src/modules/crawler.ts

@@ -0,0 +1,109 @@
+import cbws from './websocket';
+
+/**
+ * A module for controlling a web crawler through WebSocket messages.
+ */
+const cbcrawler = {
+    /**
+     * Starts the crawler.
+     */
+    start: () => {
+       cbws.getWebsocket.send(JSON.stringify({
+            "type": "crawlerEvent",
+            action: 'start'
+        }));
+    },
+    /**
+     * Takes a screenshot using the crawler.
+     */
+    screenshot: () => {
+       cbws.getWebsocket.send(JSON.stringify({
+            "type": "crawlerEvent",
+            action: 'screenshot'
+        }));
+    },
+    /**
+     * Directs the crawler to navigate to a specified URL.
+     * @param url - The URL for the crawler to navigate to.
+     */
+    goToPage: (url: string) => {
+       cbws.getWebsocket.send(JSON.stringify({
+            "type": "crawlerEvent",
+            action: 'goToPage',
+            url
+        }));
+    },
+    /**
+     * Scrolls the crawler in a specified direction.
+     * @param direction - The direction to scroll ('up', 'down', 'left', 'right').
+     */
+    scroll: (direction: string) => {
+       cbws.getWebsocket.send(JSON.stringify({
+            "type": "crawlerEvent",
+            action: 'scroll',
+            direction
+        }));
+    },
+    /**
+     * Simulates a click event on an element with the specified ID.
+     * @param id - The ID of the element to be clicked.
+     * @returns {Promise<any>} A promise that resolves when the click action is complete.
+     */
+    click: (id: string) => {
+        return new Promise((resolve, reject) => {
+           cbws.getWebsocket.send(JSON.stringify({
+                "type": "crawlerEvent",
+                action: 'click',
+                id
+            }));
+           cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.event === "clickFinished") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+    /**
+     * Types the provided text into an element with the specified ID.
+     * @param id - The ID of the element where text will be typed.
+     * @param text - The text to type into the element.
+     * @returns {Promise<any>} A promise that resolves when the type action is complete.
+     */
+    type: (id: string, text: string) => {
+        return new Promise((resolve, reject) => {
+           cbws.getWebsocket.send(JSON.stringify({
+                "type": "crawlerEvent",
+                action: 'type',
+                id,
+                text
+            }));
+           cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.event === "typeFinished") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+    /**
+     * Simulates the Enter key press using the crawler.
+     */
+    enter: () => {
+       cbws.getWebsocket.send(JSON.stringify({
+            "type": "crawlerEvent",
+            action: 'enter'
+        }));
+    },
+    /**
+     * Initiates a crawl process.
+     */
+    crawl: () => {
+       cbws.getWebsocket.send(JSON.stringify({
+            "type": "crawlerEvent",
+            action: 'crawl'
+        }));
+    }
+};
+
+export default cbcrawler;

package/src/modules/dbmemory.ts

@@ -0,0 +1,51 @@
+import cbws from './websocket';
+
+/**
+ * A module for handling in-memory database operations via WebSocket.
+ */
+const dbmemory = {
+    /**
+     * Adds a key-value pair to the in-memory database.
+     * @param {string} key - The key under which to store the value.
+     * @param {any} value - The value to be stored.
+     * @returns {Promise<any>} A promise that resolves with the response from the memory set event.
+     */
+    addKnowledge: (key: string, value: any): Promise<any> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "memoryEvent",
+                'action': 'set',
+                key,
+                value
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "memorySetResponse") {
+                    resolve(response); // Resolve the Promise with the response data
+                }
+            });
+        });
+    },
+    /**
+     * Retrieves a value from the in-memory database by key.
+     * @param {string} key - The key of the value to retrieve.
+     * @returns {Promise<any>} A promise that resolves with the response from the memory get event.
+     */
+    getKnowledge: (key: string): Promise<any> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "memoryEvent",
+                'action': 'get',
+                key
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "memoryGetResponse") {
+                    resolve(response); // Resolve the Promise with the response data
+                }
+            });
+        });
+    }
+};
+
+export default dbmemory;

package/src/modules/docutils.ts

@@ -0,0 +1,18 @@
+/**
+ * A module for document utility functions.
+ */
+const cbdocutils = {
+    /**
+     * Converts a PDF document to text.
+     * @param pdf_path - The file path to the PDF document to be converted.
+     * @returns {Promise<string>} A promise that resolves with the converted text.
+     */
+    pdf_to_text: (pdf_path: any): Promise<string> => {
+        // Implementation would go here
+        return new Promise((resolve, reject) => {
+            // PDF to text conversion logic
+        });
+    }
+};
+
+export default cbdocutils;

package/src/modules/fs.ts

@@ -0,0 +1,164 @@
+import cbws from './websocket';
+
+/**
+ * @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<any>} A promise that resolves with the server response.
+     */
+    createFile: (fileName: string, source: string, filePath: string): Promise<any> => {
+        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<any>} A promise that resolves with the server response.
+     */
+    createFolder: (folderName: string, folderPath: string): Promise<any> => {
+        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<any>} A promise that resolves with the server response.
+     */
+    readFile: (filename: string, filePath: string): Promise<any> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type":"fsEvent",
+                "action": "readFile",
+                "message": {
+                    filename,
+                    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<any>} A promise that resolves with the server response.
+     */
+    updateFile: (filename: string, filePath: string, newContent: string): Promise<any> => {
+        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<any>} A promise that resolves with the server response.
+     */
+    deleteFile: (filename: string, filePath: string): Promise<any> => {
+        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<any>} A promise that resolves with the server response.
+     */
+    deleteFolder: (foldername: string, folderpath: string): Promise<any> => {
+        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);
+                }
+            });
+        });
+    }
+};
+
+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/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';
+
+/**
+ * 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<any>} A promise that resolves with the LLM's response.
+     */
+    inference: async (message: string, llmrole: string): Promise<any> => {
+        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/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,34 @@
+import cbws from './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: any) => {
+        // Implementation for getting project settings will be added here
+    },
+    /**
+     * Retrieves the path of the current project.
+     * @returns {Promise<any>} A promise that resolves with the project path response.
+     */
+    getProjectPath: (): Promise<any> => {
+        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);
+                }
+            });
+        });
+    }
+};
+export default cbproject