changes

Author: rawatSingh2022

package.json

@@ -18,7 +18,7 @@
   "license": "MIT",
   "homepage": "https://codeboltai.github.io",
   "dependencies": {
-    "@codebolt/types": "^1.0.8",
+    "@codebolt/types": "^1.0.9",
     "typedoc-plugin-missing-exports": "^2.2.0",
     "ws": "^8.17.0"
   },

src/modules/debug.ts

@@ -1,5 +1,5 @@
 import cbws from './websocket';
-
+import {DebugAddLogResponse,OpenDebugBrowserResponse } from '@codebolt/types';
 export enum logType{
     info="info",
     error="error",
@@ -8,7 +8,13 @@ export enum logType{
 
 
 export const debug={
-    debug(log:string,type:logType) {
+    /**
+     * 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:string,type:logType):Promise<DebugAddLogResponse>=> {
         return new Promise((resolve, reject) => {
             cbws.getWebsocket.send(JSON.stringify({
                 "type": "debugEvent",
@@ -28,7 +34,13 @@ export const debug={
 
 
     },
-    openDebugBrowser(url:string,port:number){
+    /**
+     * 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:string,port:number):Promise<OpenDebugBrowserResponse>=>{
         return new Promise((resolve, reject) => {
             cbws.getWebsocket.send(JSON.stringify({
                 "type": "debugEvent",

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",

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",

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",
@@ -19,7 +20,13 @@ const cbstate = {
             });
         });
     },
-    addToAgentState: async (key: string, value: string): Promise<void> => {
+    /**
+     * 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",
@@ -38,7 +45,11 @@ const cbstate = {
             });
         });  
     },
-    getAgentState: async (): Promise<any> => {
+    /**
+     * 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",

src/modules/task.ts

@@ -1,15 +1,15 @@
 import cbws from './websocket';
-
+import {AddTaskResponse,GetTasksResponse,UpdateTasksResponse } from '@codebolt/types';
 /**
  * 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.
+     * @returns {Promise<AddTaskResponse>} A promise that resolves with the response from the add task event.
      */
-    addTask: async (task: string): Promise<any> => {
+    addTask: async (task: string): Promise<AddTaskResponse> => {
         return new Promise((resolve, reject) => {
             cbws.getWebsocket.send(JSON.stringify({
                 "type": "taskEvent",
@@ -29,9 +29,9 @@ 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> => {
+    getTasks: async (): Promise<GetTasksResponse> => {
         return new Promise((resolve, reject) => {
             cbws.getWebsocket.send(JSON.stringify({
                 "type":"taskEvent",
@@ -49,9 +49,9 @@ 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> => {
+    updateTask: async ( task: string): Promise<UpdateTasksResponse> => {
         return new Promise((resolve, reject) => {
             cbws.getWebsocket.send(JSON.stringify({
                 "type": "taskEvent",

src/modules/terminal.ts

@@ -1,6 +1,6 @@
 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.
  */
@@ -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",

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",
@@ -28,7 +29,12 @@ const tokenizer = {
         });
     },
 
-    getToken: async (key: string): Promise<any> => {
+    /**
+     * 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",

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",