@codebolt/codeboltjs 1.1.76 → 1.1.78

package/src/modules/browser.ts

@@ -0,0 +1,352 @@
+import cbws from './websocket';
+import {GoToPageResponse,UrlResponse,GetMarkdownResponse,HtmlReceived,ExtractTextResponse,GetContentResponse} from  '@codebolt/types'
+/**
+ * A module for interacting with a browser through WebSockets.
+ */
+const cbbrowser = {
+
+    /**
+     * Opens a new page in the browser.
+     */
+    newPage: () => {
+       
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "browserEvent",
+                action: 'newPage'
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.event === "newPageResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+
+    /**
+     * Retrieves the current URL of the browser's active page.
+     * @returns {Promise<UrlResponse>} A promise that resolves with the URL.
+     */
+    getUrl: ():Promise<UrlResponse> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "browserEvent",
+                action: 'getUrl'
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.event === "getUrlResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+
+    /**
+     * Navigates to a specified URL.
+     * @param {string} url - The URL to navigate to.
+     * @returns {Promise<GoToPageResponse>} A promise that resolves when navigation is complete.
+     */
+    goToPage: (url: string):Promise<GoToPageResponse> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "browserEvent",
+                action: 'goToPage',
+                url
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.event === "goToPageResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+
+    /**
+     * Takes a screenshot of the current page.
+     */
+    screenshot: () => {
+        return new Promise((resolve, reject) => {
+        cbws.getWebsocket.send(JSON.stringify({
+            "type": "browserEvent",
+            action: 'screenshot'
+        }));
+        cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.event === "screenshotResponse") {
+                    resolve(response.payload);
+                }
+            });
+        });
+    },
+
+    /**
+     * Retrieves the HTML content of the current page.
+     * @returns {Promise<HtmlReceived>} A promise that resolves with the HTML content.
+     */
+    getHTML: ():Promise<HtmlReceived> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "browserEvent",
+                action: 'getHTML'
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.event === "htmlReceived") {
+                    resolve(response.htmlResponse);
+                }
+            });
+        });
+    },
+
+    /**
+     * Retrieves the Markdown content of the current page.
+     * @returns {Promise<GetMarkdownResponse>} A promise that resolves with the Markdown content.
+     */
+    getMarkdown: ():Promise<GetMarkdownResponse> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "browserEvent",
+                action: 'getMarkdown'
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.event === "getMarkdownResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+
+    /**
+     * Retrieves the PDF content of the current page.
+     * 
+     */
+    getPDF: () => {
+        cbws.getWebsocket.send(JSON.stringify({
+            "type": "browserEvent",
+            action: 'getPDF'
+        }));
+    },
+
+    /**
+     * Converts the PDF content of the current page to text.
+     */
+    pdfToText: () => {
+        cbws.getWebsocket.send(JSON.stringify({
+            "type": "browserEvent",
+            action: 'pdfToText'
+        }));
+    },
+
+    /**
+     * Retrieves the content of the current page.
+     *  @returns {Promise<GetContentResponse>} A promise that resolves with the content.
+     */
+    getContent: ():Promise<GetContentResponse> => {
+        
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "browserEvent",
+                action: 'getContent'
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.event === "getContentResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+    /**
+     * Retrieves the snapshot of the current page.
+     *  @returns {Promise<GetContentResponse>} A promise that resolves with the content.
+     */
+    getSnapShot: ():Promise<any> => {
+        
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "browserEvent",
+                action: 'getSnapShot'
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.event === "getSnapShotResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+    /**
+     * Retrieves browser info like height width scrollx scrolly of the current page.
+     *  @returns {Promise<GetContentResponse>} A promise that resolves with the content.
+     */
+    getBrowserInfo: ():Promise<any> => {
+        
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "browserEvent",
+                action: 'getBrowserInfo'
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.event === "getBrowserInfoResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+
+    /**
+     * Extracts text from the current page.
+     *  @returns {Promise<ExtractTextResponse>} A promise that resolves with the extracted text.
+     * 
+     */
+    extractText: ():Promise<ExtractTextResponse> => {
+        
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "browserEvent",
+                action: 'extractText'
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.event === "extractTextResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+
+    /**
+     * Closes the current page.
+     */
+    close: () => {
+        cbws.getWebsocket.send(JSON.stringify({
+            "type": "browserEvent",
+            action: 'close'
+        }));
+    },
+
+    /**
+     * Scrolls the current page in a specified direction by a specified number of pixels.
+     * @param {string} direction - The direction to scroll.
+     * @param {string} pixels - The number of pixels to scroll.
+     * @returns {Promise<any>} A promise that resolves when the scroll action is complete.
+     */
+    scroll: (direction: string, pixels: string) => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "browserEvent",
+                action: 'scroll',
+                direction,
+                pixels
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.event === "scrollResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+
+    /**
+     * Types text into a specified element on the page.
+     * @param {string} elementid - The ID of the element to type into.
+     * @param {string} text - The text to type.
+     * @returns {Promise<any>} A promise that resolves when the typing action is complete.
+     */
+    type: (elementid: string, text: string) => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "browserEvent",
+                action: 'type',
+                text,
+                elementid
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.event === "typeResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+
+    /**
+     * Clicks on a specified element on the page.
+     * @param {string} elementid - The ID of the element to click.
+     * @returns {Promise<any>} A promise that resolves when the click action is complete.
+     */
+    click: (elementid: string) => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "browserEvent",
+                action: 'click',
+                elementid
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.event === "clickResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+
+    /**
+     * Simulates the Enter key press on the current page.
+     * @returns {Promise<any>} A promise that resolves when the Enter action is complete.
+     */
+    enter: () => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "browserEvent",
+                action: 'enter'
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.event === "EnterResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+
+    /**
+     * Performs a search on the current page using a specified query.
+     * @param {string} elementid - The ID of the element to perform the search in.
+     * @param {string} query - The search query.
+     * @returns {Promise<any>} A promise that resolves with the search results.
+     */
+    search: (elementid: string, query: string) => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "browserEvent",
+                action: 'search',
+                elementid,
+                query
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.event === "searchResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    }
+}
+
+export default cbbrowser;
+
+
+
+/***
+
+start_browser(objective: string, url: string, previous_command: string, browser_content: string) {
+    cbbrowser.newPage();
+}
+ */

package/src/modules/chat.ts

@@ -0,0 +1,193 @@
+// chat.ts
+import cbws from './websocket';
+import { EventEmitter } from 'events';
+import { ChatMessage, UserMessage } from '@codebolt/types'
+
+
+
+/**
+ * CustomEventEmitter class that extends the Node.js EventEmitter class.
+ */
+class CustomEventEmitter extends EventEmitter { }
+let eventEmitter = new CustomEventEmitter()
+/**
+ * Chat module to interact with the WebSocket server.
+ */
+const cbchat = {
+    /**
+     * 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"
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "getChatHistoryResponse") {
+                    resolve(response); // Resolve the Promise with the response data
+                }
+            })
+        })
+    },
+    /**
+     * 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.
+     */
+    onActionMessage: () => {
+        if (!cbws.getWebsocket) return;
+        cbws.getWebsocket.on('message', (data: string) => {
+            const response = JSON.parse(data);
+            if (response.type === "messageResponse") {
+                // Pass a callback function as an argument to the emit method
+                eventEmitter.emit("userMessage", response, (message: string) => {
+                    console.log("Callback function invoked with message:", message);
+                    cbws.getWebsocket.send(JSON.stringify({
+                        "type": "processStoped"
+                    }));
+                });
+            }
+        });
+        return eventEmitter;
+    },
+    /**
+     * Sends a message through the WebSocket connection.
+     * @param {string} message - The message to be sent.
+     */
+    sendMessage: (message: string, payload: any) => {
+        console.log(message);
+        cbws.getWebsocket.send(JSON.stringify({
+            "type": "sendMessage",
+            "message": message,
+            payload
+        }));
+    },
+    /**
+     * Waits for a reply to a sent message.
+     * @param {string} message - The message for which a reply is expected.
+     * @returns {Promise<UserMessage>} A promise that resolves with the reply.
+     */
+    waitforReply: (message: string): Promise<UserMessage> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "waitforReply",
+                "message": message
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "waitFormessageResponse") {
+                    resolve(response); // Resolve the Promise with the response data
+                }
+            });
+        });
+    },
+    /**
+     * 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: () => {
+        // Send the process started message
+        cbws.getWebsocket.send(JSON.stringify({
+            "type": "processStarted"
+        }));
+        // Register event listener for WebSocket messages
+        cbws.getWebsocket.on('message', (data: string) => {
+            const message = JSON.parse(data);
+            console.log("Received message:", message);
+            if (message.type === 'stopProcessClicked')
+
+                // Emit a custom event based on the message type
+                eventEmitter.emit("stopProcessClicked", message);
+        });
+
+        // Return an object that includes the event emitter and the stopProcess method
+        return {
+            event: eventEmitter,
+            stopProcess: () => {
+                // Implement the logic to stop the process here
+                console.log("Stopping process...");
+                // For example, you might want to send a specific message to the server to stop the process
+                cbws.getWebsocket.send(JSON.stringify({
+                    "type": "processStoped"
+                }));
+            }
+        };
+    },
+    /**
+     * 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...");
+        // For example, you might want to send a specific message to the server to stop the process
+        cbws.getWebsocket.send(JSON.stringify({
+            "type": "processStoped"
+        }));
+    },
+    /**
+   * Stops the ongoing process.
+   * Sends a specific message to the server to stop the process.
+   */
+    processFinished: () => {
+        // Implement the logic to stop the process here
+        console.log("Process Finished ...");
+        // For example, you might want to send a specific message to the server to stop the process
+        cbws.getWebsocket.send(JSON.stringify({
+            "type": "processFinished"
+        }));
+    },
+    /**
+     * Sends a confirmation request to the server with two options: Yes or No.
+     * @returns {Promise<string>} A promise that resolves with the server's response.
+     */
+    sendConfirmationRequest: (confirmationMessage: string, buttons: string[] = [],withFeedback:boolean=false): Promise<string> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "confirmationRequest",
+                "message": confirmationMessage,
+                buttons: buttons,
+                withFeedback
+
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "confirmationResponse" || response.type === "feedbackResponse" ) {
+                    resolve(response); // Resolve the Promise with the server's response
+                }
+            });
+        });
+    },
+    askQuestion: (question: string, buttons: string[] = [],withFeedback:boolean=false): Promise<string> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "confirmationRequest",
+                "message": question,
+                buttons: buttons,
+                withFeedback
+
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "confirmationResponse" || response.type === "feedbackResponse" ) {
+                    resolve(response); // Resolve the Promise with the server's response
+                }
+            });
+        });
+    },
+    /**
+ * Sends a notification event to the server.
+ * @param {string} notificationMessage - The message to be sent in the notification.
+ */
+    sendNotificationEvent: (notificationMessage: string, type: 'debug' | 'git' | 'planner' | 'browser' | 'editor' | 'terminal' | 'preview'): void => {
+        cbws.getWebsocket.send(JSON.stringify({
+            "type": "notificationEvent",
+            "message": notificationMessage,
+            "eventType": type
+        }));
+    },
+
+};
+
+export default cbchat;

package/src/modules/codeparsers.ts

@@ -0,0 +1,30 @@
+/**
+ * A collection of code parser functions.
+ */
+const cbcodeparsers = {
+    /**
+     * Retrieves the classes in a given file.
+     * @param file The file to parse for classes.
+     */
+    getClassesInFile: (file: any) => {
+        console.log('Code parsers initialized');
+    },
+    /**
+     * Retrieves the functions in a given class within a file.
+     * @param file The file containing the class.
+     * @param className The name of the class to parse for functions.
+     */
+    getFunctionsinClass: (file: any, className: any) => {
+        console.log('Code parsers initialized');
+    },
+    /**
+     * Generates an Abstract Syntax Tree (AST) for a given file.
+     * @param file The file to generate an AST for.
+     * @param className The name of the class to focus the AST generation on.
+     */
+    getAstTreeInFile: (file: any, className: any) => {
+        
+    }
+};
+
+export default cbcodeparsers;

package/src/modules/codeutils.ts

@@ -0,0 +1,126 @@
+import cbws from './websocket';
+import * as fs from 'fs';
+import path from 'path';
+// import  Parser  from 'tree-sitter';
+// import  JavaScript  from 'tree-sitter-javascript';
+
+import { GetJsTreeResponse, MatchProblemResponse, GetMatcherListTreeResponse, getMatchDetail } from '@codebolt/types';
+
+/**
+ * A utility module for working with code.
+ */
+const cbcodeutils = {
+
+    /**
+     * 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) => {
+        return new Promise(async (resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "codeEvent",
+                "action": "getJsTree",
+                payload: {
+                    filePath
+                }
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "getJsTreeResponse") {
+                    resolve(response); // Resolve the Promise with the response data
+                }
+            });
+        });
+    },
+
+    /**
+     * 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",
+                "action": "getAllFilesMarkdown"
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "getAllFilesMarkdownResponse") {
+                    resolve(response); // Resolve the Promise with the response data
+                }
+            });
+        });
+    },
+
+    /**
+     * 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",
+                "action": "performMatch",
+                payload: {
+                    matcherDefinition,
+                    problemPatterns,
+                }
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "getgetJsTreeResponse") {
+                    resolve(response); // Resolve the Promise with the response data
+                }
+            });
+        });
+    },
+
+    /**
+     * 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(response); // Resolve the Promise with the response data
+                }
+            });
+        });
+    },
+
+    /**
+     * 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",
+                "action": "getMatchDetail",
+                payload: {
+                    match: matcher
+                }
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "matchDetailTreeResponse") {
+                    resolve(response); // Resolve the Promise with the response data
+                }
+            });
+        });
+    }
+
+};
+
+export default cbcodeutils;