@codebolt/codeboltjs 2.0.4 → 2.0.6

package/dist/core/messageManager.d.ts

@@ -0,0 +1,47 @@
+/// <reference types="node" />
+import WebSocket from 'ws';
+import { EventEmitter } from 'events';
+export interface PendingRequest {
+    resolve: (value: any) => void;
+    reject: (reason?: any) => void;
+    messageTypes: string[];
+    requestId?: string;
+}
+/**
+ * Centralized message manager for handling WebSocket communications
+ */
+export declare class MessageManager extends EventEmitter {
+    pendingRequests: Map<string, PendingRequest>;
+    websocket: WebSocket | null;
+    requestCounter: number;
+    /**
+     * Initialize the message manager with a WebSocket instance
+     */
+    initialize(websocket: WebSocket): void;
+    /**
+     * Setup the centralized message listener
+     */
+    setupMessageListener(): void;
+    /**
+     * Handle incoming messages and resolve pending requests
+     */
+    handleMessage(response: any): void;
+    /**
+     * Send a message and wait for a specific response type
+     */
+    sendAndWaitForResponse<T = any>(message: any, expectedResponseType: string, timeout?: number): Promise<T>;
+    /**
+     * Send a message without waiting for response
+     */
+    send(message: any): void;
+    /**
+     * Get the WebSocket instance
+     */
+    getWebSocket(): WebSocket | null;
+    /**
+     * Clean up all pending requests
+     */
+    cleanup(): void;
+}
+declare const _default: MessageManager;
+export default _default;

package/dist/core/messageManager.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageManager = void 0;
+const events_1 = require("events");
+/**
+ * Centralized message manager for handling WebSocket communications
+ */
+class MessageManager extends events_1.EventEmitter {
+    constructor() {
+        super(...arguments);
+        this.pendingRequests = new Map();
+        this.websocket = null;
+        this.requestCounter = 0;
+    }
+    /**
+     * Initialize the message manager with a WebSocket instance
+     */
+    initialize(websocket) {
+        this.websocket = websocket;
+        this.setupMessageListener();
+    }
+    /**
+     * Setup the centralized message listener
+     */
+    setupMessageListener() {
+        if (!this.websocket)
+            return;
+        this.websocket.on('message', (data) => {
+            try {
+                const response = JSON.parse(data.toString());
+                this.handleMessage(response);
+            }
+            catch (error) {
+                console.error('Error parsing WebSocket message:', error);
+            }
+        });
+    }
+    /**
+     * Handle incoming messages and resolve pending requests
+     */
+    handleMessage(response) {
+        const { type, requestId } = response;
+        // Handle requests with specific requestId
+        if (requestId && this.pendingRequests.has(requestId)) {
+            const request = this.pendingRequests.get(requestId);
+            this.pendingRequests.delete(requestId);
+            request.resolve(response);
+            return;
+        }
+        // Handle requests by message type
+        for (const [id, request] of this.pendingRequests.entries()) {
+            if (request.messageTypes.includes(type)) {
+                this.pendingRequests.delete(id);
+                request.resolve(response);
+                return;
+            }
+        }
+        // Emit the message for any other listeners (like onUserMessage)
+        this.emit('message', response);
+    }
+    /**
+     * Send a message and wait for a specific response type
+     */
+    sendAndWaitForResponse(message, expectedResponseType, timeout = 30000) {
+        return new Promise((resolve, reject) => {
+            if (!this.websocket) {
+                reject(new Error('WebSocket is not initialized'));
+                return;
+            }
+            const requestId = `req_${++this.requestCounter}_${Date.now()}`;
+            // Add requestId to the message if it doesn't have one
+            const messageWithId = { ...message, requestId };
+            // Parse multiple message types separated by pipe
+            const messageTypes = expectedResponseType.split('|').map(type => type.trim());
+            // Store the pending request
+            this.pendingRequests.set(requestId, {
+                resolve,
+                reject,
+                messageTypes,
+                requestId
+            });
+            // Set timeout
+            const timeoutId = setTimeout(() => {
+                if (this.pendingRequests.has(requestId)) {
+                    this.pendingRequests.delete(requestId);
+                    reject(new Error(`Request timeout after ${timeout}ms for message types: ${expectedResponseType}`));
+                }
+            }, timeout);
+            // Override resolve to clear timeout
+            const originalResolve = resolve;
+            const wrappedResolve = (value) => {
+                clearTimeout(timeoutId);
+                originalResolve(value);
+            };
+            // Update the stored request with wrapped resolve
+            const request = this.pendingRequests.get(requestId);
+            request.resolve = wrappedResolve;
+            // Send the message
+            this.websocket.send(JSON.stringify(messageWithId));
+        });
+    }
+    /**
+     * Send a message without waiting for response
+     */
+    send(message) {
+        if (!this.websocket) {
+            throw new Error('WebSocket is not initialized');
+        }
+        this.websocket.send(JSON.stringify(message));
+    }
+    /**
+     * Get the WebSocket instance
+     */
+    getWebSocket() {
+        return this.websocket;
+    }
+    /**
+     * Clean up all pending requests
+     */
+    cleanup() {
+        for (const [id, request] of this.pendingRequests.entries()) {
+            request.reject(new Error('WebSocket connection closed'));
+        }
+        this.pendingRequests.clear();
+    }
+}
+exports.MessageManager = MessageManager;
+exports.default = new MessageManager();

package/dist/{modules → core}/websocket.d.ts

@@ -1,4 +1,5 @@
 import WebSocket from 'ws';
+import { MessageManager } from './messageManager';
 /**
  * Class representing a WebSocket connection.
  */
@@ -22,6 +23,10 @@ declare class cbws {
      * @throws {Error} If the WebSocket is not open.
      */
     get getWebsocket(): WebSocket;
+    /**
+     * Get the message manager instance
+     */
+    get messageManager(): MessageManager;
 }
 declare const _default: cbws;
 export default _default;

package/dist/{modules → core}/websocket.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const ws_1 = __importDefault(require("ws"));
 const fs_1 = __importDefault(require("fs"));
 const js_yaml_1 = __importDefault(require("js-yaml"));
+const messageManager_1 = __importDefault(require("./messageManager"));
 /**
  * Class representing a WebSocket connection.
  */
@@ -54,22 +55,20 @@ 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);
             });
             this.websocket.on('open', () => {
-                // if (this.websocket) {
-                //     this.websocket.send(JSON.stringify({
-                //         "type": "sendMessage",
-                //         "message": initialMessage
-                //     }));
-                //     resolve(this.websocket);
-                // }
+                // Initialize the message manager with this websocket
+                messageManager_1.default.initialize(this.websocket);
+                resolve(this.websocket);
             });
-            this.websocket.on('message', (data) => {
-                // Handle incoming WebSocket messages here.
+            this.websocket.on('close', () => {
+                // Clean up pending requests when connection closes
+                messageManager_1.default.cleanup();
             });
         });
     }
@@ -86,5 +85,11 @@ class cbws {
             return this.websocket;
         }
     }
+    /**
+     * Get the message manager instance
+     */
+    get messageManager() {
+        return messageManager_1.default;
+    }
 }
 exports.default = new cbws();

package/dist/index.d.ts

@@ -34,29 +34,40 @@ declare class Codebolt {
             success: boolean;
             result: any;
         }>;
-        writeToFile: (relPath: string, newContent: string) => Promise<unknown>;
+        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>;
     };
     browser: {
-        newPage: () => Promise<unknown>;
+        newPage: () => Promise<any>;
         getUrl: () => Promise<import("@codebolt/types").UrlResponse>;
         goToPage: (url: string) => Promise<import("@codebolt/types").GoToPageResponse>;
-        screenshot: () => Promise<unknown>;
+        screenshot: () => Promise<any>;
         getHTML: () => Promise<import("@codebolt/types").HtmlReceived>;
         getMarkdown: () => Promise<import("@codebolt/types").GetMarkdownResponse>;
         getPDF: () => void;
@@ -66,16 +77,33 @@ declare class Codebolt {
         getBrowserInfo: () => Promise<any>;
         extractText: () => Promise<import("@codebolt/types").ExtractTextResponse>;
         close: () => void;
-        scroll: (direction: string, pixels: string) => Promise<unknown>;
-        type: (elementid: string, text: string) => Promise<unknown>;
-        click: (elementid: string) => Promise<unknown>;
-        enter: () => Promise<unknown>;
-        search: (elementid: string, query: string) => Promise<unknown>;
+        scroll: (direction: string, pixels: string) => Promise<any>;
+        type: (elementid: string, text: string) => Promise<any>;
+        click: (elementid: string) => Promise<any>;
+        enter: () => Promise<any>;
+        search: (elementid: string, query: string) => Promise<any>;
     };
     chat: {
         getChatHistory: () => Promise<import("@codebolt/types").ChatMessage[]>;
         setRequestHandler: (handler: (request: any, response: (data: any) => void) => void | Promise<void>) => void;
-        onActionMessage: () => {
+        sendMessage: (message: string, payload: any) => void;
+        waitforReply: (message: string) => Promise<import("@codebolt/types").UserMessage>;
+        processStarted: (onStopClicked?: ((message: any) => void) | undefined) => {
+            stopProcess: () => void;
+            cleanup: () => void;
+        } | {
+            stopProcess: () => void;
+            cleanup?: undefined;
+        };
+        stopProcess: () => void;
+        processFinished: () => void;
+        sendConfirmationRequest: (confirmationMessage: string, buttons?: string[], withFeedback?: boolean) => Promise<string>;
+        askQuestion: (question: string, buttons?: string[], withFeedback?: boolean) => Promise<string>;
+        sendNotificationEvent: (notificationMessage: string, type: "debug" | "git" | "planner" | "browser" | "editor" | "terminal" | "preview") => void;
+    };
+    terminal: {
+        eventEmitter: {
+            cleanup?: (() => void) | undefined;
             [EventEmitter.captureRejectionSymbol]?<K>(error: Error, event: string | symbol, ...args: any[]): void;
             addListener<K_1>(eventName: string | symbol, listener: (...args: any[]) => void): any;
             on<K_2>(eventName: string | symbol, listener: (...args: any[]) => void): any;
@@ -93,37 +121,11 @@ declare class Codebolt {
             prependOnceListener<K_11>(eventName: string | symbol, listener: (...args: any[]) => void): any;
             eventNames(): (string | symbol)[];
         };
-        sendMessage: (message: string, payload: any) => void;
-        waitforReply: (message: string) => Promise<import("@codebolt/types").UserMessage>;
-        processStarted: () => {
-            event: {
-                [EventEmitter.captureRejectionSymbol]?<K>(error: Error, event: string | symbol, ...args: any[]): void;
-                addListener<K_1>(eventName: string | symbol, listener: (...args: any[]) => void): any;
-                on<K_2>(eventName: string | symbol, listener: (...args: any[]) => void): any;
-                once<K_3>(eventName: string | symbol, listener: (...args: any[]) => void): any;
-                removeListener<K_4>(eventName: string | symbol, listener: (...args: any[]) => void): any;
-                off<K_5>(eventName: string | symbol, listener: (...args: any[]) => void): any;
-                removeAllListeners(eventName?: string | symbol | undefined): any;
-                setMaxListeners(n: number): any;
-                getMaxListeners(): number;
-                listeners<K_6>(eventName: string | symbol): Function[];
-                rawListeners<K_7>(eventName: string | symbol): Function[];
-                emit<K_8>(eventName: string | symbol, ...args: any[]): boolean;
-                listenerCount<K_9>(eventName: string | symbol, listener?: Function | undefined): number;
-                prependListener<K_10>(eventName: string | symbol, listener: (...args: any[]) => void): any;
-                prependOnceListener<K_11>(eventName: string | symbol, listener: (...args: any[]) => void): any;
-                eventNames(): (string | symbol)[];
-            };
-            stopProcess: () => void;
-        };
-        stopProcess: () => void;
-        processFinished: () => void;
-        sendConfirmationRequest: (confirmationMessage: string, buttons?: string[], withFeedback?: boolean) => Promise<string>;
-        askQuestion: (question: string, buttons?: string[], withFeedback?: boolean) => Promise<string>;
-        sendNotificationEvent: (notificationMessage: string, type: "debug" | "git" | "planner" | "browser" | "editor" | "terminal" | "preview") => void;
-    };
-    terminal: {
-        eventEmitter: {
+        executeCommand: (command: string, returnEmptyStringOnSuccess?: boolean) => Promise<any>;
+        executeCommandRunUntilError: (command: string, executeInMain?: boolean) => Promise<import("@codebolt/types").CommandError>;
+        sendManualInterrupt(): Promise<import("@codebolt/types").TerminalInterruptResponse>;
+        executeCommandWithStream(command: string, executeInMain?: boolean): {
+            cleanup?: (() => void) | undefined;
             [EventEmitter.captureRejectionSymbol]?<K>(error: Error, event: string | symbol, ...args: any[]): void;
             addListener<K_1>(eventName: string | symbol, listener: (...args: any[]) => void): any;
             on<K_2>(eventName: string | symbol, listener: (...args: any[]) => void): any;
@@ -141,30 +143,23 @@ declare class Codebolt {
             prependOnceListener<K_11>(eventName: string | symbol, listener: (...args: any[]) => void): any;
             eventNames(): (string | symbol)[];
         };
-        executeCommand: (command: string, returnEmptyStringOnSuccess?: boolean) => Promise<unknown>;
-        executeCommandRunUntilError: (command: string, executeInMain?: boolean) => Promise<import("@codebolt/types").CommandError>;
-        sendManualInterrupt(): Promise<import("@codebolt/types").TerminalInterruptResponse>;
-        executeCommandWithStream(command: string, executeInMain?: boolean): EventEmitter<[never]>;
     };
     codeutils: {
-        getJsTree: (filePath?: string | undefined) => Promise<unknown>;
+        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;
         screenshot: () => void;
         goToPage: (url: string) => void;
         scroll: (direction: string) => void;
-        click: (id: string) => Promise<unknown>;
-        type: (id: string, text: string) => Promise<unknown>;
-        enter: () => void;
-        crawl: (query: string) => Promise<unknown>;
+        click: (id: string) => Promise<any>;
     };
     search: {
         init: (engine?: string) => void;
@@ -178,21 +173,51 @@ 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;
-        getEditorFileStatus: () => Promise<unknown>;
+        getEditorFileStatus: () => Promise<any>;
     };
     dbmemory: {
         addKnowledge: (key: string, value: any) => Promise<import("@codebolt/types").MemorySetResponse>;
@@ -241,7 +266,6 @@ declare class Codebolt {
         getEnabledToolBoxes: () => Promise<any>;
         getLocalToolBoxes: () => Promise<any>;
         getMentionedToolBoxes: (userMessage: import("./utils").UserMessage) => Promise<any>;
-        getAvailableToolBoxes: () => Promise<any>;
         searchAvailableToolBoxes: (query: string) => Promise<any>;
         listToolsFromToolBoxes: (toolBoxes: string[]) => Promise<any>;
         configureToolBox: (name: string, config: any) => Promise<any>;
@@ -260,6 +284,12 @@ declare class Codebolt {
     utils: {
         editFileAndApplyDiff: (filePath: string, diff: string, diffIdentifier: string, prompt: string, applyModel?: string | undefined) => Promise<any>;
     };
+    /**
+     * Sets up a listener for incoming messages with a direct handler function.
+     * @param {Function} handler - The handler function to call when a message is received.
+     * @returns {void}
+     */
+    onMessage(handler: (userMessage: any) => void | Promise<void> | any | Promise<any>): void;
 }
-declare const _default: Codebolt;
-export default _default;
+declare const codebolt: Codebolt;
+export default codebolt;

package/dist/index.js

@@ -3,7 +3,7 @@ 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("./modules/websocket"));
+const websocket_1 = __importDefault(require("./core/websocket"));
 const fs_1 = __importDefault(require("./modules/fs"));
 const llm_1 = __importDefault(require("./modules/llm"));
 const terminal_1 = __importDefault(require("./modules/terminal"));
@@ -29,7 +29,7 @@ const ws_1 = __importDefault(require("ws"));
 const history_1 = require("./modules/history");
 const tools_1 = __importDefault(require("./modules/tools"));
 const agent_1 = __importDefault(require("./modules/agent"));
-const editFile_1 = __importDefault(require("./utils/editFile"));
+const utils_1 = __importDefault(require("./modules/utils"));
 /**
  * @class Codebolt
  * @description This class provides a unified interface to interact with various modules.
@@ -65,7 +65,8 @@ class Codebolt {
         this.chatSummary = history_1.chatSummary;
         this.tools = tools_1.default;
         this.agent = agent_1.default;
-        this.utils = editFile_1.default;
+        this.utils = utils_1.default;
+        console.log("Codebolt Agent initialized");
         websocket_1.default.initializeWebSocket();
         this.websocket = websocket_1.default.getWebsocket;
     }
@@ -92,5 +93,51 @@ class Codebolt {
             });
         });
     }
+    /**
+     * Sets up a listener for incoming messages with a direct handler function.
+     * @param {Function} handler - The handler function to call when a message is received.
+     * @returns {void}
+     */
+    onMessage(handler) {
+        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);
+                            // Send processStoped with optional message
+                            const message = {
+                                "type": "processStoped"
+                            };
+                            // If handler returned data, include it as message
+                            if (result !== undefined && result !== null) {
+                                message.message = result;
+                            }
+                            websocket_1.default.messageManager.send(message);
+                        }
+                        catch (error) {
+                            console.error('Error in user message handler:', error);
+                            // Send processStoped even if there's an error
+                            websocket_1.default.messageManager.send({
+                                "type": "processStoped",
+                                "error": error instanceof Error ? error.message : "Unknown error occurred"
+                            });
+                        }
+                    }
+                };
+                websocket_1.default.messageManager.on('message', handleUserMessage);
+            }
+            else {
+                setTimeout(waitForConnection, 100);
+            }
+        };
+        waitForConnection();
+    }
 }
-exports.default = new Codebolt();
+const codebolt = new Codebolt();
+// For ES6 modules (import)
+exports.default = codebolt;
+// For CommonJS compatibility (require)
+module.exports = codebolt;
+module.exports.default = codebolt;