@codebolt/codeboltjs 1.1.30 → 1.1.32

package/modules/tokenizer.d.ts

@@ -1,12 +1,19 @@
+import { AddTokenResponse, GetTokenResponse } from '@codebolt/types';
 /**
  * Tokenizer module for handling token-related operations.
  */
 declare 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: (key: string) => Promise<any>;
+    addToken: (key: string) => Promise<AddTokenResponse>;
+    /**
+     * 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: (key: string) => Promise<GetTokenResponse>;
 };
 export default tokenizer;

package/modules/tokenizer.js

@@ -9,9 +9,9 @@ const websocket_1 = __importDefault(require("./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) => {
         return new Promise((resolve, reject) => {
@@ -29,6 +29,28 @@ 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) => {
+        return new Promise((resolve, reject) => {
+            websocket_1.default.getWebsocket.send(JSON.stringify({
+                "type": "tokenizerEvent",
+                "action": "getToken",
+                "message": {
+                    item: key
+                },
+            }));
+            websocket_1.default.getWebsocket.on('message', (data) => {
+                const response = JSON.parse(data);
+                if (response.type === "getTokenResponse") {
+                    resolve(response);
+                }
+            });
+        });
     }
 };
 exports.default = tokenizer;

package/modules/vectordb.d.ts

@@ -1,25 +1,26 @@
+import { AddVectorItemResponse, GetVectorResponse, QueryVectorItemResponse } from '@codebolt/types';
 declare 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: (key: string) => Promise<any>;
+    getVector: (key: string) => Promise<GetVectorResponse>;
     /**
      * Adds a new vector item to the vector database.
      *
 
      * @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: (item: any) => Promise<any>;
+    addVectorItem: (item: any) => Promise<AddVectorItemResponse>;
     /**
      * 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: (key: string) => Promise<any>;
+    queryVectorItem: (key: string) => Promise<QueryVectorItemResponse>;
 };
 export default VectorDB;

package/modules/vectordb.js

@@ -9,7 +9,7 @@ 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) => {
         return new Promise((resolve, reject) => {
@@ -33,7 +33,7 @@ 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) => {
         return new Promise((resolve, reject) => {
@@ -56,7 +56,7 @@ 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) => {
         return new Promise((resolve, reject) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codebolt/codeboltjs",
-  "version": "1.1.30",
+  "version": "1.1.32",
   "description": "",
   "keywords": [],
   "author": "",
@@ -18,15 +18,18 @@
   "license": "MIT",
   "homepage": "https://codeboltai.github.io",
   "dependencies": {
+    "@codebolt/types": "^1.0.9",
     "typedoc-plugin-missing-exports": "^2.2.0",
     "ws": "^8.17.0"
   },
   "devDependencies": {
+    "@types/events": "^3.0.3",
     "@types/ws": "^8.5.10",
     "jest": "^29.7.0",
     "jest-serial-runner": "^1.2.1",
     "ts-loader": "^9.5.1",
     "typedoc": "^0.25.13",
+    "typedoc-plugin-markdown": "^4.0.1",
     "typescript": "^5.4.5",
     "webpack": "^5.91.0",
     "webpack-cli": "^5.1.4"

package/script/gen.js

@@ -0,0 +1,27 @@
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+// Define the directory containing your TypeScript files
+const dir = './src';
+
+// Define the output directory for the documentation
+const outDir = './document';
+
+// Use a recursive function to find all TypeScript files in the directory and its subdirectories
+function getFiles(dir) {
+    return fs.readdirSync(dir).reduce((files, file) => {
+        const filePath = path.join(dir, file);
+        const isDirectory = fs.statSync(filePath).isDirectory();
+        return isDirectory ? [...files, ...getFiles(filePath)] : [...files, filePath];
+    }, []);
+}
+
+// Get all TypeScript files
+const tsFiles = getFiles(dir).filter(file => file.endsWith('.ts'));
+
+// Generate documentation for each TypeScript file
+tsFiles.forEach(file => {
+    const outPath = path.join(outDir, path.basename(file, '.ts'));
+    execSync(`npx typedoc --plugin typedoc-plugin-markdown --out ${outPath} ${file}`);
+});

package/src/index.ts

@@ -22,9 +22,7 @@ import debug from './modules/debug'
 import tokenizer from './modules/tokenizer'
 import WebSocket from 'ws';
 import { EventEmitter } from 'events';
-export class CustomEventEmitter extends EventEmitter {}
 
-let eventEmitter= new CustomEventEmitter();
 
 /**
  * @class Codebolt
@@ -40,20 +38,7 @@ class Codebolt  { // Extend EventEmitter
 
         this.websocket = cbws.getWebsocket;
     }
-    /**
-         * @method setupMessageListener
-         * @description Sets up a listener for incoming WebSocket messages.
-         */
-    userMessageListener() {
-        if (!this.websocket) return;
-        this.websocket.on('message', (data: string) => {
-            const response = JSON.parse(data);
-            if (response.type === "messageResponse") {
-                eventEmitter.emit("userMessage", response.response);
-            } 
-        });
-        return eventEmitter;
-    }
+    
     /**
      * @method waitForConnection
      * @description Waits for the WebSocket connection to open.
@@ -82,17 +67,6 @@ class Codebolt  { // Extend EventEmitter
         });
     }
 
-    /**
-     * @method start_browser
-     * @description Starts a new browser page.
-     * @param {string} objective - The objective of the browser session.
-     * @param {string} url - The URL to navigate to.
-     * @param {string} previous_command - The previous command executed.
-     * @param {string} browser_content - The content of the browser.
-     */
-    start_browser(objective: string, url: string, previous_command: string, browser_content: string) {
-        cbbrowser.newPage();
-    }
     websocket: WebSocket | null = null;
     fs = cbfs;
     git = git;

package/src/modules/browser.ts

@@ -1,5 +1,5 @@
 import cbws from './websocket';
-
+import {GoToPageResponse,UrlResponse,GetMarkdownResponse,HtmlReceived} from  '@codebolt/types'
 /**
  * A module for interacting with a browser through WebSockets.
  */
@@ -17,9 +17,9 @@ const cbbrowser = {
 
     /**
      * Retrieves the current URL of the browser's active page.
-     * @returns {Promise<any>} A promise that resolves with the URL.
+     * @returns {Promise<UrlResponse>} A promise that resolves with the URL.
      */
-    getUrl: () => {
+    getUrl: ():Promise<UrlResponse> => {
         return new Promise((resolve, reject) => {
             cbws.getWebsocket.send(JSON.stringify({
                 "type": "browserEvent",
@@ -37,9 +37,9 @@ const cbbrowser = {
     /**
      * Navigates to a specified URL.
      * @param {string} url - The URL to navigate to.
-     * @returns {Promise<any>} A promise that resolves when navigation is complete.
+     * @returns {Promise<GoToPageResponse>} A promise that resolves when navigation is complete.
      */
-    goToPage: (url: string) => {
+    goToPage: (url: string):Promise<GoToPageResponse> => {
         return new Promise((resolve, reject) => {
             cbws.getWebsocket.send(JSON.stringify({
                 "type": "browserEvent",
@@ -67,9 +67,9 @@ const cbbrowser = {
 
     /**
      * Retrieves the HTML content of the current page.
-     * @returns {Promise<string>} A promise that resolves with the HTML content.
+     * @returns {Promise<HtmlReceived>} A promise that resolves with the HTML content.
      */
-    getHTML: () => {
+    getHTML: ():Promise<HtmlReceived> => {
         return new Promise((resolve, reject) => {
             cbws.getWebsocket.send(JSON.stringify({
                 "type": "browserEvent",
@@ -86,9 +86,9 @@ const cbbrowser = {
 
     /**
      * Retrieves the Markdown content of the current page.
-     * @returns {Promise<any>} A promise that resolves with the Markdown content.
+     * @returns {Promise<GetMarkdownResponse>} A promise that resolves with the Markdown content.
      */
-    getMarkdown: () => {
+    getMarkdown: ():Promise<GetMarkdownResponse> => {
         return new Promise((resolve, reject) => {
             cbws.getWebsocket.send(JSON.stringify({
                 "type": "browserEvent",
@@ -264,3 +264,12 @@ const cbbrowser = {
 }
 
 export default cbbrowser;
+
+
+
+/***
+
+start_browser(objective: string, url: string, previous_command: string, browser_content: string) {
+    cbbrowser.newPage();
+}
+ */

package/src/modules/chat.ts

@@ -1,19 +1,25 @@
 // chat.ts
 import cbws from './websocket';
 import { EventEmitter } from 'events';
+import {ChatMessage} from  '@codebolt/types'
+
+
 
 /**
  * CustomEventEmitter class that extends the Node.js EventEmitter class.
  */
-export class CustomEventEmitter extends EventEmitter {}
-
+class CustomEventEmitter extends EventEmitter {}
+let  eventEmitter= new CustomEventEmitter()
 /**
  * Chat module to interact with the WebSocket server.
  */
 const cbchat = {
-    eventEmitter: new CustomEventEmitter(),
 
-    getChatHistory() {
+    /**
+     * Retrieves the chat history from the server.
+     * @returns {Promise<ChatMessage[]>} A promise that resolves with an array of ChatMessage objects representing the chat history.
+     */
+    getChatHistory: (): Promise<ChatMessage[]> => {
         return new Promise((resolve, reject) => {
             cbws.getWebsocket.send(JSON.stringify({
                 "type": "getChatHistory"
@@ -25,15 +31,28 @@ const cbchat = {
                 }
             })
         })
-      
+    },
 
+    /**
+     * Sets up a listener for incoming WebSocket messages and emits a custom event when a message is received.
+     * @returns {EventEmitter} The event emitter used for emitting custom events.
+     */
+    userMessageListener: () => {
+        if (!cbws.getWebsocket) return;
+        cbws.getWebsocket.on('message', (data: string) => {
+            const response = JSON.parse(data);
+            if (response.type === "messageResponse") {
+                eventEmitter.emit("userMessage", response.response);
+            } 
+        });
+        return eventEmitter;
     },
 
     /**
      * Sends a message through the WebSocket connection.
      * @param {string} message - The message to be sent.
      */
-    sendMessage(message: string) {
+    sendMessage: (message: string) => {
         console.log(message);
         cbws.getWebsocket.send(JSON.stringify({
             "type": "sendMessage",
@@ -44,9 +63,9 @@ const cbchat = {
     /**
      * Waits for a reply to a sent message.
      * @param {string} message - The message for which a reply is expected.
-     * @returns {Promise<any>} A promise that resolves with the reply.
+     * @returns {Promise<string>} A promise that resolves with the reply.
      */
-    waitforReply(message: string): Promise<any> {
+    waitforReply: (message: string): Promise<string> => {
         return new Promise((resolve, reject) => {
             cbws.getWebsocket.send(JSON.stringify({
                 "type": "waitforReply",
@@ -65,7 +84,7 @@ const cbchat = {
      * Notifies the server that a process has started and sets up an event listener for stopProcessClicked events.
      * @returns An object containing the event emitter and a stopProcess method.
      */
-    processStarted() {
+    processStarted: () => {
         // Send the process started message
         cbws.getWebsocket.send(JSON.stringify({
             "type": "processStarted"
@@ -77,12 +96,12 @@ const cbchat = {
             if(message.type==='stopProcessClicked')
 
             // Emit a custom event based on the message type
-            this.eventEmitter.emit("stopProcessClicked", message);
+            eventEmitter.emit("stopProcessClicked", message);
         });
 
         // Return an object that includes the event emitter and the stopProcess method
         return {
-            event: this.eventEmitter,
+            event: eventEmitter,
             stopProcess: () => {
                 // Implement the logic to stop the process here
                 console.log("Stopping process...");
@@ -93,6 +112,10 @@ const cbchat = {
             }
         };
     },
+    /**
+     * Stops the ongoing process.
+     * Sends a specific message to the server to stop the process.
+     */
     stopProcess: () => {
         // Implement the logic to stop the process here
         console.log("Stopping process...");

package/src/modules/codeutils.ts

@@ -1,26 +1,17 @@
 import cbws from './websocket';
+import { GetJsTreeResponse, MatchProblemResponse, GetMatcherListTreeResponse, getMatchDetail } from '@codebolt/types';
 
 /**
  * A utility module for working with code.
  */
 const cbcodeutils = {
-  
     
-    getCodeTree: (): Promise<any> => {
-        return new Promise((resolve, reject) => {
-            cbws.getWebsocket.send(JSON.stringify({
-                "type": "codeEvent",
-                "action":"getCodeTree"
-            }));
-            cbws.getWebsocket.on('message', (data: string) => {
-                const response = JSON.parse(data);
-                if (response.type === "getCodeTreeResponse") {
-                    resolve(response.markdown); // Resolve the Promise with the response data
-                } 
-            });
-        });
-    },
-    getJsTree: (filePath:string): Promise<any> => {
+    /**
+     * Retrieves a JavaScript tree structure for a given file path.
+     * @param {string} filePath - The path of the file to retrieve the JS tree for.
+     * @returns {Promise<GetJsTreeResponse>} A promise that resolves with the JS tree response.
+     */
+    getJsTree: (filePath: string): Promise<GetJsTreeResponse> => {
         return new Promise((resolve, reject) => {
             cbws.getWebsocket.send(JSON.stringify({
                 "type": "codeEvent",
@@ -32,12 +23,17 @@ const cbcodeutils = {
             cbws.getWebsocket.on('message', (data: string) => {
                 const response = JSON.parse(data);
                 if (response.type === "getJsTreeResponse") {
-                    resolve(resolve); // Resolve the Promise with the response data
+                    resolve(response); // Resolve the Promise with the response data
                 } 
             });
         });
     },
-    getAllFilesAsMarkDown:()=>{
+
+    /**
+     * Retrieves all files as Markdown.
+     * @returns {Promise<string>} A promise that resolves with the Markdown content of all files.
+     */
+    getAllFilesAsMarkDown: (): Promise<string> => {
         return new Promise((resolve, reject) => {
             cbws.getWebsocket.send(JSON.stringify({
                 "type": "codeEvent",
@@ -46,12 +42,20 @@ const cbcodeutils = {
             cbws.getWebsocket.on('message', (data: string) => {
                 const response = JSON.parse(data);
                 if (response.type === "getAllFilesMarkdownResponse") {
-                    resolve(response.markdown); // Resolve the Promise with the response data
+                    resolve(response); // Resolve the Promise with the response data
                 } 
             });
         });
     },
-    performMatch:(matcherDefinition:object, problemPatterns:[], problems:[])=>{
+
+    /**
+     * Performs a matching operation based on the provided matcher definition and problem patterns.
+     * @param {object} matcherDefinition - The definition of the matcher.
+     * @param {Array} problemPatterns - The patterns to match against.
+     * @param {Array} problems - The list of problems.
+     * @returns {Promise<MatchProblemResponse>} A promise that resolves with the matching problem response.
+     */
+    performMatch: (matcherDefinition: object, problemPatterns: any[], problems: any[]): Promise<MatchProblemResponse> => {
         return new Promise((resolve, reject) => {
             cbws.getWebsocket.send(JSON.stringify({
                 "type": "codeEvent",
@@ -64,27 +68,37 @@ const cbcodeutils = {
             cbws.getWebsocket.on('message', (data: string) => {
                 const response = JSON.parse(data);
                 if (response.type === "getgetJsTreeResponse") {
-                    resolve(resolve); // Resolve the Promise with the response data
+                    resolve(response); // Resolve the Promise with the response data
                 } 
             });
         }); 
     },
-    getMatcherList:()=>{
+
+    /**
+     * Retrieves the list of matchers.
+     * @returns {Promise<GetMatcherListTreeResponse>} A promise that resolves with the list of matchers response.
+     */
+    getMatcherList: (): Promise<GetMatcherListTreeResponse> => {
         return new Promise((resolve, reject) => {
             cbws.getWebsocket.send(JSON.stringify({
                 "type": "codeEvent",
                 "action":"getMatcherList",
-                
             }));
             cbws.getWebsocket.on('message', (data: string) => {
                 const response = JSON.parse(data);
                 if (response.type === "getMatcherListTreeResponse") {
-                    resolve(resolve); // Resolve the Promise with the response data
+                    resolve(response); // Resolve the Promise with the response data
                 } 
             });
         }); 
     },
-    matchDetail:(matcher:string)=>{
+
+    /**
+     * Retrieves details of a match.
+     * @param {string} matcher - The matcher to retrieve details for.
+     * @returns {Promise<getMatchDetail>} A promise that resolves with the match detail response.
+     */
+    matchDetail: (matcher: string): Promise<getMatchDetail> => {
         return new Promise((resolve, reject) => {
             cbws.getWebsocket.send(JSON.stringify({
                 "type": "codeEvent",
@@ -92,12 +106,11 @@ const cbcodeutils = {
                 payload:{
                     match:matcher
                 }
-                
             }));
             cbws.getWebsocket.on('message', (data: string) => {
                 const response = JSON.parse(data);
                 if (response.type === "matchDetailTreeResponse") {
-                    resolve(resolve); // Resolve the Promise with the response data
+                    resolve(response); // Resolve the Promise with the response data
                 } 
             });
         }); 

package/src/modules/dbmemory.ts

@@ -1,4 +1,5 @@
 import cbws from './websocket';
+import {MemorySetResponse,MemoryGetResponse  } from '@codebolt/types';
 
 /**
  * A module for handling in-memory database operations via WebSocket.
@@ -8,9 +9,9 @@ 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.
+     * @returns {Promise<MemorySetResponse>} A promise that resolves with the response from the memory set event.
      */
-    addKnowledge: (key: string, value: any): Promise<any> => {
+    addKnowledge: (key: string, value: any): Promise<MemorySetResponse> => {
         return new Promise((resolve, reject) => {
             cbws.getWebsocket.send(JSON.stringify({
                 "type": "memoryEvent",
@@ -29,9 +30,9 @@ const dbmemory = {
     /**
      * 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.
+     * @returns {Promise<MemoryGetResponse>} A promise that resolves with the response from the memory get event.
      */
-    getKnowledge: (key: string): Promise<any> => {
+    getKnowledge: (key: string): Promise<MemoryGetResponse> => {
         return new Promise((resolve, reject) => {
             cbws.getWebsocket.send(JSON.stringify({
                 "type": "memoryEvent",

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