@codebolt/codeboltjs 2.0.4 → 2.0.6

package/dist/modules/chat.js

@@ -4,14 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (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();
+const websocket_1 = __importDefault(require("../core/websocket"));
 /**
  * Chat module to interact with the WebSocket server.
  */
@@ -21,17 +14,9 @@ const cbchat = {
      * @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
-                }
-            });
-        });
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "getChatHistory"
+        }, "getChatHistoryResponse");
     },
     /**
      * Sets a global request handler for all incoming messages
@@ -40,15 +25,14 @@ const cbchat = {
     setRequestHandler: (handler) => {
         const waitForConnection = () => {
             const setupHandler = () => {
-                if (websocket_1.default.getWebsocket) {
-                    websocket_1.default.getWebsocket.on('message', async (data) => {
+                if (websocket_1.default.messageManager) {
+                    websocket_1.default.messageManager.on('message', async (request) => {
                         try {
-                            const request = JSON.parse(data);
                             await handler(request, (responseData) => {
-                                websocket_1.default.getWebsocket.send(JSON.stringify({
+                                websocket_1.default.messageManager.send({
                                     type: `processStoped`,
                                     ...responseData
-                                }));
+                                });
                             });
                         }
                         catch (error) {
@@ -64,46 +48,16 @@ const cbchat = {
         };
         waitForConnection();
     },
-    /**
-     * 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.
-     */
-    /**
- * 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: () => {
-        const waitForConnection = () => {
-            if (websocket_1.default.getWebsocket) {
-                websocket_1.default.getWebsocket.on('message', (data) => {
-                    const response = JSON.parse(data);
-                    if (response.type === "messageResponse") {
-                        eventEmitter.emit("userMessage", response, (message) => {
-                            websocket_1.default.getWebsocket.send(JSON.stringify({
-                                "type": "processStoped",
-                                "message": message
-                            }));
-                        });
-                    }
-                });
-            }
-            else {
-                setTimeout(waitForConnection, 100);
-            }
-        };
-        waitForConnection();
-        return eventEmitter;
-    },
     /**
      * Sends a message through the WebSocket connection.
      * @param {string} message - The message to be sent.
      */
     sendMessage: (message, payload) => {
-        websocket_1.default.getWebsocket.send(JSON.stringify({
+        websocket_1.default.messageManager.send({
             "type": "sendMessage",
             "message": message,
             payload
-        }));
+        });
     },
     /**
      * Waits for a reply to a sent message.
@@ -111,44 +65,47 @@ const cbchat = {
      * @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
-                }
-            });
-        });
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "waitforReply",
+            "message": message
+        }, "waitFormessageResponse");
     },
     /**
-     * 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.
+     * Notifies the server that a process has started and sets up a listener for stopProcessClicked events.
+     * @param {Function} onStopClicked - Callback function to handle stop process events.
+     * @returns An object containing a stopProcess method.
      */
-    processStarted: () => {
+    processStarted: (onStopClicked) => {
         // Send the process started message
-        websocket_1.default.getWebsocket.send(JSON.stringify({
+        websocket_1.default.messageManager.send({
             "type": "processStarted"
-        }));
-        // Register event listener for WebSocket messages
-        websocket_1.default.getWebsocket.on('message', (data) => {
-            const message = JSON.parse(data);
-            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
+        // Register event listener for WebSocket messages if callback provided
+        if (onStopClicked) {
+            const handleStopMessage = (message) => {
+                if (message.type === 'stopProcessClicked') {
+                    onStopClicked(message);
+                }
+            };
+            websocket_1.default.messageManager.on('message', handleStopMessage);
+            // Return an object that includes the stopProcess method and cleanup
+            return {
+                stopProcess: () => {
+                    websocket_1.default.messageManager.send({
+                        "type": "processStoped"
+                    });
+                },
+                cleanup: () => {
+                    websocket_1.default.messageManager.removeListener('message', handleStopMessage);
+                }
+            };
+        }
+        // Return an object that includes the stopProcess method
         return {
-            event: eventEmitter,
             stopProcess: () => {
-                // Implement the logic to stop the process here
-                // For example, you might want to send a specific message to the server to stop the process
-                websocket_1.default.getWebsocket.send(JSON.stringify({
+                websocket_1.default.messageManager.send({
                     "type": "processStoped"
-                }));
+                });
             }
         };
     },
@@ -157,69 +114,49 @@ const cbchat = {
      * Sends a specific message to the server to stop the process.
      */
     stopProcess: () => {
-        // Implement the logic to stop the process here
-        // For example, you might want to send a specific message to the server to stop the process
-        websocket_1.default.getWebsocket.send(JSON.stringify({
+        websocket_1.default.messageManager.send({
             "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
-        // For example, you might want to send a specific message to the server to stop the process
-        websocket_1.default.getWebsocket.send(JSON.stringify({
+        websocket_1.default.messageManager.send({
             "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
-                }
-            });
-        });
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "confirmationRequest",
+            "message": confirmationMessage,
+            buttons: buttons,
+            withFeedback
+        }, "confirmationResponse|feedbackResponse");
     },
     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
-                }
-            });
-        });
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "confirmationRequest",
+            "message": question,
+            buttons: buttons,
+            withFeedback
+        }, "confirmationResponse|feedbackResponse");
     },
     /**
  * 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({
+        websocket_1.default.messageManager.send({
             "type": "notificationEvent",
             "message": notificationMessage,
             "eventType": type
-        }));
+        });
     },
 };
 exports.default = cbchat;

package/dist/modules/codeparsers.d.ts

@@ -1,3 +1,19 @@
+/**
+ * Type definition for an AST node.
+ */
+export interface ASTNode {
+    type: string;
+    text: string;
+    startPosition: {
+        row: number;
+        column: number;
+    };
+    endPosition: {
+        row: number;
+        column: number;
+    };
+    children: ASTNode[];
+}
 /**
  * A collection of code parser functions.
  */
@@ -6,18 +22,31 @@ declare const cbcodeparsers: {
      * Retrieves the classes in a given file.
      * @param file The file to parse for classes.
      */
-    getClassesInFile: (file: any) => void;
+    getClassesInFile: (file: string) => Promise<{
+        error: string;
+    } | {
+        name: any;
+        location: string;
+    }[]>;
     /**
      * 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;
+    getFunctionsinClass: (file: string, className: string) => Promise<{
+        error: string;
+    } | {
+        name: string;
+        class: string;
+        location: string;
+    }[]>;
     /**
      * 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;
+    getAstTreeInFile: (file: string, className?: string) => Promise<ASTNode | {
+        error: string;
+    }>;
 };
 export default cbcodeparsers;

package/dist/modules/codeparsers.js

@@ -1,5 +1,32 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+const parse_source_code_1 = require("../utils/parse-source-code");
+const languageParser_1 = require("../utils/parse-source-code/languageParser");
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
 /**
  * A collection of code parser functions.
  */
@@ -8,21 +35,286 @@ const cbcodeparsers = {
      * Retrieves the classes in a given file.
      * @param file The file to parse for classes.
      */
-    getClassesInFile: (file) => {
+    getClassesInFile: async (file) => {
+        // Check if file exists
+        try {
+            await fs.access(file);
+        }
+        catch (error) {
+            return { error: `File does not exist or is not accessible: ${file}` };
+        }
+        // Get file extension and determine if we support it
+        const ext = path.extname(file).toLowerCase().slice(1);
+        const supportedExtensions = ['js', 'jsx', 'ts', 'tsx', 'py', 'rs', 'go', 'c', 'h', 'cpp', 'hpp', 'cs', 'rb', 'java', 'php', 'swift'];
+        if (!supportedExtensions.includes(ext)) {
+            return { error: `Unsupported file type: ${ext}` };
+        }
+        // Load language parser for this file
+        const languageParsers = await (0, languageParser_1.loadRequiredLanguageParsers)([file]);
+        // Parse the file
+        const result = await (0, parse_source_code_1.parseFile)(file, languageParsers);
+        // Filter for class definitions only
+        const lines = (result === null || result === void 0 ? void 0 : result.split('\n')) || [];
+        const classes = [];
+        let currentClass = null;
+        for (const line of lines) {
+            // Match line patterns from the parseFile result format
+            if (line.includes('@definition.class')) {
+                // Extract the class name from the line
+                const className = line.split('@')[0].trim();
+                currentClass = { name: className, location: file };
+                classes.push(currentClass);
+            }
+        }
+        // If no classes found, try to use AST approach
+        if (classes.length === 0) {
+            try {
+                // Get the file extension
+                const ext = path.extname(file).toLowerCase().slice(1);
+                // Load language parser
+                const languageParsers = await (0, languageParser_1.loadRequiredLanguageParsers)([file]);
+                // Get the parser for this file type
+                const { parser } = languageParsers[ext] || {};
+                if (parser) {
+                    // Read the file content
+                    const fileContent = await fs.readFile(file, 'utf8');
+                    // Parse the file to get AST
+                    const tree = parser.parse(fileContent);
+                    // Function to find class nodes in the AST
+                    const findClassNodes = (node) => {
+                        const classNodes = [];
+                        if (node.type === 'class_declaration' ||
+                            node.type === 'class' ||
+                            node.type === 'class_definition') {
+                            classNodes.push(node);
+                        }
+                        // Recursively search children
+                        for (let i = 0; i < node.childCount; i++) {
+                            const childResults = findClassNodes(node.child(i));
+                            classNodes.push(...childResults);
+                        }
+                        return classNodes;
+                    };
+                    const classNodes = findClassNodes(tree.rootNode);
+                    // Extract class names from the nodes
+                    for (const node of classNodes) {
+                        // For most languages, the class name is in a child node
+                        // Let's attempt to extract it from the text
+                        const text = node.text;
+                        const classMatch = text.match(/class\s+([a-zA-Z_$][0-9a-zA-Z_$]*)/);
+                        if (classMatch && classMatch[1]) {
+                            classes.push({
+                                name: classMatch[1],
+                                location: file
+                            });
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                console.error('Error trying AST approach:', error);
+            }
+        }
+        return classes;
     },
     /**
      * 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) => {
+    getFunctionsinClass: async (file, className) => {
+        // Check if file exists
+        try {
+            await fs.access(file);
+        }
+        catch (error) {
+            return { error: `File does not exist or is not accessible: ${file}` };
+        }
+        // Load language parser for this file
+        const languageParsers = await (0, languageParser_1.loadRequiredLanguageParsers)([file]);
+        // Parse the file
+        const result = await (0, parse_source_code_1.parseFile)(file, languageParsers);
+        // Extract content
+        const fileContent = await fs.readFile(file, 'utf8');
+        // Parse the file content to find the class and its methods
+        const lines = (result === null || result === void 0 ? void 0 : result.split('\n')) || [];
+        const functions = [];
+        // Use AST approach to find methods within the class
+        try {
+            // Get the file extension
+            const ext = path.extname(file).toLowerCase().slice(1);
+            // Get the parser for this file type
+            const { parser } = languageParsers[ext] || {};
+            if (parser) {
+                // Parse the file to get AST
+                const tree = parser.parse(fileContent);
+                // Find the class node
+                const findClassNode = (node) => {
+                    if ((node.type === 'class_declaration' ||
+                        node.type === 'class' ||
+                        node.type === 'class_definition') &&
+                        node.text.includes(className)) {
+                        return node;
+                    }
+                    // Recursively search children
+                    for (let i = 0; i < node.childCount; i++) {
+                        const child = node.child(i);
+                        const result = findClassNode(child);
+                        if (result)
+                            return result;
+                    }
+                    return null;
+                };
+                const classNode = findClassNode(tree.rootNode);
+                if (classNode) {
+                    // Function to find method nodes within the class
+                    const findMethodNodes = (node) => {
+                        const methodNodes = [];
+                        // Different languages use different node types for methods
+                        if (node.type === 'method_definition' ||
+                            node.type === 'method' ||
+                            node.type === 'method_declaration' ||
+                            node.type === 'function' ||
+                            node.type === 'function_definition') {
+                            methodNodes.push(node);
+                        }
+                        // Recursively search children
+                        for (let i = 0; i < node.childCount; i++) {
+                            const childResults = findMethodNodes(node.child(i));
+                            methodNodes.push(...childResults);
+                        }
+                        return methodNodes;
+                    };
+                    const methodNodes = findMethodNodes(classNode);
+                    // Extract method names from the nodes
+                    for (const node of methodNodes) {
+                        // Try to find method name from node text
+                        let methodName = '';
+                        // Different pattern matching based on language type
+                        if (ext === 'py') {
+                            // Python methods: def method_name(
+                            const methodMatch = node.text.match(/def\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*\(/);
+                            if (methodMatch && methodMatch[1]) {
+                                methodName = methodMatch[1];
+                            }
+                        }
+                        else if (['js', 'jsx', 'ts', 'tsx'].includes(ext)) {
+                            // JavaScript/TypeScript methods: methodName( or methodName =
+                            const methodMatch = node.text.match(/([a-zA-Z_$][a-zA-Z0-9_$]*)\s*[\(=]/);
+                            if (methodMatch && methodMatch[1]) {
+                                methodName = methodMatch[1];
+                            }
+                        }
+                        else {
+                            // Generic approach for other languages
+                            // Look for identifiers followed by parentheses
+                            const methodMatch = node.text.match(/([a-zA-Z_][a-zA-Z0-9_]*)\s*\(/);
+                            if (methodMatch && methodMatch[1]) {
+                                methodName = methodMatch[1];
+                            }
+                        }
+                        if (methodName && !['constructor', '__init__'].includes(methodName)) {
+                            functions.push({
+                                name: methodName,
+                                class: className,
+                                location: file
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.error('Error parsing methods:', error);
+        }
+        return functions;
     },
     /**
      * 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) => {
+    getAstTreeInFile: async (file, className) => {
+        try {
+            await fs.access(file);
+        }
+        catch (error) {
+            return { error: `File does not exist or is not accessible: ${file}` };
+        }
+        // Get file extension and determine if we support it
+        const ext = path.extname(file).toLowerCase().slice(1);
+        const supportedExtensions = ['js', 'jsx', 'ts', 'tsx', 'py', 'rs', 'go', 'c', 'h', 'cpp', 'hpp', 'cs', 'rb', 'java', 'php', 'swift'];
+        if (!supportedExtensions.includes(ext)) {
+            return { error: `Unsupported file type: ${ext}` };
+        }
+        // Load language parser for this file
+        const languageParsers = await (0, languageParser_1.loadRequiredLanguageParsers)([file]);
+        // Get the parser for this file type
+        const { parser } = languageParsers[ext] || {};
+        if (!parser) {
+            return { error: `No parser available for file type: ${ext}` };
+        }
+        // Read the file content
+        const fileContent = await fs.readFile(file, 'utf8');
+        // Parse the file to get AST
+        const tree = parser.parse(fileContent);
+        // If className is provided, find and return only that class's AST
+        if (className) {
+            // Function to recursively search for the class node
+            const findClassNode = (node) => {
+                if ((node.type === 'class_declaration' ||
+                    node.type === 'abstract_class_declaration' ||
+                    node.type === 'class_definition') &&
+                    node.text.includes(className)) {
+                    return node;
+                }
+                // Recursively search children
+                for (let i = 0; i < node.childCount; i++) {
+                    const child = node.child(i);
+                    const result = findClassNode(child);
+                    if (result)
+                        return result;
+                }
+                return null;
+            };
+            const classNode = findClassNode(tree.rootNode);
+            if (classNode) {
+                // Convert the class node to a JSON-serializable object
+                const serializeNode = (node) => {
+                    const result = {
+                        type: node.type,
+                        text: node.text,
+                        startPosition: { row: node.startPosition.row, column: node.startPosition.column },
+                        endPosition: { row: node.endPosition.row, column: node.endPosition.column },
+                        children: []
+                    };
+                    for (let i = 0; i < node.childCount; i++) {
+                        result.children.push(serializeNode(node.child(i)));
+                    }
+                    return result;
+                };
+                return serializeNode(classNode);
+            }
+            else {
+                return { error: `Class '${className}' not found in file: ${file}` };
+            }
+        }
+        // Otherwise return the full AST
+        // Convert the full tree to a JSON-serializable object
+        const serializeNode = (node) => {
+            const result = {
+                type: node.type,
+                text: node.text,
+                startPosition: { row: node.startPosition.row, column: node.startPosition.column },
+                endPosition: { row: node.endPosition.row, column: node.endPosition.column },
+                children: []
+            };
+            for (let i = 0; i < node.childCount; i++) {
+                result.children.push(serializeNode(node.child(i)));
+            }
+            return result;
+        };
+        return serializeNode(tree.rootNode);
     }
 };
 exports.default = cbcodeparsers;