@codebolt/codeboltjs 2.0.3 → 2.0.5

package/modules/tools.js

@@ -1,255 +0,0 @@
-"use strict";
-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("./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: () => {
-        return new Promise((resolve, reject) => {
-            websocket_1.default.getWebsocket.send(JSON.stringify({
-                "type": "codebolttools",
-                "action": "getEnabledToolBoxes"
-            }));
-            websocket_1.default.getWebsocket.on('message', (data) => {
-                try {
-                    const response = JSON.parse(data);
-                    if (response.type === "getEnabledToolBoxesResponse") {
-                        resolve(response.data);
-                    }
-                }
-                catch (error) {
-                    reject(new Error("Failed to parse response"));
-                }
-            });
-            websocket_1.default.getWebsocket.on('error', (error) => {
-                reject(error);
-            });
-        });
-    },
-    /**
-     * Gets the list of locally available toolboxes.
-     *
-     * @returns Promise with the local toolboxes data
-     */
-    getLocalToolBoxes: () => {
-        return new Promise((resolve, reject) => {
-            websocket_1.default.getWebsocket.send(JSON.stringify({
-                "type": "codebolttools",
-                "action": "getLocalToolBoxes"
-            }));
-            websocket_1.default.getWebsocket.on('message', (data) => {
-                try {
-                    const response = JSON.parse(data);
-                    if (response.type === "getLocalToolBoxesResponse") {
-                        resolve(response.data);
-                    }
-                }
-                catch (error) {
-                    reject(new Error("Failed to parse response"));
-                }
-            });
-            websocket_1.default.getWebsocket.on('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) => {
-        return new Promise((resolve, reject) => {
-            resolve(userMessage.mentionedMCPs);
-        });
-    },
-    /**
-     * Gets all available toolboxes.
-     *
-     * @returns Promise with all available toolboxes data
-     */
-    getAvailableToolBoxes: () => {
-        return new Promise((resolve, reject) => {
-            websocket_1.default.getWebsocket.send(JSON.stringify({
-                "type": "codebolttools",
-                "action": "getAvailableToolBoxes"
-            }));
-            websocket_1.default.getWebsocket.on('message', (data) => {
-                try {
-                    const response = JSON.parse(data);
-                    if (response.type === "getAvailableToolBoxesResponse") {
-                        resolve(response.data);
-                    }
-                }
-                catch (error) {
-                    reject(new Error("Failed to parse response"));
-                }
-            });
-            websocket_1.default.getWebsocket.on('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) => {
-        return new Promise((resolve, reject) => {
-            websocket_1.default.getWebsocket.send(JSON.stringify({
-                "type": "codebolttools",
-                "action": "searchAvailableToolBoxes",
-                "query": query
-            }));
-            websocket_1.default.getWebsocket.on('message', (data) => {
-                try {
-                    const response = JSON.parse(data);
-                    if (response.type === "searchAvailableToolBoxesResponse") {
-                        resolve(response.data);
-                    }
-                }
-                catch (error) {
-                    reject(new Error("Failed to parse response"));
-                }
-            });
-            websocket_1.default.getWebsocket.on('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) => {
-        return new Promise((resolve, reject) => {
-            websocket_1.default.getWebsocket.send(JSON.stringify({
-                "type": "codebolttools",
-                "action": "listToolsFromToolBoxes",
-                "toolBoxes": toolBoxes
-            }));
-            websocket_1.default.getWebsocket.on('message', (data) => {
-                try {
-                    const response = JSON.parse(data);
-                    if (response.type === "listToolsFromToolBoxesResponse") {
-                        resolve(response.data);
-                    }
-                }
-                catch (error) {
-                    reject(new Error("Failed to parse response"));
-                }
-            });
-            websocket_1.default.getWebsocket.on('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, config) => {
-        return new Promise((resolve, reject) => {
-            websocket_1.default.getWebsocket.send(JSON.stringify({
-                "type": "codebolttools",
-                "action": "configureToolBox",
-                "mcpName": name,
-                "config": config
-            }));
-            websocket_1.default.getWebsocket.on('message', (data) => {
-                try {
-                    const response = JSON.parse(data);
-                    if (response.type === "configureToolBoxResponse") {
-                        resolve(response.data);
-                    }
-                }
-                catch (error) {
-                    reject(new Error("Failed to parse response"));
-                }
-            });
-            websocket_1.default.getWebsocket.on('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) => {
-        return new Promise((resolve, reject) => {
-            websocket_1.default.getWebsocket.send(JSON.stringify({
-                "type": "codebolttools",
-                "action": "getTools",
-                "toolboxes": tools
-            }));
-            websocket_1.default.getWebsocket.on('message', (data) => {
-                try {
-                    const response = JSON.parse(data);
-                    if (response.type === "getToolsResponse") {
-                        resolve(response.data);
-                    }
-                }
-                catch (error) {
-                    reject(new Error("Failed to parse response"));
-                }
-            });
-            websocket_1.default.getWebsocket.on('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, toolName, params) => {
-        return new Promise((resolve, reject) => {
-            websocket_1.default.getWebsocket.send(JSON.stringify({
-                "type": "codebolttools",
-                "action": "executeTool",
-                "toolName": `${toolbox}--${toolName}`,
-                "params": params
-            }));
-            websocket_1.default.getWebsocket.on('message', (data) => {
-                try {
-                    const response = JSON.parse(data);
-                    if (response.type === "executeToolResponse") {
-                        resolve(response.data);
-                    }
-                }
-                catch (error) {
-                    reject(new Error("Failed to parse response"));
-                }
-            });
-            websocket_1.default.getWebsocket.on('error', (error) => {
-                reject(error);
-            });
-        });
-    },
-};
-exports.default = codeboltMCP;

package/modules/vectordb.js

@@ -1,103 +0,0 @@
-"use strict";
-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("./websocket"));
-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) => {
-        return new Promise((resolve, reject) => {
-            websocket_1.default.getWebsocket.send(JSON.stringify({
-                "type": "vectordbEvent",
-                "action": "getVector",
-                "message": {
-                    item: key
-                },
-            }));
-            websocket_1.default.getWebsocket.on('message', (data) => {
-                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) => {
-        return new Promise((resolve, reject) => {
-            websocket_1.default.getWebsocket.send(JSON.stringify({
-                "type": "vectordbEvent",
-                "action": "addVectorItem",
-                "message": {
-                    item: item
-                },
-            }));
-            websocket_1.default.getWebsocket.on('message', (data) => {
-                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) => {
-        return new Promise((resolve, reject) => {
-            websocket_1.default.getWebsocket.send(JSON.stringify({
-                "type": "vectordbEvent",
-                "action": "queryVectorItem",
-                "message": {
-                    item: key
-                },
-            }));
-            websocket_1.default.getWebsocket.on('message', (data) => {
-                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) => {
-        return new Promise((resolve, reject) => {
-            websocket_1.default.getWebsocket.send(JSON.stringify({
-                "type": "vectordbEvent",
-                "action": "queryVectorItems",
-                "message": {
-                    items,
-                    dbPath
-                },
-            }));
-            websocket_1.default.getWebsocket.on('message', (data) => {
-                const response = JSON.parse(data);
-                if (response.type === "qeryVectorItemsResponse") {
-                    resolve(response);
-                }
-            });
-        });
-    },
-};
-exports.default = VectorDB;

package/script/gen.js

@@ -1,27 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-const { execSync } = require('child_process');
-
-// Define the directory containing your TypeScript files
-const dir = './src';
-
-// Define the output directory for the documentation
-const outDir = './document';
-
-// Use a recursive function to find all TypeScript files in the directory and its subdirectories
-function getFiles(dir) {
-    return fs.readdirSync(dir).reduce((files, file) => {
-        const filePath = path.join(dir, file);
-        const isDirectory = fs.statSync(filePath).isDirectory();
-        return isDirectory ? [...files, ...getFiles(filePath)] : [...files, filePath];
-    }, []);
-}
-
-// Get all TypeScript files
-const tsFiles = getFiles(dir).filter(file => file.endsWith('.ts'));
-
-// Generate documentation for each TypeScript file
-tsFiles.forEach(file => {
-    const outPath = path.join(outDir, path.basename(file, '.ts'));
-    execSync(`npx typedoc --plugin typedoc-plugin-markdown --out ${outPath} ${file}`);
-});

package/src/index.ts

@@ -1,108 +0,0 @@
-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 cbstate from './modules/state';
-import task from './modules/task';
-import vectorDB from './modules/vectordb';
-import debug from './modules/debug'
-import tokenizer from './modules/tokenizer'
-import WebSocket from 'ws';
-import { EventEmitter } from 'events';
-import {chatSummary} from './modules/history'
-import codeboltTools from './modules/tools';
-import cbagent from './modules/agent';
-import cbutils from './utils/editFile';
-
-
-
-/**
- * @class Codebolt
- * @description This class provides a unified interface to interact with various modules.
- */
-class Codebolt  { // Extend EventEmitter
-
-    /**
-     * @constructor
-     * @description Initializes the websocket connection.
-     */
-    constructor() {
-        cbws.initializeWebSocket()
-        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);
-            });
-
-        });
-    }
-
-    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;
-    cbstate = cbstate;
-    taskplaner = task;
-    vectordb = vectorDB;
-    debug = debug;
-    tokenizer = tokenizer;
-    chatSummary=chatSummary;
-    tools = codeboltTools;
-    agent = cbagent;
-    utils = cbutils;
-  
-}
-
-export default new Codebolt();
-
-
-

package/src/modules/agent.ts

@@ -1,120 +0,0 @@
-import { GetAgentStateResponse } from '@codebolt/types';
-import cbws from './websocket';
-
-
-export enum AgentLocation {
-    ALL = 'all',
-    LOCAL_ONLY = 'local_only',
-    REMOTE_ONLY = 'remote_only',
-}
-
-
-export enum Agents {
-    LOCAL = 'local',
-    ALL = 'all',
-    DOWNLOADED = 'downloaded',
-}
-
-export enum FilterUsing {
-    USE_AI = 'use_ai',
-    USE_VECTOR_DB = 'use_vector_db',
-    USE_BOTH = 'use_both',
-}
-
-
-
-const codeboltAgent = {
-    /**
-     * Retrieves an agent based on the specified task.
-     * @param {string} task - The task for which an agent is needed.
-     * @returns {Promise<AgentResponse>} A promise that resolves with the agent details.
-     */
-    findAgent: (task: string, maxResult = 1, agents = [], agentLocaltion: AgentLocation = AgentLocation.ALL, getFrom: FilterUsing.USE_VECTOR_DB): Promise<any> => {
-        return new Promise((resolve, reject) => {
-            cbws.getWebsocket.send(JSON.stringify({
-                "type": "agentEvent",
-                "action": "findAgent",
-                "task": task,
-                "agents": agents,// for filter in vector db
-                "maxResult": maxResult,
-                "location": agentLocaltion,
-                "getFrom": getFrom
-            }));
-            cbws.getWebsocket.on('message', (data: string) => {
-                const response = JSON.parse(data);
-                if (response.type === "findAgentByTaskResponse") {
-                    resolve(response); // Resolve the Promise with the agent details
-                }
-            });
-        });
-    },
-
-    /**
-     * Starts an agent for the specified task.
-     * @param {string} task - The task for which the agent should be started.
-     * @returns {Promise<void>} A promise that resolves when the agent has been successfully started.
-     */
-    startAgent: (agentId: string, task: string): Promise<any> => {
-        return new Promise((resolve, reject) => {
-            cbws.getWebsocket.send(JSON.stringify({
-                "type": "agentEvent",
-                "action": "startAgent",
-                "agentId": agentId,
-                "task": task
-            }));
-            cbws.getWebsocket.on('message', (data: string) => {
-                const response = JSON.parse(data);
-                if (response.type === "taskCompletionResponse" && response.agentId === agentId) {
-                    resolve(response); // Resolve the Promise when the agent has been successfully started
-                }
-            });
-        });
-    },
-
-    /**
-     * Lists all available agents.
-     * @returns {Promise<any>} A promise that resolves with the list of agents.
-     */
-    getAgentsList: (type: Agents = Agents.DOWNLOADED): Promise<any> => {
-        return new Promise((resolve, reject) => {
-            cbws.getWebsocket.send(JSON.stringify({
-                "type": "agentEvent",
-                "action": "listAgents",
-                "agentType": type,
-
-            }));
-            cbws.getWebsocket.on('message', (data: string) => {
-                const response = JSON.parse(data);
-                if (response.type === "listAgentsResponse") {
-                    resolve(response); // Resolve the Promise with the list of agents
-                }
-            });
-        });
-    },
-    /**
-     * Lists all available agents.
-     * @returns {Promise<any>} A promise that resolves with the list of agents.
-     */
-    getAgentsDetail: (agentList = []): Promise<any> => {
-        return new Promise((resolve, reject) => {
-            cbws.getWebsocket.send(JSON.stringify({
-                "type": "agentEvent",
-                "action": "agentsDetail",
-                "agentList": agentList
-            }));
-            cbws.getWebsocket.on('message', (data: string) => {
-                const response = JSON.parse(data);
-                if (response.type === "listAgentsResponse") {
-                    resolve(response); // Resolve the Promise with the list of agents
-                }
-            });
-        });
-    }
-}
-
-
-export default codeboltAgent;
-
-
-
-