@codebolt/codeboltjs 1.1.28 → 1.1.32

package/src/modules/fs.ts

@@ -1,5 +1,5 @@
 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.
@@ -11,9 +11,9 @@ const cbfs = {
      * @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.
+     * @returns {Promise<CreateFileResponse>} A promise that resolves with the server response.
      */
-    createFile: (fileName: string, source: string, filePath: string): Promise<any> => {
+    createFile: (fileName: string, source: string, filePath: string): Promise<CreateFileResponse> => {
         return new Promise((resolve, reject) => {
             cbws.getWebsocket.send(JSON.stringify({
                 "type":"fsEvent",
@@ -37,9 +37,9 @@ const cbfs = {
      * @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.
+     * @returns {Promise<CreateFolderResponse>} A promise that resolves with the server response.
      */
-    createFolder: (folderName: string, folderPath: string): Promise<any> => {
+    createFolder: (folderName: string, folderPath: string): Promise<CreateFolderResponse> => {
         return new Promise((resolve, reject) => {
             cbws.getWebsocket.send(JSON.stringify({
                 "type":"fsEvent",
@@ -62,9 +62,9 @@ const cbfs = {
      * @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.
+     * @returns {Promise<ReadFileResponse>} A promise that resolves with the server response.
      */
-    readFile: (filename: string, filePath: string): Promise<any> => {
+    readFile: (filename: string, filePath: string): Promise<ReadFileResponse> => {
         return new Promise((resolve, reject) => {
             cbws.getWebsocket.send(JSON.stringify({
                 "type":"fsEvent",
@@ -88,9 +88,9 @@ const cbfs = {
      * @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.
+     * @returns {Promise<UpdateFileResponse>} A promise that resolves with the server response.
      */
-    updateFile: (filename: string, filePath: string, newContent: string): Promise<any> => {
+    updateFile: (filename: string, filePath: string, newContent: string): Promise<UpdateFileResponse> => {
         return new Promise((resolve, reject) => {
             cbws.getWebsocket.send(JSON.stringify({
                 "type":"fsEvent",
@@ -114,9 +114,9 @@ const cbfs = {
      * @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.
+     * @returns {Promise<DeleteFileResponse>} A promise that resolves with the server response.
      */
-    deleteFile: (filename: string, filePath: string): Promise<any> => {
+    deleteFile: (filename: string, filePath: string): Promise<DeleteFileResponse> => {
         return new Promise((resolve, reject) => {
             cbws.getWebsocket.send(JSON.stringify({
                 "type":"fsEvent",
@@ -139,9 +139,9 @@ const cbfs = {
      * @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.
+     * @returns {Promise<DeleteFolderResponse>} A promise that resolves with the server response.
      */
-    deleteFolder: (foldername: string, folderpath: string): Promise<any> => {
+    deleteFolder: (foldername: string, folderpath: string): Promise<DeleteFolderResponse> => {
         return new Promise((resolve, reject) => {
             cbws.getWebsocket.send(JSON.stringify({
                 "type":"fsEvent",
@@ -159,8 +159,25 @@ const cbfs = {
             });
         });
     },
-    listFile:(folderPath?:string)=>{
-
+    /**
+     * @function listFile
+     * @description Lists all files.
+     * @returns {Promise<FileListResponse>} A promise that resolves with the list of files.
+     */
+    listFile: (filePath:string) => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "fsEvent",
+                "action": "fileList",
+                
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "fileListResponse") {
+                    resolve(response);
+                }
+            });
+        });
     },
   
 };

package/src/modules/llm.ts

@@ -1,5 +1,5 @@
 import cbws from './websocket';
-
+import {LLMResponse } from '@codebolt/types';
 /**
  * A module for interacting with language learning models (LLMs) via WebSocket.
  */
@@ -12,9 +12,9 @@ const cbllm = {
      * 
      * @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.
+     * @returns {Promise<LLMResponse>} A promise that resolves with the LLM's response.
      */
-    inference: async (message: string, llmrole: string): Promise<any> => {
+    inference: async (message: string, llmrole: string): Promise<LLMResponse> => {
         return new Promise((resolve, reject) => {
             cbws.getWebsocket.send(JSON.stringify({
                 "type": "inference",

package/src/modules/project.ts

@@ -1,5 +1,5 @@
 import cbws from './websocket';
-
+import {GetProjectPathResponse } from '@codebolt/types';
 /**
  * A module for interacting with project settings and paths.
  */
@@ -14,9 +14,9 @@ const cbproject = {
     },
     /**
      * Retrieves the path of the current project.
-     * @returns {Promise<any>} A promise that resolves with the project path response.
+     * @returns {Promise<GetProjectPathResponse>} A promise that resolves with the project path response.
      */
-    getProjectPath: (): Promise<any> => {
+    getProjectPath: (): Promise<GetProjectPathResponse> => {
         return new Promise((resolve, reject) => {
             cbws.getWebsocket.send(JSON.stringify({
                 "type": "settingEvent",

package/src/modules/state.ts

@@ -1,11 +1,12 @@
 import cbws from './websocket';
+import {ApplicationState,AddToAgentStateResponse,GetAgentStateResponse } from '@codebolt/types';
 
-/**
- * Retrieves the application state asynchronously.
- * @returns {Promise<any>} A promise that resolves with the application state.
- */
 const cbstate = {
-    getApplicationState: async (): Promise<any> => {
+    /**
+     * Retrieves the current application state from the server via WebSocket.
+     * @returns {Promise<ApplicationState>} A promise that resolves with the application state.
+     */
+    getApplicationState: async (): Promise<ApplicationState> => {
         return new Promise((resolve, reject) => {
             cbws.getWebsocket.send(JSON.stringify({
                 "type": "getAppState",
@@ -18,6 +19,50 @@ const cbstate = {
                 }
             });
         });
+    },
+    /**
+     * 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: string, value: string): Promise<AddToAgentStateResponse> => {
+      return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "agentStateEvent",
+                "action":"addToAgentState",
+                payload:{
+                    key,
+                    value
+                }
+                
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "addToAgentStateResponse") {
+                    resolve(response); // Resolve the Promise with the response data
+                }
+            });
+        });  
+    },
+    /**
+     * 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 (): Promise<GetAgentStateResponse> => {
+       return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "agentStateEvent",
+                "action":"getAgentState",
+                
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "getAgentStateResponse") {
+                    resolve(response); // Resolve the Promise with the response data
+                }
+            });
+        });  
     }
 };
 

package/src/modules/task.ts

@@ -1,5 +1,5 @@
 import cbws from './websocket';
-
+// import {AddTaskResponse,GetTasksResponse,UpdateTasksResponse } from '@codebolt/types';
 /**
  * Manages task operations via WebSocket communication.
  */
@@ -7,7 +7,7 @@ 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.
+     * @returns {Promise<AddTaskResponse>} A promise that resolves with the response from the add task event.
      */
     addTask: async (task: string): Promise<any> => {
         return new Promise((resolve, reject) => {
@@ -29,7 +29,7 @@ const taskplaner = {
     },
     /**
      * Retrieves all tasks using a WebSocket message.
-     * @returns {Promise<any>} A promise that resolves with the response from the get tasks event.
+     * @returns {Promise<GetTasksResponse>} A promise that resolves with the response from the get tasks event.
      */
     getTasks: async (): Promise<any> => {
         return new Promise((resolve, reject) => {
@@ -49,7 +49,7 @@ const taskplaner = {
     /**
      * 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.
+     * @returns {Promise<UpdateTasksResponse>} A promise that resolves with the response from the update task event.
      */
     updateTask: async ( task: string): Promise<any> => {
         return new Promise((resolve, reject) => {

package/src/modules/terminal.ts

@@ -1,10 +1,10 @@
 import cbws from './websocket';
 import { EventEmitter } from 'events';
-
+import {CommandError,CommandFinish,CommandOutput,TerminalInterruptResponse,TerminalInterrupted } from '@codebolt/types';
 /**
  * CustomEventEmitter class that extends the Node.js EventEmitter class.
  */
-export class CustomEventEmitter extends EventEmitter {}
+class CustomEventEmitter extends EventEmitter {}
 /**
  * A module for executing commands in a terminal-like environment via WebSocket.
  */
@@ -17,9 +17,9 @@ const cbterminal = {
      * of the executed command and resolves the promise accordingly.
      *
      * @param {string} command - The command to be executed.
-     * @returns {Promise<any>} A promise that resolves with the command's output, error, or finish signal.
+     * @returns {Promise<CommandOutput|CommandError>} A promise that resolves with the command's output, error, or finish signal.
      */
-    executeCommand: async (command: string): Promise<any> => {
+    executeCommand: async (command: string): Promise<CommandOutput|CommandError> => {
         return new Promise((resolve, reject) => {
             cbws.getWebsocket.send(JSON.stringify({
                 "type": "executeCommand",
@@ -39,9 +39,9 @@ const cbterminal = {
      * Listens for messages from the WebSocket and resolves the promise when an error is encountered.
      *
      * @param {string} command - The command to be executed.
-     * @returns {Promise<any>} A promise that resolves when an error occurs during command execution.
+     * @returns {Promise<CommandError>} A promise that resolves when an error occurs during command execution.
      */
-    executeCommandRunUntilError: async (command: string): Promise<any> => {
+    executeCommandRunUntilError: async (command: string): Promise<CommandError> => {
         return new Promise((resolve, reject) => {
             cbws.getWebsocket.send(JSON.stringify({
                 "type": "executeCommandRunUntilError",
@@ -60,9 +60,9 @@ const cbterminal = {
     /**
      * Sends a manual interrupt signal to the terminal.
      *
-     * @returns {void}
+     * @returns {Promise<TerminalInterruptResponse>} 
      */
-    sendManualInterrupt(): Promise<any>  {
+    sendManualInterrupt(): Promise<TerminalInterruptResponse>  {
        
         return new Promise((resolve, reject) => {
            cbws.getWebsocket.send(JSON.stringify({
@@ -82,9 +82,9 @@ const cbterminal = {
      * Listens for messages from the WebSocket and streams the output data.
      *
      * @param {string} command - The command to be executed.
-     * @returns {Promise<any>} A promise that streams the output data during command execution.
+     * @returns {EventEmitter} A promise that streams the output data during command execution.
      */
-    executeCommandWithStream(command: string) {
+    executeCommandWithStream(command: string):EventEmitter {
          // Send the process started message
          cbws.getWebsocket.send(JSON.stringify({
             "type": "executeCommandWithStream",

package/src/modules/tokenizer.ts

@@ -1,3 +1,4 @@
+import { AddTokenResponse, GetTokenResponse } from '@codebolt/types';
 import cbws from './websocket';
 
 /**
@@ -6,11 +7,11 @@ import cbws from './websocket';
 const tokenizer = {
   
     /**
-     * Adds a token asynchronously.
-     * @param {string} key - The key of the token to add.
-     * @returns {Promise<any>} A promise that resolves with the response.
+     * Adds a token to the system via WebSocket.
+     * @param {string} key - The key associated with the token to be added.
+     * @returns {Promise<AddTokenResponse>} A promise that resolves with the response from the add token event.
      */
-    addToken: async (key: string): Promise<any> => {
+    addToken: async (key: string): Promise<AddTokenResponse> => {
         return new Promise((resolve, reject) => {
             cbws.getWebsocket.send(JSON.stringify({
                 "type":"tokenizerEvent",
@@ -26,6 +27,29 @@ const tokenizer = {
                 }
             });
         });
+    },
+
+    /**
+     * Retrieves a token from the system via WebSocket.
+     * @param {string} key - The key associated with the token to be retrieved.
+     * @returns {Promise<GetTokenResponse>} A promise that resolves with the response from the get token event.
+     */
+    getToken: async (key: string): Promise<GetTokenResponse> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type":"tokenizerEvent",
+                "action": "getToken",
+                "message": {
+                    item: key
+                },
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "getTokenResponse") {
+                    resolve(response);
+                }
+            });
+        });
     }
 }
 

package/src/modules/vectordb.ts

@@ -1,13 +1,13 @@
 import cbws from './websocket';
-
+import { AddVectorItemResponse,GetVectorResponse,QueryVectorItemResponse } from '@codebolt/types';
 const VectorDB = {
     /**
      * Retrieves a vector from the vector database based on the provided key.
      *
      * @param {string} key - The key of the vector to retrieve.
-     * @returns {Promise<any>} A promise that resolves with the retrieved vector.
+     * @returns {Promise<GetVectorResponse>} A promise that resolves with the retrieved vector.
      */
-    getVector: async (key: string): Promise<any> => {
+    getVector: async (key: string): Promise<GetVectorResponse> => {
         return new Promise((resolve, reject) => {
             cbws.getWebsocket.send(JSON.stringify({
                 "type":"vectordbEvent",
@@ -30,9 +30,9 @@ const VectorDB = {
      *
 
      * @param {any} item - The item to add to the vector.
-     * @returns {Promise<any>} A promise that resolves when the item is successfully added.
+     * @returns {Promise<AddVectorItemResponse>} A promise that resolves when the item is successfully added.
      */
-    addVectorItem: async ( item: any): Promise<any> => {
+    addVectorItem: async ( item: any): Promise<AddVectorItemResponse> => {
         return new Promise((resolve, reject) => {
             cbws.getWebsocket.send(JSON.stringify({
                 "type":"vectordbEvent",
@@ -54,9 +54,9 @@ const VectorDB = {
      * Queries a vector item from the vector database based on the provided key.
      *
      * @param {string} key - The key of the vector to query the item from.
-     * @returns {Promise<any>} A promise that resolves with the queried vector item.
+     * @returns {Promise<QueryVectorItemResponse>} A promise that resolves with the queried vector item.
      */
-    queryVectorItem: async (key: string): Promise<any> => {
+    queryVectorItem: async (key: string): Promise<QueryVectorItemResponse> => {
         return new Promise((resolve, reject) => {
             cbws.getWebsocket.send(JSON.stringify({
                 "type":"vectordbEvent",