@codebolt/codeboltjs 1.0.0 → 1.0.1

package/.github/workflows/publish-to-npm.yml

@@ -0,0 +1,18 @@
+name: Publish Package to npmjs
+on:
+  release:
+    types: [published]
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      # Setup .npmrc file to publish to npm
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20.x'
+          registry-url: 'https://registry.npmjs.org'
+      - run: npm ci
+      - run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/License.md

@@ -0,0 +1,21 @@
+/**
+ * MIT License
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */

package/Readme.md

@@ -0,0 +1,27 @@
+# Codebolt Agent Library 
+
+This library provides a set of tools and utilities for creating Codebolt agents, enabling seamless integration with the Codebolt platform.
+
+## Features
+- Create and manage Codebolt agents
+- Interact with the Codebolt platform
+- Utilize Codebolt's powerful API
+
+## Installation
+
+```bash
+npm install @codebolt/codeboltjs
+```
+
+## Usage
+
+```javascript
+const codebolt = require('@codebolt/codeboltjs');
+
+// Your code here
+```
+
+## Documentation
+
+For More Documentation visit [Codebolt's Documentation](https://docs.codebolt.ai)
+

package/package.json

@@ -1,11 +1,32 @@
 {
   "name": "@codebolt/codeboltjs",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "",
   "keywords": [],
   "author": "",
+  "main": "src/index.ts",
   "license": "ISC",
+  "scripts": {
+    "build": "tsc",
+    "build:docs": "typedoc --plugin typedoc-plugin-missing-exports",
+    "build:jsondocs": "typedoc --plugin typedoc-plugin-missing-exports --json out.json --pretty",
+    "test": "jest fs.test.js"
+  },
   "dependencies": {
+    "typedoc-plugin-missing-exports": "^2.2.0",
     "ws": "^8.16.0"
+  },
+  "devDependencies": {
+    "@types/ws": "^8.5.10",
+    "ts-loader": "^9.5.1",
+    "typedoc": "^0.25.13",
+    "typescript": "^5.4.5",
+    "webpack": "^5.91.0",
+    "webpack-cli": "^5.1.4",
+    "jest": "^29.7.0",
+    "jest-serial-runner": "^1.2.1"
+  },
+  "jest": {
+    "testTimeout": 50000
   }
 }

package/src/index.ts

@@ -0,0 +1,92 @@
+import cbws from './modules/websocket';
+import cbfs from './modules/fs';
+import cbllm from './modules/llm';
+import cbterminal from './modules/terminal';
+import cbbrowser from './modules/browser';
+import cbchat from './modules/chat';
+import cbcodeutils from './modules/codeutils';
+import cbdocutils from './modules/docutils';
+import cbcrawler from './modules/crawler';
+import cbsearch from './modules/search';
+import cbknowledge from './modules/knowledge';
+import cbrag from './modules/rag';
+import cbcodeparsers from './modules/codeparsers';
+import cboutputparsers from './modules/outputparsers';
+import cbproject from './modules/project';
+import git from './modules/git';
+import dbmemory from './modules/dbmemory';
+import WebSocket from 'ws';
+
+/**
+ * @class Codebolt
+ * @description This class provides a unified interface to interact with various modules.
+ */
+class Codebolt {
+
+    /**
+     * @constructor
+     * @description Initializes the websocket connection.
+     */
+    constructor(){
+        this.websocket = cbws.getWebsocket;
+    }
+
+    /**
+     * @method waitForConnection
+     * @description Waits for the WebSocket connection to open.
+     * @returns {Promise<void>} A promise that resolves when the WebSocket connection is open.
+     */
+     async waitForConnection() {
+        return new Promise<void>((resolve, reject) => {
+            if (!this.websocket) {
+                reject(new Error('WebSocket is not initialized'));
+                return;
+            }
+    
+            if (this.websocket.readyState === WebSocket.OPEN) {
+                resolve();
+                return;
+            }
+    
+            this.websocket.addEventListener('open', () => {
+                resolve();
+            });
+    
+            this.websocket.addEventListener('error', (error) => {
+                reject(error);
+            });
+        });
+    }
+
+    /**
+     * @method start_browser
+     * @description Starts a new browser page.
+     * @param {string} objective - The objective of the browser session.
+     * @param {string} url - The URL to navigate to.
+     * @param {string} previous_command - The previous command executed.
+     * @param {string} browser_content - The content of the browser.
+     */
+    start_browser(objective:string, url:string, previous_command:string, browser_content:string) {
+        cbbrowser.newPage();
+    }
+
+    websocket: WebSocket | null = null;
+    fs = cbfs;
+    git=git;
+    llm = cbllm;
+    browser = cbbrowser;
+    chat = cbchat;
+    terminal = cbterminal;
+    codeutils = cbcodeutils;
+    docutils = cbdocutils;
+    crawler = cbcrawler;
+    search = cbsearch;
+    knowledge = cbknowledge;
+    rag = cbrag;
+    codeparsers = cbcodeparsers;
+    outputparsers = cboutputparsers;
+    project = cbproject;
+    dbmemory = dbmemory;
+}
+
+export default new Codebolt();

package/src/modules/browser.ts

@@ -0,0 +1,266 @@
+import cbws from './websocket';
+
+/**
+ * A module for interacting with a browser through WebSockets.
+ */
+const cbbrowser = {
+
+    /**
+     * Opens a new page in the browser.
+     */
+    newPage: () => {
+        cbws.getWebsocket.send(JSON.stringify({
+            "type": "browserEvent",
+            action: 'newPage'
+        }));
+    },
+
+    /**
+     * Retrieves the current URL of the browser's active page.
+     * @returns {Promise<any>} A promise that resolves with the URL.
+     */
+    getUrl: () => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "browserEvent",
+                action: 'getUrl'
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.event === "getUrlResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+
+    /**
+     * Navigates to a specified URL.
+     * @param {string} url - The URL to navigate to.
+     * @returns {Promise<any>} A promise that resolves when navigation is complete.
+     */
+    goToPage: (url: string) => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "browserEvent",
+                action: 'goToPage',
+                url
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.event === "goToPageResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+
+    /**
+     * Takes a screenshot of the current page.
+     */
+    screenshot: () => {
+        cbws.getWebsocket.send(JSON.stringify({
+            "type": "browserEvent",
+            action: 'screenshot'
+        }));
+    },
+
+    /**
+     * Retrieves the HTML content of the current page.
+     * @returns {Promise<string>} A promise that resolves with the HTML content.
+     */
+    getHTML: () => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "browserEvent",
+                action: 'getHTML'
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.event === "htmlReceived") {
+                    resolve(response.htmlResponse);
+                }
+            });
+        });
+    },
+
+    /**
+     * Retrieves the Markdown content of the current page.
+     * @returns {Promise<any>} A promise that resolves with the Markdown content.
+     */
+    getMarkdown: () => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "browserEvent",
+                action: 'getMarkdown'
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.event === "getMarkdownResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+
+    /**
+     * Retrieves the PDF content of the current page.
+     */
+    getPDF: () => {
+        cbws.getWebsocket.send(JSON.stringify({
+            "type": "browserEvent",
+            action: 'getPDF'
+        }));
+    },
+
+    /**
+     * Converts the PDF content of the current page to text.
+     */
+    pdfToText: () => {
+        cbws.getWebsocket.send(JSON.stringify({
+            "type": "browserEvent",
+            action: 'pdfToText'
+        }));
+    },
+
+    /**
+     * Retrieves the content of the current page.
+     */
+    getContent: () => {
+        cbws.getWebsocket.send(JSON.stringify({
+            "type": "browserEvent",
+            action: 'getContent'
+        }));
+    },
+
+    /**
+     * Extracts text from the current page.
+     */
+    extractText: () => {
+        cbws.getWebsocket.send(JSON.stringify({
+            "type": "browserEvent",
+            action: 'extractText'
+        }));
+    },
+
+    /**
+     * Closes the current page.
+     */
+    close: () => {
+        cbws.getWebsocket.send(JSON.stringify({
+            "type": "browserEvent",
+            action: 'close'
+        }));
+    },
+
+    /**
+     * Scrolls the current page in a specified direction by a specified number of pixels.
+     * @param {string} direction - The direction to scroll.
+     * @param {string} pixels - The number of pixels to scroll.
+     * @returns {Promise<any>} A promise that resolves when the scroll action is complete.
+     */
+    scroll: (direction: string, pixels: string) => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "browserEvent",
+                action: 'scroll',
+                direction,
+                pixels
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.event === "scrollResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+
+    /**
+     * Types text into a specified element on the page.
+     * @param {string} elementid - The ID of the element to type into.
+     * @param {string} text - The text to type.
+     * @returns {Promise<any>} A promise that resolves when the typing action is complete.
+     */
+    type: (elementid: string, text: string) => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "browserEvent",
+                action: 'type',
+                text,
+                elementid
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.event === "typeResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+
+    /**
+     * Clicks on a specified element on the page.
+     * @param {string} elementid - The ID of the element to click.
+     * @returns {Promise<any>} A promise that resolves when the click action is complete.
+     */
+    click: (elementid: string) => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "browserEvent",
+                action: 'click',
+                elementid
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.event === "clickResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+
+    /**
+     * Simulates the Enter key press on the current page.
+     * @returns {Promise<any>} A promise that resolves when the Enter action is complete.
+     */
+    enter: () => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "browserEvent",
+                action: 'enter'
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.event === "EnterResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+
+    /**
+     * Performs a search on the current page using a specified query.
+     * @param {string} elementid - The ID of the element to perform the search in.
+     * @param {string} query - The search query.
+     * @returns {Promise<any>} A promise that resolves with the search results.
+     */
+    search: (elementid: string, query: string) => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "browserEvent",
+                action: 'search',
+                elementid,
+                query
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.event === "searchResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    }
+}
+
+export default cbbrowser;

package/src/modules/chat.ts

@@ -0,0 +1,82 @@
+// chat.ts
+import cbws from './websocket';
+import { EventEmitter } from 'events';
+
+/**
+ * CustomEventEmitter class that extends the Node.js EventEmitter class.
+ */
+class CustomEventEmitter extends EventEmitter {}
+
+/**
+ * Chat module to interact with the WebSocket server.
+ */
+const cbchat = {
+    eventEmitter: new CustomEventEmitter(),
+
+    /**
+     * Sends a message through the WebSocket connection.
+     * @param {string} message - The message to be sent.
+     */
+    sendMessage(message: string) {
+        console.log(message);
+        cbws.getWebsocket.send(JSON.stringify({
+            "type": "sendMessage",
+            "message": message
+        }));
+    },
+
+    /**
+     * Waits for a reply to a sent message.
+     * @param {string} message - The message for which a reply is expected.
+     * @returns {Promise<any>} A promise that resolves with the reply.
+     */
+    waitforReply(message: string): Promise<any> {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "waitforReply",
+                "message": message
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "messageResponse") {
+                    resolve(response); // Resolve the Promise with the response data
+                } 
+            });
+        });
+    },
+
+    /**
+     * Notifies the server that a process has started and sets up an event listener for stopProcessClicked events.
+     * @returns An object containing the event emitter and a stopProcess method.
+     */
+    processStarted() {
+        // Send the process started message
+        cbws.getWebsocket.send(JSON.stringify({
+            "type": "processStarted"
+        }));
+        // Register event listener for WebSocket messages
+        cbws.getWebsocket.on('message', (data: string) => {
+            const message = JSON.parse(data);
+            console.log("Received message:", message);
+            if(message.type==='stopProcessClicked')
+
+            // Emit a custom event based on the message type
+            this.eventEmitter.emit("stopProcessClicked", message);
+        });
+
+        // Return an object that includes the event emitter and the stopProcess method
+        return {
+            event: this.eventEmitter,
+            stopProcess: () => {
+                // Implement the logic to stop the process here
+                console.log("Stopping process...");
+                // For example, you might want to send a specific message to the server to stop the process
+                cbws.getWebsocket.send(JSON.stringify({
+                    "type": "processStoped"
+                }));
+            }
+        };
+    }
+};
+
+export default cbchat;

package/src/modules/codeparsers.ts

@@ -0,0 +1,30 @@
+/**
+ * A collection of code parser functions.
+ */
+const cbcodeparsers = {
+    /**
+     * Retrieves the classes in a given file.
+     * @param file The file to parse for classes.
+     */
+    getClassesInFile: (file: any) => {
+        console.log('Code parsers initialized');
+    },
+    /**
+     * Retrieves the functions in a given class within a file.
+     * @param file The file containing the class.
+     * @param className The name of the class to parse for functions.
+     */
+    getFunctionsinClass: (file: any, className: any) => {
+        console.log('Code parsers initialized');
+    },
+    /**
+     * Generates an Abstract Syntax Tree (AST) for a given file.
+     * @param file The file to generate an AST for.
+     * @param className The name of the class to focus the AST generation on.
+     */
+    getAstTreeInFile: (file: any, className: any) => {
+        
+    }
+};
+
+export default cbcodeparsers;

package/src/modules/codeutils.ts

@@ -0,0 +1,19 @@
+/**
+ * A utility module for working with code.
+ */
+const cbcodeutils = {
+    /**
+     * Asynchronously generates a code tree from the provided source code.
+     * @param {any} fileName - The name of the file.
+     * @param {any} source - The source code to generate the tree from.
+     * @param {any} filePath - The file path where the source code is located.
+     * @returns {Promise<any>} A promise that resolves with the code tree.
+     */
+    getCodeTree: (fileName: any, source: any, filePath: any): Promise<any> => {
+        return new Promise((resolve, reject) => {
+            // Implementation would go here
+        });
+    }
+};
+
+export default cbcodeutils;