@codebolt/codeboltjs 2.0.3 → 2.0.5

package/dist/modules/dbmemory.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const websocket_1 = __importDefault(require("../core/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<MemorySetResponse>} A promise that resolves with the response from the memory set event.
+     */
+    addKnowledge: (key, value) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "memoryEvent",
+            'action': 'set',
+            key,
+            value
+        }, "memorySetResponse");
+    },
+    /**
+     * Retrieves a value from the in-memory database by key.
+     * @param {string} key - The key of the value to retrieve.
+     * @returns {Promise<MemoryGetResponse>} A promise that resolves with the response from the memory get event.
+     */
+    getKnowledge: (key) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "memoryEvent",
+            'action': 'get',
+            key
+        }, "memoryGetResponse");
+    }
+};
+exports.default = dbmemory;

package/dist/modules/debug.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.debug = exports.logType = void 0;
+const websocket_1 = __importDefault(require("../core/websocket"));
+var logType;
+(function (logType) {
+    logType["info"] = "info";
+    logType["error"] = "error";
+    logType["warning"] = "warning";
+})(logType || (exports.logType = logType = {}));
+exports.debug = {
+    /**
+     * Sends a log message to the debug websocket and waits for a response.
+     * @param {string} log - The log message to send.
+     * @param {logType} type - The type of the log message (info, error, warning).
+     * @returns {Promise<DebugAddLogResponse>} A promise that resolves with the response from the debug event.
+     */
+    debug: (log, type) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "debugEvent",
+            "action": "addLog",
+            message: {
+                log,
+                type
+            }
+        }, "debugEventResponse");
+    },
+    /**
+     * Requests to open a debug browser at the specified URL and port.
+     * @param {string} url - The URL where the debug browser should be opened.
+     * @param {number} port - The port on which the debug browser will listen.
+     * @returns {Promise<OpenDebugBrowserResponse>} A promise that resolves with the response from the open debug browser event.
+     */
+    openDebugBrowser: (url, port) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "debugEvent",
+            "action": "openDebugBrowser",
+            message: {
+                url,
+                port
+            }
+        }, "openDebugBrowserResponse");
+    }
+};
+exports.default = exports.debug;

package/{modules → dist/modules}/fs.d.ts

@@ -89,6 +89,6 @@ declare const cbfs: {
      * @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) => Promise<unknown>;
+    writeToFile: (relPath: string, newContent: string) => Promise<any>;
 };
 export default cbfs;

package/dist/modules/fs.js

@@ -0,0 +1,184 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const websocket_1 = __importDefault(require("../core/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<CreateFileResponse>} A promise that resolves with the server response.
+     */
+    createFile: (fileName, source, filePath) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "fsEvent",
+            "action": "createFile",
+            "message": {
+                fileName,
+                source,
+                filePath
+            },
+        }, "createFileResponse");
+    },
+    /**
+     * @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, folderPath) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "fsEvent",
+            "action": "createFolder",
+            "message": {
+                folderName,
+                folderPath
+            },
+        }, "createFolderResponse");
+    },
+    /**
+     * @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) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "fsEvent",
+            "action": "readFile",
+            "message": {
+                filePath
+            },
+        }, "readFileResponse");
+    },
+    /**
+     * @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, filePath, newContent) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "fsEvent",
+            "action": "updateFile",
+            "message": {
+                filename,
+                filePath,
+                newContent
+            },
+        }, "commandOutput");
+    },
+    /**
+     * @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, filePath) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "fsEvent",
+            "action": "deleteFile",
+            "message": {
+                filename,
+                filePath
+            },
+        }, "deleteFileResponse");
+    },
+    /**
+     * @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, folderpath) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "fsEvent",
+            "action": "deleteFolder",
+            "message": {
+                foldername,
+                folderpath
+            },
+        }, "deleteFolderResponse");
+    },
+    /**
+     * @function listFile
+     * @description Lists all files.
+     * @returns {Promise<FileListResponse>} A promise that resolves with the list of files.
+     */
+    listFile: (folderPath, isRecursive = false) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "fsEvent",
+            "action": "fileList",
+            message: {
+                folderPath,
+                isRecursive
+            }
+        }, "fileListResponse");
+    },
+    /**
+     * @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) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "fsEvent",
+            "action": "listCodeDefinitionNames",
+            "message": {
+                path
+            }
+        }, "listCodeDefinitionNamesResponse");
+    },
+    /**
+     * @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, regex, filePattern) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "fsEvent",
+            "action": "searchFiles",
+            "message": {
+                path,
+                regex,
+                filePattern
+            }
+        }, "searchFilesResponse");
+    },
+    /**
+     * @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, newContent) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "fsEvent",
+            "action": "writeToFile",
+            "message": {
+                relPath,
+                newContent
+            }
+        }, "writeToFileResponse");
+    },
+};
+exports.default = cbfs;

package/dist/modules/git.js

@@ -0,0 +1,152 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const websocket_1 = __importDefault(require("../core/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) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "gitEvent",
+            "action": "Init",
+            "path": path
+        }, "InitResponse");
+    },
+    /**
+     * 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, path) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "gitEvent",
+            "action": "Clone",
+            "url": url,
+            "path": path
+        }, "CloneResponse");
+    },
+    /**
+     * 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) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "gitEvent",
+            "action": "Pull",
+            "path": path
+        }, "PullResponse");
+    },
+    /**
+     * 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) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "gitEvent",
+            "action": "Push",
+            "path": path
+        }, "PushResponse");
+    },
+    /**
+     * 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) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "gitEvent",
+            "action": "Status",
+            "path": path
+        }, "StatusResponse");
+    },
+    /**
+     * 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) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "gitEvent",
+            "action": "Add",
+            "path": path
+        }, "AddResponse");
+    },
+    /**
+     * 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) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "gitEvent",
+            "action": "Commit",
+            "message": message
+        }, "gitCommitResponse");
+    },
+    /**
+     * 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, branch) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "gitEvent",
+            "action": "Checkout",
+            "path": path,
+            "branch": branch
+        }, "CheckoutResponse");
+    },
+    /**
+     * 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, branch) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "gitEvent",
+            "action": "Branch",
+            "path": path,
+            "branch": branch
+        }, "BranchResponse");
+    },
+    /**
+     * 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) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "gitEvent",
+            "action": "Logs",
+            "path": path
+        }, "LogsResponse");
+    },
+    /**
+     * 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, path) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "gitEvent",
+            "action": "Diff",
+            "path": path,
+            "commitHash": commitHash
+        }, "DiffResponse");
+    }
+};
+exports.default = gitService;

package/{modules → dist/modules}/history.js

@@ -4,7 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.chatSummary = exports.logType = void 0;
-const websocket_1 = __importDefault(require("./websocket"));
+const websocket_1 = __importDefault(require("../core/websocket"));
 /**
  * Enum representing different types of log messages.
  */
@@ -28,18 +28,10 @@ exports.chatSummary = {
      * @returns Promise with an array of message objects containing role and content
      */
     summarizeAll: () => {
-        return new Promise((resolve, reject) => {
-            websocket_1.default.getWebsocket.send(JSON.stringify({
-                "type": "chatSummaryEvent",
-                "action": "summarizeAll",
-            }));
-            websocket_1.default.getWebsocket.on('message', (data) => {
-                const response = JSON.parse(data);
-                if (response.type === "getSummarizeAllResponse") {
-                    resolve(response.payload); // Resolve the Promise with the response data
-                }
-            });
-        });
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "chatSummaryEvent",
+            "action": "summarizeAll",
+        }, "getSummarizeAllResponse");
     },
     /**
      * Summarizes a specific part of the chat history.
@@ -49,20 +41,12 @@ exports.chatSummary = {
      * @returns Promise with an array of summarized message objects
      */
     summarize: (messages, depth) => {
-        return new Promise((resolve, reject) => {
-            websocket_1.default.getWebsocket.send(JSON.stringify({
-                "type": "chatSummaryEvent",
-                "action": "summarize",
-                messages,
-                depth
-            }));
-            websocket_1.default.getWebsocket.on('message', (data) => {
-                const response = JSON.parse(data);
-                if (response.type === "getSummarizeResponse") {
-                    resolve(response.payload); // Resolve the Promise with the response data
-                }
-            });
-        });
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "chatSummaryEvent",
+            "action": "summarize",
+            messages,
+            depth
+        }, "getSummarizeResponse");
     }
 };
 exports.default = exports.chatSummary;

package/{modules → dist/modules}/llm.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const websocket_1 = __importDefault(require("./websocket"));
+const websocket_1 = __importDefault(require("../core/websocket"));
 /**
  * A module for interacting with language learning models (LLMs) via WebSocket.
  */
@@ -19,21 +19,13 @@ const cbllm = {
      * @returns {Promise<LLMResponse>} A promise that resolves with the LLM's response.
      */
     inference: async (message, llmrole) => {
-        return new Promise((resolve, reject) => {
-            websocket_1.default.getWebsocket.send(JSON.stringify({
-                "type": "inference",
-                "message": {
-                    prompt: message,
-                    llmrole
-                },
-            }));
-            websocket_1.default.getWebsocket.on('message', (data) => {
-                const response = JSON.parse(data);
-                if (response.type === "llmResponse") {
-                    resolve(response); // Resolve the Promise with the response data
-                }
-            });
-        });
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "inference",
+            "message": {
+                prompt: message,
+                llmrole
+            },
+        }, "llmResponse");
     }
 };
 exports.default = cbllm;

package/{modules → dist/modules}/project.d.ts

@@ -16,6 +16,6 @@ declare const cbproject: {
     getProjectPath: () => Promise<GetProjectPathResponse>;
     getRepoMap: (message: any) => Promise<GetProjectPathResponse>;
     runProject: () => void;
-    getEditorFileStatus: () => Promise<unknown>;
+    getEditorFileStatus: () => Promise<any>;
 };
 export default cbproject;

package/dist/modules/project.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const websocket_1 = __importDefault(require("../core/websocket"));
+/**
+ * A module for interacting with project settings and paths.
+ */
+const cbproject = {
+    /**
+     * Placeholder for a method to get project settings.
+     * Currently, this method does not perform any operations.
+     * @param {any} output - The output where project settings would be stored.
+     */
+    getProjectSettings: (output) => {
+        // Implementation for getting project settings will be added here
+    },
+    /**
+     * Retrieves the path of the current project.
+     * @returns {Promise<GetProjectPathResponse>} A promise that resolves with the project path response.
+     */
+    getProjectPath: () => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "settingEvent",
+            "action": "getProjectPath"
+        }, "getProjectPathResponse");
+    },
+    getRepoMap: (message) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "settingEvent",
+            "action": "getRepoMap",
+            message
+        }, "getRepoMapResponse");
+    },
+    runProject: () => {
+        websocket_1.default.messageManager.send({
+            "type": "runProject"
+        });
+    },
+    getEditorFileStatus: () => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "settingEvent",
+            "action": "getEditorFileStatus",
+        }, "getEditorFileStatusResponse");
+    }
+};
+exports.default = cbproject;

package/dist/modules/state.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const websocket_1 = __importDefault(require("../core/websocket"));
+const cbstate = {
+    /**
+     * Retrieves the current application state from the server via WebSocket.
+     * @returns {Promise<ApplicationState>} A promise that resolves with the application state.
+     */
+    getApplicationState: async () => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "projectStateEvent",
+            "action": "getAppState",
+        }, "getAppStateResponse");
+    },
+    /**
+     * Adds a key-value pair to the agent's state on the server via WebSocket.
+     * @param {string} key - The key to add to the agent's state.
+     * @param {string} value - The value associated with the key.
+     * @returns {Promise<AddToAgentStateResponse>} A promise that resolves with the response to the addition request.
+     */
+    addToAgentState: async (key, value) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "agentStateEvent",
+            "action": "addToAgentState",
+            payload: {
+                key,
+                value
+            }
+        }, "addToAgentStateResponse");
+    },
+    /**
+     * Retrieves the current state of the agent from the server via WebSocket.
+     * @returns {Promise<GetAgentStateResponse>} A promise that resolves with the agent's state.
+     */
+    getAgentState: async () => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "agentStateEvent",
+            "action": "getAgentState",
+        }, "getAgentStateResponse");
+    },
+    /**
+     * Retrieves the current project state from the server via WebSocket.
+     * @returns {Promise<GetProjectStateResponse>} A promise that resolves with the project's state.
+     */
+    getProjectState: async () => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "projectStateEvent",
+            "action": "getProjectState",
+        }, "getProjectStateResponse");
+    },
+    /**
+     * Updates the project state on the server via WebSocket.
+     * @returns {Promise<UpdateProjectStateResponse>} A promise that resolves with the response to the update request.
+     */
+    updateProjectState: async (key, value) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "projectStateEvent",
+            "action": "updateProjectState",
+            payload: {
+                key,
+                value
+            }
+        }, "updateProjectStateResponse");
+    }
+};
+exports.default = cbstate;