@codebolt/codeboltjs 2.2.2 → 2.2.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codebolt/codeboltjs",
-  "version": "2.2.2",
+  "version": "2.2.3",
   "description": "",
   "keywords": [],
   "author": "",
@@ -11,6 +11,16 @@
     "README.md",
     "LICENSE"
   ],
+  "scripts": {
+    "build": "tsc && node script/copy-wasm.js",
+    "build:webpack": "webpack",
+    "build:all": "npm run build && npm run build:webpack",
+    "build:docs": "typedoc --plugin typedoc-plugin-missing-exports",
+    "build:jsondocs": "typedoc --plugin typedoc-plugin-missing-exports --json out.json --pretty",
+    "test": "echo \"Integration tests require WebSocket server - skipping for release\" && exit 0",
+    "clean": "powershell -Command \"Remove-Item -Path 'dist' -Recurse -Force -ErrorAction SilentlyContinue; Remove-Item -Path 'build' -Recurse -Force -ErrorAction SilentlyContinue\"",
+    "lint": "eslint src/**/*.ts && tsc --noEmit"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/codeboltai/codeboltjs.git",
@@ -22,6 +32,7 @@
     "access": "public"
   },
   "dependencies": {
+    "@codebolt/types": "workspace:*",
     "@types/uuid": "^10.0.0",
     "buffer": "^6.0.3",
     "execa": "^9.5.2",
@@ -32,9 +43,8 @@
     "timers": "^0.1.1",
     "util": "^0.12.5",
     "uuid": "^11.1.0",
-    "ws": "^8.17.0",
-    "yargs": "^17.7.2",
-    "@codebolt/types": "1.0.16"
+    "ws": "^8.18.3",
+    "yargs": "^17.7.2"
   },
   "devDependencies": {
     "@types/events": "^3.0.3",
@@ -42,14 +52,14 @@
     "@types/node": "^20.14.2",
     "@types/uri-templates": "^0.1.34",
     "@types/ws": "^8.5.10",
-    "jest": "^29.7.0",
+    "jest": "^30.2.0",
     "jest-serial-runner": "^1.2.1",
     "ts-loader": "^9.5.1",
     "typedoc": "^0.28.10",
     "typedoc-plugin-markdown": "^3.15.0",
     "typedoc-plugin-missing-exports": "^4.1.0",
     "typescript": "^5.4.5",
-    "webpack": "^5.91.0",
+    "webpack": "^5.102.1",
     "webpack-cli": "^5.1.4"
   },
   "jest": {
@@ -60,15 +70,5 @@
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
     }
-  },
-  "scripts": {
-    "build": "tsc && node script/copy-wasm.js",
-    "build:webpack": "webpack",
-    "build:all": "npm run build && npm run build:webpack",
-    "build:docs": "typedoc --plugin typedoc-plugin-missing-exports",
-    "build:jsondocs": "typedoc --plugin typedoc-plugin-missing-exports --json out.json --pretty",
-    "test": "echo \"Integration tests require WebSocket server - skipping for release\" && exit 0",
-    "clean": "powershell -Command \"Remove-Item -Path 'dist' -Recurse -Force -ErrorAction SilentlyContinue; Remove-Item -Path 'build' -Recurse -Force -ErrorAction SilentlyContinue\"",
-    "lint": "eslint src/**/*.ts && tsc --noEmit"
   }
-}
+}

package/dist/modules/codeparsers.d.ts

@@ -1,37 +0,0 @@
-import type { ASTNode } from "../types/commonTypes";
-/**
- * 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: 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: 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: string, className?: string) => Promise<ASTNode | {
-        error: string;
-    }>;
-};
-export default cbcodeparsers;

package/dist/modules/codeparsers.js

@@ -1,329 +0,0 @@
-"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 () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-const codeparser_1 = require("@codebolt/codeparser");
-const fs = __importStar(require("fs/promises"));
-const path = __importStar(require("path"));
-/**
- * A collection of code parser functions.
- */
-const cbcodeparsers = {
-    /**
-     * Retrieves the classes in a given file.
-     * @param file The file to parse for classes.
-     */
-    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, codeparser_1.loadRequiredLanguageParsers)([file]);
-        // Parse the file
-        const result = await (0, codeparser_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, codeparser_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: 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, codeparser_1.loadRequiredLanguageParsers)([file]);
-        // Parse the file
-        const result = await (0, codeparser_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: 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, codeparser_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;