@codebolt/codeboltjs 1.1.76 → 1.1.78

package/modules/browser.js

@@ -0,0 +1,331 @@
+"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"));
+/**
+ * A module for interacting with a browser through WebSockets.
+ */
+const cbbrowser = {
+    /**
+     * Opens a new page in the browser.
+     */
+    newPage: () => {
+        return new Promise((resolve, reject) => {
+            websocket_1.default.getWebsocket.send(JSON.stringify({
+                "type": "browserEvent",
+                action: 'newPage'
+            }));
+            websocket_1.default.getWebsocket.on('message', (data) => {
+                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: () => {
+        return new Promise((resolve, reject) => {
+            websocket_1.default.getWebsocket.send(JSON.stringify({
+                "type": "browserEvent",
+                action: 'getUrl'
+            }));
+            websocket_1.default.getWebsocket.on('message', (data) => {
+                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) => {
+        return new Promise((resolve, reject) => {
+            websocket_1.default.getWebsocket.send(JSON.stringify({
+                "type": "browserEvent",
+                action: 'goToPage',
+                url
+            }));
+            websocket_1.default.getWebsocket.on('message', (data) => {
+                const response = JSON.parse(data);
+                if (response.event === "goToPageResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+    /**
+     * Takes a screenshot of the current page.
+     */
+    screenshot: () => {
+        return new Promise((resolve, reject) => {
+            websocket_1.default.getWebsocket.send(JSON.stringify({
+                "type": "browserEvent",
+                action: 'screenshot'
+            }));
+            websocket_1.default.getWebsocket.on('message', (data) => {
+                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: () => {
+        return new Promise((resolve, reject) => {
+            websocket_1.default.getWebsocket.send(JSON.stringify({
+                "type": "browserEvent",
+                action: 'getHTML'
+            }));
+            websocket_1.default.getWebsocket.on('message', (data) => {
+                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: () => {
+        return new Promise((resolve, reject) => {
+            websocket_1.default.getWebsocket.send(JSON.stringify({
+                "type": "browserEvent",
+                action: 'getMarkdown'
+            }));
+            websocket_1.default.getWebsocket.on('message', (data) => {
+                const response = JSON.parse(data);
+                if (response.event === "getMarkdownResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+    /**
+     * Retrieves the PDF content of the current page.
+     *
+     */
+    getPDF: () => {
+        websocket_1.default.getWebsocket.send(JSON.stringify({
+            "type": "browserEvent",
+            action: 'getPDF'
+        }));
+    },
+    /**
+     * Converts the PDF content of the current page to text.
+     */
+    pdfToText: () => {
+        websocket_1.default.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: () => {
+        return new Promise((resolve, reject) => {
+            websocket_1.default.getWebsocket.send(JSON.stringify({
+                "type": "browserEvent",
+                action: 'getContent'
+            }));
+            websocket_1.default.getWebsocket.on('message', (data) => {
+                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: () => {
+        return new Promise((resolve, reject) => {
+            websocket_1.default.getWebsocket.send(JSON.stringify({
+                "type": "browserEvent",
+                action: 'getSnapShot'
+            }));
+            websocket_1.default.getWebsocket.on('message', (data) => {
+                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: () => {
+        return new Promise((resolve, reject) => {
+            websocket_1.default.getWebsocket.send(JSON.stringify({
+                "type": "browserEvent",
+                action: 'getBrowserInfo'
+            }));
+            websocket_1.default.getWebsocket.on('message', (data) => {
+                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: () => {
+        return new Promise((resolve, reject) => {
+            websocket_1.default.getWebsocket.send(JSON.stringify({
+                "type": "browserEvent",
+                action: 'extractText'
+            }));
+            websocket_1.default.getWebsocket.on('message', (data) => {
+                const response = JSON.parse(data);
+                if (response.event === "extractTextResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+    /**
+     * Closes the current page.
+     */
+    close: () => {
+        websocket_1.default.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, pixels) => {
+        return new Promise((resolve, reject) => {
+            websocket_1.default.getWebsocket.send(JSON.stringify({
+                "type": "browserEvent",
+                action: 'scroll',
+                direction,
+                pixels
+            }));
+            websocket_1.default.getWebsocket.on('message', (data) => {
+                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, text) => {
+        return new Promise((resolve, reject) => {
+            websocket_1.default.getWebsocket.send(JSON.stringify({
+                "type": "browserEvent",
+                action: 'type',
+                text,
+                elementid
+            }));
+            websocket_1.default.getWebsocket.on('message', (data) => {
+                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) => {
+        return new Promise((resolve, reject) => {
+            websocket_1.default.getWebsocket.send(JSON.stringify({
+                "type": "browserEvent",
+                action: 'click',
+                elementid
+            }));
+            websocket_1.default.getWebsocket.on('message', (data) => {
+                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) => {
+            websocket_1.default.getWebsocket.send(JSON.stringify({
+                "type": "browserEvent",
+                action: 'enter'
+            }));
+            websocket_1.default.getWebsocket.on('message', (data) => {
+                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, query) => {
+        return new Promise((resolve, reject) => {
+            websocket_1.default.getWebsocket.send(JSON.stringify({
+                "type": "browserEvent",
+                action: 'search',
+                elementid,
+                query
+            }));
+            websocket_1.default.getWebsocket.on('message', (data) => {
+                const response = JSON.parse(data);
+                if (response.event === "searchResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    }
+};
+exports.default = cbbrowser;
+/***
+
+start_browser(objective: string, url: string, previous_command: string, browser_content: string) {
+    cbbrowser.newPage();
+}
+ */ 

package/modules/chat.d.ts

@@ -0,0 +1,64 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { ChatMessage, UserMessage } from '@codebolt/types';
+/**
+ * CustomEventEmitter class that extends the Node.js EventEmitter class.
+ */
+declare class CustomEventEmitter extends EventEmitter {
+}
+/**
+ * Chat module to interact with the WebSocket server.
+ */
+declare 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[]>;
+    /**
+     * 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: () => CustomEventEmitter | undefined;
+    /**
+     * Sends a message through the WebSocket connection.
+     * @param {string} message - The message to be sent.
+     */
+    sendMessage: (message: string, payload: any) => void;
+    /**
+     * 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>;
+    /**
+     * 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: () => {
+        event: CustomEventEmitter;
+        stopProcess: () => void;
+    };
+    /**
+     * Stops the ongoing process.
+     * Sends a specific message to the server to stop the process.
+     */
+    stopProcess: () => void;
+    /**
+   * Stops the ongoing process.
+   * Sends a specific message to the server to stop the process.
+   */
+    processFinished: () => void;
+    /**
+     * 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) => Promise<string>;
+    askQuestion: (question: string, buttons?: string[], withFeedback?: boolean) => Promise<string>;
+    /**
+ * 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;
+};
+export default cbchat;

package/modules/chat.js

@@ -0,0 +1,190 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// chat.ts
+const websocket_1 = __importDefault(require("./websocket"));
+const events_1 = require("events");
+/**
+ * CustomEventEmitter class that extends the Node.js EventEmitter class.
+ */
+class CustomEventEmitter extends events_1.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: () => {
+        return new Promise((resolve, reject) => {
+            websocket_1.default.getWebsocket.send(JSON.stringify({
+                "type": "getChatHistory"
+            }));
+            websocket_1.default.getWebsocket.on('message', (data) => {
+                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 (!websocket_1.default.getWebsocket)
+            return;
+        websocket_1.default.getWebsocket.on('message', (data) => {
+            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) => {
+                    console.log("Callback function invoked with message:", message);
+                    websocket_1.default.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, payload) => {
+        console.log(message);
+        websocket_1.default.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) => {
+        return new Promise((resolve, reject) => {
+            websocket_1.default.getWebsocket.send(JSON.stringify({
+                "type": "waitforReply",
+                "message": message
+            }));
+            websocket_1.default.getWebsocket.on('message', (data) => {
+                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
+        websocket_1.default.getWebsocket.send(JSON.stringify({
+            "type": "processStarted"
+        }));
+        // Register event listener for WebSocket messages
+        websocket_1.default.getWebsocket.on('message', (data) => {
+            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
+                websocket_1.default.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
+        websocket_1.default.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
+        websocket_1.default.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, buttons = [], withFeedback = false) => {
+        return new Promise((resolve, reject) => {
+            websocket_1.default.getWebsocket.send(JSON.stringify({
+                "type": "confirmationRequest",
+                "message": confirmationMessage,
+                buttons: buttons,
+                withFeedback
+            }));
+            websocket_1.default.getWebsocket.on('message', (data) => {
+                const response = JSON.parse(data);
+                if (response.type === "confirmationResponse" || response.type === "feedbackResponse") {
+                    resolve(response); // Resolve the Promise with the server's response
+                }
+            });
+        });
+    },
+    askQuestion: (question, buttons = [], withFeedback = false) => {
+        return new Promise((resolve, reject) => {
+            websocket_1.default.getWebsocket.send(JSON.stringify({
+                "type": "confirmationRequest",
+                "message": question,
+                buttons: buttons,
+                withFeedback
+            }));
+            websocket_1.default.getWebsocket.on('message', (data) => {
+                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, type) => {
+        websocket_1.default.getWebsocket.send(JSON.stringify({
+            "type": "notificationEvent",
+            "message": notificationMessage,
+            "eventType": type
+        }));
+    },
+};
+exports.default = cbchat;

package/modules/codeparsers.d.ts

@@ -0,0 +1,23 @@
+/**
+ * A collection of code parser functions.
+ */
+declare const cbcodeparsers: {
+    /**
+     * Retrieves the classes in a given file.
+     * @param file The file to parse for classes.
+     */
+    getClassesInFile: (file: any) => void;
+    /**
+     * 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) => void;
+    /**
+     * 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) => void;
+};
+export default cbcodeparsers;

package/modules/codeparsers.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * 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) => {
+        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, className) => {
+        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, className) => {
+    }
+};
+exports.default = cbcodeparsers;

package/modules/codeutils.d.ts

@@ -0,0 +1,37 @@
+import { MatchProblemResponse, GetMatcherListTreeResponse, getMatchDetail } from '@codebolt/types';
+/**
+ * A utility module for working with code.
+ */
+declare 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) => Promise<unknown>;
+    /**
+     * Retrieves all files as Markdown.
+     * @returns {Promise<string>} A promise that resolves with the Markdown content of all files.
+     */
+    getAllFilesAsMarkDown: () => Promise<string>;
+    /**
+     * 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>;
+    /**
+     * Retrieves the list of matchers.
+     * @returns {Promise<GetMatcherListTreeResponse>} A promise that resolves with the list of matchers response.
+     */
+    getMatcherList: () => Promise<GetMatcherListTreeResponse>;
+    /**
+     * 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>;
+};
+export default cbcodeutils;