@codebolt/codeboltjs 2.0.2 → 2.0.4

package/src/modules/tools.ts

@@ -1,254 +0,0 @@
-import { UserMessage } from '../utils';
-import cbws from './websocket';
-
-/**
- * Object containing methods for interacting with Codebolt MCP (Model Context Protocol) tools.
- * Provides functionality to discover, list, and execute tools.
- */
-const codeboltMCP = {
-    /**
-     * Gets the list of currently enabled toolboxes.
-     * 
-     * @returns Promise with the enabled toolboxes data
-     */
-    getEnabledToolBoxes: (): Promise<any> => {
-        return new Promise((resolve, reject) => {
-            cbws.getWebsocket.send(JSON.stringify({
-                "type": "codebolttools",
-                "action": "getEnabledToolBoxes"
-            }));
-            cbws.getWebsocket.on('message', (data: string) => {
-                try {
-                    const response = JSON.parse(data);
-                    if (response.type === "getEnabledToolBoxesResponse") {
-                        resolve(response.data);
-                    }
-                } catch (error) {
-                    reject(new Error("Failed to parse response"));
-                }
-            });
-            cbws.getWebsocket.on('error', (error: Error) => {
-                reject(error);
-            });
-        });
-    },
-
-    /**
-     * Gets the list of locally available toolboxes.
-     * 
-     * @returns Promise with the local toolboxes data
-     */
-    getLocalToolBoxes: (): Promise<any> => {
-        return new Promise((resolve, reject) => {
-            cbws.getWebsocket.send(JSON.stringify({
-                "type": "codebolttools",
-                "action": "getLocalToolBoxes"
-            }));
-            cbws.getWebsocket.on('message', (data: string) => {
-                try {
-                    const response = JSON.parse(data);
-                    if (response.type === "getLocalToolBoxesResponse") {
-                        resolve(response.data);
-                    }
-                } catch (error) {
-                    reject(new Error("Failed to parse response"));
-                }
-            });
-            cbws.getWebsocket.on('error', (error: Error) => {
-                reject(error);
-            });
-        });
-    },
-
-    /**
-     * Gets toolboxes mentioned in a user message.
-     * 
-     * @param userMessage - The user message to extract mentions from
-     * @returns Promise with the mentioned toolboxes
-     */
-    getMentionedToolBoxes: (userMessage: UserMessage): Promise<any> => {
-        return new Promise((resolve, reject) => {
-            resolve(userMessage.mentionedMCPs);
-        });
-    },
-
-    /**
-     * Gets all available toolboxes.
-     * 
-     * @returns Promise with all available toolboxes data
-     */
-    getAvailableToolBoxes: (): Promise<any> => {
-        return new Promise((resolve, reject) => {
-            cbws.getWebsocket.send(JSON.stringify({
-                "type": "codebolttools",
-                "action": "getAvailableToolBoxes"
-            }));
-            cbws.getWebsocket.on('message', (data: string) => {
-                try {
-                    const response = JSON.parse(data);
-                    if (response.type === "getAvailableToolBoxesResponse") {
-                        resolve(response.data);
-                    }
-                } catch (error) {
-                    reject(new Error("Failed to parse response"));
-                }
-            });
-            cbws.getWebsocket.on('error', (error: Error) => {
-                reject(error);
-            });
-        });
-    },
-
-    /**
-     * Searches for available toolboxes matching a query.
-     * 
-     * @param query - The search query string
-     * @returns Promise with matching toolboxes data
-     */
-    searchAvailableToolBoxes: (query: string): Promise<any> => {
-        return new Promise((resolve, reject) => {
-            cbws.getWebsocket.send(JSON.stringify({
-                "type": "codebolttools",
-                "action": "searchAvailableToolBoxes",
-                "query": query
-            }));
-            cbws.getWebsocket.on('message', (data: string) => {
-                try {
-                    const response = JSON.parse(data);
-                    if (response.type === "searchAvailableToolBoxesResponse") {
-                        resolve(response.data);
-                    }
-                } catch (error) {
-                    reject(new Error("Failed to parse response"));
-                }
-            });
-            cbws.getWebsocket.on('error', (error: Error) => {
-                reject(error);
-            });
-        });
-    },
-
-    /**
-     * Lists all tools from the specified toolboxes.
-     * 
-     * @param toolBoxes - Array of toolbox names to list tools from
-     * @returns Promise with tools from the specified toolboxes
-     */
-    listToolsFromToolBoxes: (toolBoxes: string[]): Promise<any> => {
-        return new Promise((resolve, reject) => {
-            cbws.getWebsocket.send(JSON.stringify({
-                "type": "codebolttools",
-                "action": "listToolsFromToolBoxes",
-                "toolBoxes": toolBoxes
-            }));
-            cbws.getWebsocket.on('message', (data: string) => {
-                try {
-                    const response = JSON.parse(data);
-                    if (response.type === "listToolsFromToolBoxesResponse") {
-                        resolve(response.data);
-                    }
-                } catch (error) {
-                    reject(new Error("Failed to parse response"));
-                }
-            });
-            cbws.getWebsocket.on('error', (error: Error) => {
-                reject(error);
-            });
-        });
-
-    },
-
-    /**
-     * Configures a specific toolbox with provided configuration.
-     * 
-     * @param name - The name of the toolbox to configure
-     * @param config - Configuration object for the toolbox
-     * @returns Promise with the configuration result
-     */
-    configureToolBox: (name: string, config: any): Promise<any> => {
-        return new Promise((resolve, reject) => {
-            cbws.getWebsocket.send(JSON.stringify({
-                "type": "codebolttools",
-                "action": "configureToolBox",
-                "mcpName": name,
-                "config": config
-            }));
-            cbws.getWebsocket.on('message', (data: string) => {
-                try {
-                    const response = JSON.parse(data);
-                    if (response.type === "configureToolBoxResponse") {
-                        resolve(response.data);
-                    }
-                } catch (error) {
-                    reject(new Error("Failed to parse response"));
-                }
-            });
-            cbws.getWebsocket.on('error', (error: Error) => {
-                reject(error);
-            });
-        });
-    },
-
-    /**
-     * Gets detailed information about specific tools.
-     * 
-     * @param tools - Array of toolbox and tool name pairs
-     * @returns Promise with detailed information about the tools
-     */
-    getTools: (tools: { toolbox: string, toolName: string }[]): Promise<any[]> => {
-        return new Promise((resolve, reject) => {
-            cbws.getWebsocket.send(JSON.stringify({
-                "type": "codebolttools",
-                "action": "getTools",
-                "toolboxes": tools
-            }));
-            cbws.getWebsocket.on('message', (data: string) => {
-                try {
-                    const response = JSON.parse(data);
-                    if (response.type === "getToolsResponse") {
-                        resolve(response.data);
-                    }
-                } catch (error) {
-                    reject(new Error("Failed to parse response"));
-                }
-            });
-            cbws.getWebsocket.on('error', (error: Error) => {
-                reject(error);
-            });
-        });
-    },
-
-    /**
-     * Executes a specific tool with provided parameters.
-     * 
-     * @param toolbox - The name of the toolbox containing the tool
-     * @param toolName - The name of the tool to execute
-     * @param params - Parameters to pass to the tool
-     * @returns Promise with the execution result
-     */
-    executeTool: (toolbox: string, toolName: string, params: any): Promise<any> => {
-        return new Promise((resolve, reject) => {
-            cbws.getWebsocket.send(JSON.stringify({
-                "type": "codebolttools",
-                "action": "executeTool",
-                "toolName": `${toolbox}--${toolName}`,
-                "params": params
-            }));
-            cbws.getWebsocket.on('message', (data: string) => {
-                try {
-                    const response = JSON.parse(data);
-                    if (response.type === "executeToolResponse") {
-                        resolve(response.data);
-                    }
-                } catch (error) {
-                    reject(new Error("Failed to parse response"));
-                }
-            });
-            cbws.getWebsocket.on('error', (error: Error) => {
-                reject(error);
-            });
-        });
-    },
-}
-
-export default codeboltMCP;

package/src/modules/vectordb.ts

@@ -1,102 +0,0 @@
-import cbws from './websocket';
-import { AddVectorItemResponse,GetVectorResponse,QueryVectorItemResponse } from '@codebolt/types';
-const VectorDB = {
-    /**
-     * Retrieves a vector from the vector database based on the provided key.
-     *
-     * @param {string} key - The key of the vector to retrieve.
-     * @returns {Promise<GetVectorResponse>} A promise that resolves with the retrieved vector.
-     */
-    getVector: async (key: string): Promise<GetVectorResponse> => {
-        return new Promise((resolve, reject) => {
-            cbws.getWebsocket.send(JSON.stringify({
-                "type":"vectordbEvent",
-                "action": "getVector",
-                "message": {
-                    item: key
-                },
-            }));
-            cbws.getWebsocket.on('message', (data: string) => {
-                const response = JSON.parse(data);
-                if (response.type === "getVectorResponse") {
-                    resolve(response);
-                }
-            });
-        });
-    },
-
-    /**
-     * Adds a new vector item to the vector database.
-     *
-
-     * @param {any} item - The item to add to the vector.
-     * @returns {Promise<AddVectorItemResponse>} A promise that resolves when the item is successfully added.
-     */
-    addVectorItem: async ( item: any): Promise<AddVectorItemResponse> => {
-        return new Promise((resolve, reject) => {
-            cbws.getWebsocket.send(JSON.stringify({
-                "type":"vectordbEvent",
-                "action": "addVectorItem",
-                "message": {
-                    item: item
-                },
-            }));
-            cbws.getWebsocket.on('message', (data: string) => {
-                const response = JSON.parse(data);
-                if (response.type === "addVectorItemResponse") {
-                    resolve(response);
-                }
-            });
-        });
-    },
-
-    /**
-     * Queries a vector item from the vector database based on the provided key.
-     *
-     * @param {string} key - The key of the vector to query the item from.
-     * @returns {Promise<QueryVectorItemResponse>} A promise that resolves with the queried vector item.
-     */
-    queryVectorItem: async (key: string): Promise<QueryVectorItemResponse> => {
-        return new Promise((resolve, reject) => {
-            cbws.getWebsocket.send(JSON.stringify({
-                "type":"vectordbEvent",
-                "action": "queryVectorItem",
-                "message": {
-                    item: key
-                },
-            }));
-            cbws.getWebsocket.on('message', (data: string) => {
-                const response = JSON.parse(data);
-                if (response.type === "qeryVectorItemResponse") {
-                    resolve(response);
-                }
-            });
-        });
-    },
-    /**
-     * Queries a vector item from the vector database based on the provided key.
-     *
-     * @param {string} key - The key of the vector to query the item from.
-     * @returns {Promise<QueryVectorItemResponse>} A promise that resolves with the queried vector item.
-     */
-    queryVectorItems: async (items: [],dbPath:string): Promise<QueryVectorItemResponse> => {
-        return new Promise((resolve, reject) => {
-            cbws.getWebsocket.send(JSON.stringify({
-                "type":"vectordbEvent",
-                "action": "queryVectorItems",
-                "message": {
-                    items,
-                    dbPath
-                },
-            }));
-            cbws.getWebsocket.on('message', (data: string) => {
-                const response = JSON.parse(data);
-                if (response.type === "qeryVectorItemsResponse") {
-                    resolve(response);
-                }
-            });
-        });
-    },
-};
-
-export default VectorDB;

package/src/modules/websocket.ts

@@ -1,97 +0,0 @@
-import WebSocket from 'ws';
-import fs from 'fs';
-import yaml from 'js-yaml';
-
-/**
- * Class representing a WebSocket connection.
- */
-class cbws {
-    websocket!: WebSocket;
-
-
-    /**
-     * Constructs a new cbws instance and initializes the WebSocket connection.
-     */
-    constructor() {
-
-        // this.websocket=undefined;
-        // this.websocket = new WebSocket(`ws://localhost:${process.env.SOCKET_PORT}/codebolt?id=${uniqueConnectionId}${agentIdParam}${parentIdParam}${process.env.Is_Dev ? '&dev=true' : ''}`);
-        // this.initializeWebSocket(initialMessage).catch(error => {
-        //     console.error("WebSocket connection failed:", error);
-        // });
-    }
-
-
-    private getUniqueConnectionId(): string {
-        try {
-            let fileContents = fs.readFileSync('./codeboltagent.yaml', 'utf8');
-            let data: any = yaml.load(fileContents);
-            return data.unique_connectionid;
-        } catch (e) {
-            console.error('Unable to locate codeboltagent.yaml file.');
-            return '';
-        }
-    }
-
-    private getInitialMessage(): string {
-        try {
-            let fileContents = fs.readFileSync('./codeboltagent.yaml', 'utf8');
-            let data: any = yaml.load(fileContents);
-            return data.initial_message;
-        } catch (e) {
-            // console.error('Unable to locate codeboltagent.yaml file.');
-            return '';
-        }
-    }
-
-    /**
-     * Initializes the WebSocket by setting up event listeners and returning a promise that resolves
-     * when the WebSocket connection is successfully opened.
-     * @returns {Promise<WebSocket>} A promise that resolves with the WebSocket instance.
-     */
-    public async initializeWebSocket(): Promise<WebSocket> {
-        const uniqueConnectionId = this.getUniqueConnectionId();
-        const initialMessage = this.getInitialMessage();
-
-        const agentIdParam = process.env.agentId ? `&agentId=${process.env.agentId}` : '';
-        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 WebSocket(`ws://localhost:${process.env.SOCKET_PORT}/codebolt?id=${uniqueConnectionId}${agentIdParam}${parentIdParam}${parentAgentInstanceIdParam}${agentTask}${process.env.Is_Dev ? '&dev=true' : ''}`);
-
-        return new Promise((resolve, reject) => {
-            this.websocket.on('error', (error: Error) => {
-                reject(error);
-            });
-
-            this.websocket.on('open', () => {
-                // if (this.websocket) {
-                //     this.websocket.send(JSON.stringify({
-                //         "type": "sendMessage",
-                //         "message": initialMessage
-                //     }));
-                //     resolve(this.websocket);
-                // }
-            });
-
-            this.websocket.on('message', (data: WebSocket.Data) => {
-                // Handle incoming WebSocket messages here.
-            });
-        });
-    }
-
-    /**
-     * Getter for the WebSocket instance. Throws an error if the WebSocket is not open.
-     * @returns {WebSocket} The WebSocket instance.
-     * @throws {Error} If the WebSocket is not open.
-     */
-    get getWebsocket(): WebSocket {
-        if (this.websocket && !this.websocket.OPEN) {
-            throw new Error('WebSocket is not open');
-        } else {
-            return this.websocket;
-        }
-    }
-}
-
-export default new cbws();

package/src/utils.ts

@@ -1,5 +0,0 @@
-export { ToolBox } from './modules/toolBox';
-export { TaskInstruction } from './modules/agentlib/taskInstruction';
-export { UserMessage } from './modules/agentlib/usermessage';
-export { SystemPrompt } from './modules/agentlib/systemprompt';
-export { Agent } from './modules/agentlib/agent';

package/tests/fs.test.js

@@ -1,89 +0,0 @@
-const codebolt = require("../src");
-const fs = require('fs');
-
-const testCases = [
-    {
-        name: 'createFile should create a file',
-        testFunction: async () => {
-            await codebolt.activate();
-            const fileName = 'testFile.txt';
-            const source = 'Test content';
-            const filePath = '/test';
-            const { projectPath } = await codebolt.project.getProjectPath();
-            await codebolt.fs.createFile(fileName, source, filePath);
-            const fileFullPath = projectPath + filePath + '/' + fileName;
-            expect(fs.existsSync(fileFullPath)).toBe(true);
-        }
-    },
-    {
-        name: 'createFolder should send the correct message to websocket',
-        testFunction: async () => {
-            await codebolt.activate();
-            const folderName = 'testFolder';
-            const folderPath = '/test';
-            const { projectPath } = await codebolt.project.getProjectPath();
-            await codebolt.fs.createFolder(folderName, folderPath);
-            // Assuming the folder creation is confirmed by the existence of the folder
-            const folderFullPath = `${projectPath}${folderPath}/${folderName}`;
-            expect(fs.existsSync(folderFullPath)).toBe(true);
-        }
-    },
-    {
-        name: 'deleteFolder should send the correct message to websocket',
-        testFunction: async () => {
-            await codebolt.activate();
-            const folderName = 'testFolder';
-            const folderPath = '/test';
-            const { projectPath } = await codebolt.project.getProjectPath();
-            await codebolt.fs.deleteFolder(folderName, folderPath);
-            
-            const folderFullPath = `${projectPath}${folderPath}/${folderName}`;
-            expect(fs.existsSync(folderFullPath)).toBe(false);
-        }
-    },
-    {
-        name: 'readFile should send the correct message to websocket',
-        testFunction: async () => {
-            await codebolt.activate();
-            const fileName = 'testFile.txt';
-            const filePath = '/test';
-            const { content } = await codebolt.fs.readFile(fileName, filePath);
-            expect(content).toBe('Test content'); // Assuming 'Test content' is the expected content
-        }
-    },
-    {
-        name: 'updateFile should send the correct message to websocket',
-        testFunction: async () => {
-            await codebolt.activate();
-            const fileName = 'testFile.txt';
-            const filePath = '/test';
-            const newContent = 'Updated content';
-            await codebolt.fs.updateFile(fileName, filePath, newContent);
-            const { projectPath } = await codebolt.project.getProjectPath();
-            const fileFullPath = `${projectPath}${filePath}/${fileName}`;
-            const updatedContent = fs.readFileSync(fileFullPath, 'utf8');
-            console.log(updatedContent);
-            expect(updatedContent).toBe(newContent);
-        }
-    },
-    {
-        name: 'deleteFile should send the correct message to websocket',
-        testFunction: async () => {
-            await codebolt.activate();
-            const fileName = 'testFile.txt';
-            const filePath = '/test';
-            await codebolt.fs.deleteFile(fileName, filePath);
-            const { projectPath } = await codebolt.project.getProjectPath();
-
-            const fileFullPath = `${projectPath}${filePath}/${fileName}`;
-            expect(fs.existsSync(fileFullPath)).toBe(false);
-        }
-    }
-   
-];
-
-describe('Run test cases sequentially', () => {
-    test.each(testCases)('%s', async (testCase) => {
-        await testCase.testFunction();
-    });
-});

package/tests/index.test.js

@@ -1,4 +0,0 @@
-test('runAllTests', async () => {
-    await require('./tests/fs.test.js');
-    await require('./tests/chat.test.js');
-});