@codebolt/codeboltjs 1.1.12 → 1.1.14

package/index.js

@@ -20,6 +20,8 @@ const outputparsers_1 = __importDefault(require("./modules/outputparsers"));
 const project_1 = __importDefault(require("./modules/project"));
 const git_1 = __importDefault(require("./modules/git"));
 const dbmemory_1 = __importDefault(require("./modules/dbmemory"));
+const state_1 = __importDefault(require("./modules/state"));
+const task_1 = __importDefault(require("./modules/task"));
 const ws_1 = __importDefault(require("ws"));
 /**
  * @class Codebolt
@@ -48,6 +50,8 @@ class Codebolt {
         this.outputparsers = outputparsers_1.default;
         this.project = project_1.default;
         this.dbmemory = dbmemory_1.default;
+        this.cbstate = state_1.default;
+        this.taskplaner = task_1.default;
         this.websocket = websocket_1.default.getWebsocket;
     }
     /**

package/modules/state.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Retrieves the application state asynchronously.
+ * @returns {Promise<any>} A promise that resolves with the application state.
+ */
+declare const cbstate: {
+    getApplicationState: () => Promise<any>;
+};
+export default cbstate;

package/modules/state.js

@@ -0,0 +1,26 @@
+"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("./websocket"));
+/**
+ * Retrieves the application state asynchronously.
+ * @returns {Promise<any>} A promise that resolves with the application state.
+ */
+const cbstate = {
+    getApplicationState: async () => {
+        return new Promise((resolve, reject) => {
+            websocket_1.default.getWebsocket.send(JSON.stringify({
+                "type": "getAppState",
+            }));
+            websocket_1.default.getWebsocket.on('message', (data) => {
+                const response = JSON.parse(data);
+                if (response.type === "getAppStateResponse") {
+                    resolve(response); // Resolve the Promise with the response data
+                }
+            });
+        });
+    }
+};
+exports.default = cbstate;

package/modules/task.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Manages task operations via WebSocket communication.
+ */
+declare const taskplaner: {
+    /**
+     * Adds a task using a WebSocket message.
+     * @param {string} task - The task to be added.
+     * @returns {Promise<any>} A promise that resolves with the response from the add task event.
+     */
+    addTask: (task: string) => Promise<any>;
+    /**
+     * Retrieves all tasks using a WebSocket message.
+     * @returns {Promise<any>} A promise that resolves with the response from the get tasks event.
+     */
+    getTasks: () => Promise<any>;
+    /**
+     * Updates an existing task using a WebSocket message.
+     * @param {string} task - The updated task information.
+     * @returns {Promise<any>} A promise that resolves with the response from the update task event.
+     */
+    updateTask: (task: string) => Promise<any>;
+};
+export default taskplaner;

package/modules/task.js

@@ -0,0 +1,74 @@
+"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("./websocket"));
+/**
+ * Manages task operations via WebSocket communication.
+ */
+const taskplaner = {
+    /**
+     * Adds a task using a WebSocket message.
+     * @param {string} task - The task to be added.
+     * @returns {Promise<any>} A promise that resolves with the response from the add task event.
+     */
+    addTask: async (task) => {
+        return new Promise((resolve, reject) => {
+            websocket_1.default.getWebsocket.send(JSON.stringify({
+                "type": "taskEvent",
+                "action": "addTask",
+                message: {
+                    "task": task
+                }
+            }));
+            websocket_1.default.getWebsocket.on('message', (data) => {
+                const response = JSON.parse(data);
+                if (response.type === "addTaskResponse") {
+                    resolve(response); // Resolve the promise with the response data from adding the task
+                }
+            });
+        });
+    },
+    /**
+     * Retrieves all tasks using a WebSocket message.
+     * @returns {Promise<any>} A promise that resolves with the response from the get tasks event.
+     */
+    getTasks: async () => {
+        return new Promise((resolve, reject) => {
+            websocket_1.default.getWebsocket.send(JSON.stringify({
+                "type": "taskEvent",
+                "action": "getTasks"
+            }));
+            websocket_1.default.getWebsocket.on('message', (data) => {
+                const response = JSON.parse(data);
+                if (response.type === "getTasksResponse") {
+                    resolve(response); // Resolve the promise with the response data from retrieving tasks
+                }
+            });
+        });
+    },
+    /**
+     * Updates an existing task using a WebSocket message.
+     * @param {string} task - The updated task information.
+     * @returns {Promise<any>} A promise that resolves with the response from the update task event.
+     */
+    updateTask: async (task) => {
+        return new Promise((resolve, reject) => {
+            websocket_1.default.getWebsocket.send(JSON.stringify({
+                "type": "taskEvent",
+                "action": "updateTask",
+                message: {
+                    "task": task
+                }
+            }));
+            websocket_1.default.getWebsocket.on('message', (data) => {
+                const response = JSON.parse(data);
+                if (response.type === "updateTaskResponse") {
+                    resolve(response); // Resolve the promise with the response data from updating the task
+                }
+            });
+        });
+    }
+};
+exports.default = taskplaner;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codebolt/codeboltjs",
-  "version": "1.1.12",
+  "version": "1.1.14",
   "description": "",
   "keywords": [],
   "author": "",

package/src/index.ts

@@ -15,8 +15,11 @@ import cboutputparsers from './modules/outputparsers';
 import cbproject from './modules/project';
 import git from './modules/git';
 import dbmemory from './modules/dbmemory';
+import cbstate from './modules/state';
+import task from './modules/task';
 import WebSocket from 'ws';
 
+
 /**
  * @class Codebolt
  * @description This class provides a unified interface to interact with various modules.
@@ -69,7 +72,6 @@ class Codebolt {
     start_browser(objective:string, url:string, previous_command:string, browser_content:string) {
         cbbrowser.newPage();
     }
-
     websocket: WebSocket | null = null;
     fs = cbfs;
     git=git;
@@ -87,6 +89,8 @@ class Codebolt {
     outputparsers = cboutputparsers;
     project = cbproject;
     dbmemory = dbmemory;
+    cbstate=cbstate;
+    taskplaner=task
 }
 
 // export default new Codebolt();

package/src/modules/state.ts

@@ -0,0 +1,24 @@
+import cbws from './websocket';
+
+/**
+ * Retrieves the application state asynchronously.
+ * @returns {Promise<any>} A promise that resolves with the application state.
+ */
+const cbstate = {
+    getApplicationState: async (): Promise<any> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "getAppState",
+                
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "getAppStateResponse") {
+                    resolve(response); // Resolve the Promise with the response data
+                }
+            });
+        });
+    }
+};
+
+export default cbstate;

package/src/modules/task.ts

@@ -0,0 +1,72 @@
+import cbws from './websocket';
+
+/**
+ * Manages task operations via WebSocket communication.
+ */
+const taskplaner = {
+    /**
+     * Adds a task using a WebSocket message.
+     * @param {string} task - The task to be added.
+     * @returns {Promise<any>} A promise that resolves with the response from the add task event.
+     */
+    addTask: async (task: string): Promise<any> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "taskEvent",
+                "action":"addTask",
+                message:{
+                    "task": task
+                }
+               
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "addTaskResponse") {
+                    resolve(response); // Resolve the promise with the response data from adding the task
+                }
+            });
+        });
+    },
+    /**
+     * Retrieves all tasks using a WebSocket message.
+     * @returns {Promise<any>} A promise that resolves with the response from the get tasks event.
+     */
+    getTasks: async (): Promise<any> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type":"taskEvent",
+                "action": "getTasks"
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "getTasksResponse") {
+                    resolve(response); // Resolve the promise with the response data from retrieving tasks
+                }
+            });
+        });
+    },
+    /**
+     * Updates an existing task using a WebSocket message.
+     * @param {string} task - The updated task information.
+     * @returns {Promise<any>} A promise that resolves with the response from the update task event.
+     */
+    updateTask: async ( task: string): Promise<any> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "taskEvent",
+                "action": "updateTask",
+                message: {
+                    "task": task
+                }
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "updateTaskResponse") {
+                    resolve(response); // Resolve the promise with the response data from updating the task
+                }
+            });
+        });
+    }
+};
+
+export default taskplaner;