@codebolt/codeboltjs 2.0.5 → 2.0.6

package/dist/core/websocket.js

@@ -55,7 +55,8 @@ class cbws {
         const parentIdParam = process.env.parentId ? `&parentId=${process.env.parentId}` : '';
         const parentAgentInstanceIdParam = process.env.parentAgentInstanceId ? `&parentAgentInstanceId=${process.env.parentAgentInstanceId}` : '';
         const agentTask = process.env.agentTask ? `&agentTask=${process.env.agentTask}` : '';
-        this.websocket = new ws_1.default(`ws://localhost:${process.env.SOCKET_PORT}/codebolt?id=${uniqueConnectionId}${agentIdParam}${parentIdParam}${parentAgentInstanceIdParam}${agentTask}${process.env.Is_Dev ? '&dev=true' : ''}`);
+        const socketPort = process.env.SOCKET_PORT || '12345';
+        this.websocket = new ws_1.default(`ws://localhost:${socketPort}/codebolt?id=${uniqueConnectionId}${agentIdParam}${parentIdParam}${parentAgentInstanceIdParam}${agentTask}${process.env.Is_Dev ? '&dev=true' : ''}`);
         return new Promise((resolve, reject) => {
             this.websocket.on('error', (error) => {
                 reject(error);

package/dist/index.d.ts

@@ -35,19 +35,30 @@ declare class Codebolt {
             result: any;
         }>;
         writeToFile: (relPath: string, newContent: string) => Promise<any>;
+        grepSearch: (path: string, query: string, includePattern?: string | undefined, excludePattern?: string | undefined, caseSensitive?: boolean) => Promise<{
+            success: boolean;
+            result: any;
+        }>;
+        fileSearch: (query: string) => Promise<{
+            success: boolean;
+            result: any;
+        }>;
+        editFileWithDiff: (targetFile: string, codeEdit: string, diffIdentifier: string, prompt: string, applyModel?: string | undefined) => Promise<{
+            success: boolean;
+            result: any;
+        }>;
     };
     git: {
         init: (path: string) => Promise<any>;
-        clone: (url: string, path: string) => Promise<any>;
-        pull: (path: string) => Promise<any>;
-        push: (path: string) => Promise<any>;
-        status: (path: string) => Promise<any>;
-        add: (path: string) => Promise<any>;
+        pull: () => Promise<any>;
+        push: () => Promise<any>;
+        status: () => Promise<any>;
+        addAll: () => Promise<any>;
         commit: (message: string) => Promise<any>;
-        checkout: (path: string, branch: string) => Promise<any>;
-        branch: (path: string, branch: string) => Promise<any>;
+        checkout: (branch: string) => Promise<any>;
+        branch: (branch: string) => Promise<any>;
         logs: (path: string) => Promise<any>;
-        diff: (commitHash: string, path: string) => Promise<any>;
+        diff: (commitHash: string) => Promise<any>;
     };
     llm: {
         inference: (message: string, llmrole: string) => Promise<import("@codebolt/types").LLMResponse>;
@@ -134,14 +145,14 @@ declare class Codebolt {
         };
     };
     codeutils: {
-        getJsTree: (filePath?: string | undefined) => Promise<any>;
+        getJsTree: (filePath?: string | undefined) => Promise<import("./modules/codeutils").JSTreeResponse>;
         getAllFilesAsMarkDown: () => Promise<string>;
-        performMatch: (matcherDefinition: object, problemPatterns: any[], problems: any[]) => Promise<import("@codebolt/types").MatchProblemResponse>;
+        performMatch: (matcherDefinition: object, problemPatterns: any[], problems?: any[]) => Promise<import("@codebolt/types").MatchProblemResponse>;
         getMatcherList: () => Promise<import("@codebolt/types").GetMatcherListTreeResponse>;
         matchDetail: (matcher: string) => Promise<import("@codebolt/types").getMatchDetail>;
     };
     docutils: {
-        pdf_to_text: (pdf_path: any) => Promise<string>;
+        pdf_to_text: (pdf_path: string) => Promise<string>;
     };
     crawler: {
         start: () => void;
@@ -162,17 +173,47 @@ declare class Codebolt {
         retrieve_related_knowledge: (query: string, filename: string) => void;
     };
     codeparsers: {
-        getClassesInFile: (file: any) => void;
-        getFunctionsinClass: (file: any, className: any) => void;
-        getAstTreeInFile: (file: any, className: any) => void;
+        getClassesInFile: (file: string) => Promise<{
+            error: string;
+        } | {
+            name: any;
+            location: string;
+        }[]>;
+        getFunctionsinClass: (file: string, className: string) => Promise<{
+            error: string;
+        } | {
+            name: string;
+            class: string;
+            location: string;
+        }[]>;
+        getAstTreeInFile: (file: string, className?: string | undefined) => Promise<import("./modules/codeparsers").ASTNode | {
+            error: string;
+        }>;
     };
     outputparsers: {
-        init: (output: any) => void;
+        parseJSON: (jsonString: string) => {
+            success: boolean;
+            parsed?: any;
+            error?: Error | undefined;
+        };
+        parseXML: (xmlString: string) => {
+            success: boolean;
+            parsed?: any;
+        };
+        parseCSV: (csvString: string) => {
+            success: boolean;
+            parsed?: any[] | undefined;
+            error?: Error | undefined;
+        };
+        parseText: (text: string) => {
+            success: boolean;
+            parsed: string[];
+        };
         parseErrors: (output: any) => string[];
         parseWarnings: (output: any) => string[];
     };
     project: {
-        getProjectSettings: (output: any) => void;
+        getProjectSettings: () => Promise<any>;
         getProjectPath: () => Promise<import("@codebolt/types").GetProjectPathResponse>;
         getRepoMap: (message: any) => Promise<import("@codebolt/types").GetProjectPathResponse>;
         runProject: () => void;

package/dist/index.js

@@ -66,6 +66,7 @@ class Codebolt {
         this.tools = tools_1.default;
         this.agent = agent_1.default;
         this.utils = utils_1.default;
+        console.log("Codebolt Agent initialized");
         websocket_1.default.initializeWebSocket();
         this.websocket = websocket_1.default.getWebsocket;
     }
@@ -101,6 +102,7 @@ class Codebolt {
         const waitForConnection = () => {
             if (websocket_1.default.messageManager) {
                 const handleUserMessage = async (response) => {
+                    console.log("Message received By Agent Library Starting Custom Agent Handler Logic", response);
                     if (response.type === "messageResponse") {
                         try {
                             const result = await handler(response);

package/dist/modules/agent.js

@@ -73,7 +73,7 @@ const codeboltAgent = {
             "type": "agentEvent",
             "action": "agentsDetail",
             "agentList": agentList
-        }, "listAgentsResponse");
+        }, "agentsDetailResponse");
     }
 };
 exports.default = codeboltAgent;

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;

package/dist/modules/codeutils.d.ts

@@ -1,4 +1,21 @@
 import { MatchProblemResponse, GetMatcherListTreeResponse, getMatchDetail } from '@codebolt/types';
+export interface JSTreeStructureItem {
+    type: string;
+    name: string;
+    startLine: number;
+    endLine: number;
+    startColumn: number;
+    endColumn: number;
+    nodeType: string;
+}
+export interface JSTreeResponse {
+    event: string;
+    payload?: {
+        filePath: string;
+        structure: JSTreeStructureItem[];
+    };
+    error?: string;
+}
 /**
  * A utility module for working with code.
  */
@@ -6,9 +23,9 @@ 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.
+     * @returns {Promise<JSTreeResponse>} A promise that resolves with the JS tree response.
      */
-    getJsTree: (filePath?: string) => Promise<any>;
+    getJsTree: (filePath?: string) => Promise<JSTreeResponse>;
     /**
      * Retrieves all files as Markdown.
      * @returns {Promise<string>} A promise that resolves with the Markdown content of all files.
@@ -16,12 +33,12 @@ declare const cbcodeutils: {
     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.
+     * @param {object} matcherDefinition - The definition of the matcher (name, pattern, language, etc.).
+     * @param {Array} problemPatterns - The patterns to match against (regex patterns with severity levels).
+     * @param {Array} problems - Optional list of pre-existing problems to include.
      * @returns {Promise<MatchProblemResponse>} A promise that resolves with the matching problem response.
      */
-    performMatch: (matcherDefinition: object, problemPatterns: any[], problems: any[]) => Promise<MatchProblemResponse>;
+    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.
@@ -29,7 +46,7 @@ declare const cbcodeutils: {
     getMatcherList: () => Promise<GetMatcherListTreeResponse>;
     /**
      * Retrieves details of a match.
-     * @param {string} matcher - The matcher to retrieve details for.
+     * @param {string} matcher - The matcher to retrieve details for (by name or identifier).
      * @returns {Promise<getMatchDetail>} A promise that resolves with the match detail response.
      */
     matchDetail: (matcher: string) => Promise<getMatchDetail>;