@codebolt/codeboltjs 2.0.12 → 2.0.13

package/Readme.md

@@ -1,11 +1,14 @@
 # Codebolt Agent Library 
 
-This library provides a set of tools and utilities for creating Codebolt agents, enabling seamless integration with the Codebolt platform.
+This library provides a set of tools and utilities for creating Codebolt agents, enabling seamless integration with the Codebolt platform with full TypeScript support.
 
 ## Features
 - Create and manage Codebolt agents
 - Interact with the Codebolt platform
 - Utilize Codebolt's powerful API
+- **Full TypeScript support with comprehensive type definitions**
+- Type-safe API interactions
+- IntelliSense support in TypeScript/JavaScript IDEs
 
 ## Installation
 
@@ -13,12 +16,137 @@ This library provides a set of tools and utilities for creating Codebolt agents,
 npm install @codebolt/codeboltjs
 ```
 
-## Usage
+## Quick Start
 
+### JavaScript
 ```javascript
 const codebolt = require('@codebolt/codeboltjs');
 
-// Your code here
+// Set up message handling
+codebolt.onMessage(async (userMessage) => {
+  console.log('User said:', userMessage.userMessage);
+  
+  // Read a file
+  const content = await codebolt.fs.readFile({ path: './example.txt' });
+  console.log('File content:', content);
+  
+  return { status: 'completed' };
+});
+```
+
+### TypeScript
+```typescript
+import codebolt from 'codeboltjs';
+import type { 
+  ChatMessageFromUser, 
+  ReadFileOptions, 
+  BrowserScreenshotOptions 
+} from 'codeboltjs';
+
+// Type-safe message handling
+codebolt.onMessage(async (userMessage: ChatMessageFromUser) => {
+  console.log('User said:', userMessage.userMessage);
+  console.log('Mentioned files:', userMessage.mentionedFiles);
+  
+  // Type-safe file operations
+  const readOptions: ReadFileOptions = {
+    path: './config.json',
+    encoding: 'utf8',
+    askForPermission: true
+  };
+  
+  const content = await codebolt.fs.readFile(readOptions);
+  
+  // Type-safe browser operations
+  const screenshotOptions: BrowserScreenshotOptions = {
+    fullPage: true,
+    quality: 90,
+    format: 'png'
+  };
+  
+  const screenshot = await codebolt.browser.takeScreenshot(screenshotOptions);
+  
+  return { status: 'completed', data: content };
+});
+```
+
+## TypeScript Support
+
+This library provides comprehensive TypeScript support with over 200+ type definitions covering:
+
+### Core Types
+- **Message & Tool Types**: `Message`, `ToolCall`, `Tool`, `LLMInferenceParams`
+- **API Response Types**: `APIResponse`, `SuccessResponse`, `FailureResponse`
+- **Configuration Types**: `CodeboltConfig`, `AgentConfiguration`
+
+### Module-Specific Types
+- **File System**: `ReadFileOptions`, `WriteFileOptions`, `SearchFilesOptions`
+- **Browser**: `BrowserNavigationOptions`, `BrowserScreenshotOptions`
+- **Terminal**: `TerminalExecuteOptions`
+- **Git**: `GitCommitOptions`, `GitLogOptions`
+- **LLM**: `LLMChatOptions`, `OpenAIMessage`
+- **Vector DB**: `VectorAddOptions`, `VectorQueryOptions`
+
+### Import Strategies
+
+#### From Main Package
+```typescript
+import codebolt, { type Message, type ToolCall } from 'codeboltjs';
+```
+
+#### From Types Barrel (Recommended)
+```typescript
+import codebolt from 'codeboltjs';
+import type { Message, ToolCall, LLMChatOptions } from 'codeboltjs/types';
+```
+
+#### Namespace Import
+```typescript
+import codebolt from 'codeboltjs';
+import type * as CodeboltTypes from 'codeboltjs/types';
+```
+
+For detailed type usage examples, see [TYPES.md](./TYPES.md).
+
+## API Overview
+
+### Core Modules
+
+- `codebolt.fs` - File system operations
+- `codebolt.git` - Git operations  
+- `codebolt.browser` - Browser automation
+- `codebolt.terminal` - Terminal/shell operations
+- `codebolt.llm` - LLM interactions
+- `codebolt.chat` - Chat management
+- `codebolt.agent` - Agent operations
+- `codebolt.vectordb` - Vector database operations
+- `codebolt.mcp` - MCP (Model Context Protocol) tools
+
+### Example Usage
+
+```typescript
+// Wait for connection
+await codebolt.waitForReady();
+
+// File operations
+const files = await codebolt.fs.listFiles({ path: './src', recursive: true });
+const content = await codebolt.fs.readFile({ path: './package.json' });
+
+// Browser operations  
+await codebolt.browser.navigateTo({ url: 'https://example.com' });
+const screenshot = await codebolt.browser.takeScreenshot({ fullPage: true });
+
+// Terminal operations
+const result = await codebolt.terminal.execute({ 
+  command: 'npm install',
+  cwd: './my-project' 
+});
+
+// LLM operations
+const response = await codebolt.llm.chat({
+  messages: [{ role: 'user', content: 'Explain TypeScript' }],
+  temperature: 0.7
+});
 ```
 
 ## Development
@@ -64,11 +192,17 @@ The project supports two build methods:
 ### Project Structure
 
 - `src/` - TypeScript source code
+  - `core/` - Core library classes (Codebolt class, WebSocket management)
+  - `modules/` - Feature modules (fs, git, browser, etc.)
+  - `types/` - TypeScript type definitions
+  - `utils/` - Utility functions
 - `dist/` - Compiled JavaScript and type definitions (generated by TypeScript)
 - `build/` - Webpack bundle (generated by webpack)
 - `docs/` - Generated documentation
 
 ## Documentation
 
-For More Documentation visit [Codebolt's Documentation](https://docs.codebolt.ai)
+- **[Type Definitions Guide](./TYPES.md)** - Comprehensive TypeScript usage guide
+- **[Codebolt Documentation](https://docs.codebolt.ai)** - Platform documentation
+- **API Reference** - Generated from source code (coming soon)
 

package/dist/core/Codebolt.d.ts

@@ -0,0 +1,310 @@
+/// <reference types="node" />
+import WebSocket from 'ws';
+import type { UserMessage } from '../types/libFunctionTypes';
+/**
+ * @class Codebolt
+ * @description This class provides a unified interface to interact with various modules.
+ */
+declare class Codebolt {
+    websocket: WebSocket | null;
+    private isReady;
+    private readyPromise;
+    /**
+     * @constructor
+     * @description Initializes the websocket connection.
+     */
+    constructor();
+    /**
+     * @method initializeConnection
+     * @description Initializes the WebSocket connection asynchronously.
+     * @private
+     */
+    private initializeConnection;
+    /**
+     * @method waitForReady
+     * @description Waits for the Codebolt instance to be fully initialized.
+     * @returns {Promise<void>} A promise that resolves when the instance is ready.
+     */
+    waitForReady(): Promise<void>;
+    /**
+     * @method isReady
+     * @description Checks if the Codebolt instance is ready for use.
+     * @returns {boolean} True if the instance is ready, false otherwise.
+     */
+    get ready(): boolean;
+    fs: {
+        createFile: (fileName: string, source: string, filePath: string) => Promise<import("../types/socketMessageTypes").CreateFileResponse>;
+        createFolder: (folderName: string, folderPath: string) => Promise<import("../types/socketMessageTypes").CreateFolderResponse>;
+        readFile: (filePath: string) => Promise<import("../types/socketMessageTypes").ReadFileResponse>;
+        updateFile: (filename: string, filePath: string, newContent: string) => Promise<import("../types/socketMessageTypes").UpdateFileResponse>;
+        deleteFile: (filename: string, filePath: string) => Promise<import("../types/socketMessageTypes").DeleteFileResponse>;
+        deleteFolder: (foldername: string, folderpath: string) => Promise<import("../types/socketMessageTypes").DeleteFolderResponse>;
+        listFile: (folderPath: string, isRecursive?: boolean) => Promise<any>;
+        listCodeDefinitionNames: (path: string) => Promise<{
+            success: boolean;
+            result: any;
+        }>;
+        searchFiles: (path: string, regex: string, filePattern: string) => Promise<{
+            success: boolean;
+            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<import("../types/socketMessageTypes").GitInitResponse>;
+        pull: () => Promise<import("../types/socketMessageTypes").GitPullResponse>;
+        push: () => Promise<import("../types/socketMessageTypes").GitPushResponse>;
+        status: () => Promise<import("../types/socketMessageTypes").GitStatusResponse>;
+        addAll: () => Promise<import("../types/socketMessageTypes").AddResponse>;
+        commit: (message: string) => Promise<import("../types/socketMessageTypes").GitCommitResponse>;
+        checkout: (branch: string) => Promise<import("../types/socketMessageTypes").GitCheckoutResponse>;
+        branch: (branch: string) => Promise<import("../types/socketMessageTypes").GitBranchResponse>;
+        logs: (path: string) => Promise<import("../types/socketMessageTypes").GitLogsResponse>;
+        diff: (commitHash: string) => Promise<import("../types/socketMessageTypes").GitDiffResponse>;
+    };
+    llm: {
+        inference: (message: string, llmrole: string) => Promise<import("../types/socketMessageTypes").LLMResponse>;
+    };
+    browser: {
+        newPage: () => Promise<import("../types/socketMessageTypes").BrowserActionResponseData>;
+        getUrl: () => Promise<import("../types/socketMessageTypes").UrlResponse>;
+        goToPage: (url: string) => Promise<import("../types/socketMessageTypes").GoToPageResponse>;
+        screenshot: () => Promise<import("../types/socketMessageTypes").BrowserScreenshotResponse>;
+        getHTML: () => Promise<import("../types/socketMessageTypes").HtmlReceived>;
+        getMarkdown: () => Promise<import("../types/socketMessageTypes").GetMarkdownResponse>;
+        getPDF: () => void;
+        pdfToText: () => void;
+        getContent: () => Promise<import("../types/socketMessageTypes").GetContentResponse>;
+        getSnapShot: () => Promise<import("../types/socketMessageTypes").BrowserSnapshotResponse>;
+        getBrowserInfo: () => Promise<import("../types/socketMessageTypes").BrowserInfoResponse>;
+        extractText: () => Promise<import("../types/socketMessageTypes").ExtractTextResponse>;
+        close: () => void;
+        scroll: (direction: string, pixels: string) => Promise<import("../types/socketMessageTypes").BrowserActionResponseData>;
+        type: (elementid: string, text: string) => Promise<import("../types/socketMessageTypes").BrowserActionResponseData>;
+        click: (elementid: string) => Promise<import("../types/socketMessageTypes").BrowserActionResponseData>;
+        enter: () => Promise<import("../types/socketMessageTypes").BrowserActionResponseData>;
+        search: (elementid: string, query: string) => Promise<import("../types/socketMessageTypes").BrowserActionResponseData>;
+    };
+    chat: {
+        getChatHistory: () => Promise<import("../types/socketMessageTypes").ChatMessage[]>;
+        setRequestHandler: (handler: (request: any, response: (data: any) => void) => void | Promise<void>) => void;
+        sendMessage: (message: string, payload: any) => void;
+        waitforReply: (message: string) => Promise<import("../types/socketMessageTypes").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: "browser" | "terminal" | "git" | "debug" | "planner" | "editor" | "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;
+            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)[];
+        };
+        executeCommand: (command: string, returnEmptyStringOnSuccess?: boolean) => Promise<any>;
+        executeCommandRunUntilError: (command: string, executeInMain?: boolean) => Promise<import("../types/socketMessageTypes").CommandError>;
+        sendManualInterrupt(): Promise<import("../types/socketMessageTypes").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;
+            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)[];
+        };
+    };
+    codeutils: {
+        getJsTree: (filePath?: string | undefined) => Promise<import("../types/InternalTypes").JSTreeResponse>;
+        getAllFilesAsMarkDown: () => Promise<string>;
+        performMatch: (matcherDefinition: object, problemPatterns: any[], problems?: any[]) => Promise<import("../types/socketMessageTypes").MatchProblemResponse>;
+        getMatcherList: () => Promise<import("../types/socketMessageTypes").GetMatcherListTreeResponse>;
+        matchDetail: (matcher: string) => Promise<import("../types/socketMessageTypes").getMatchDetail>;
+    };
+    crawler: {
+        start: () => void;
+        screenshot: () => void;
+        goToPage: (url: string) => void;
+        scroll: (direction: string) => void;
+        click: (id: string) => Promise<any>;
+    };
+    search: {
+        init: (engine?: string) => void;
+        search: (query: string) => Promise<string>;
+        get_first_link: (query: string) => Promise<string>;
+    };
+    knowledge: {};
+    rag: {
+        init: () => void;
+        add_file: (filename: string, file_path: string) => void;
+        retrieve_related_knowledge: (query: string, filename: string) => void;
+    };
+    codeparsers: {
+        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("..").ASTNode | {
+            error: string;
+        }>;
+    };
+    outputparsers: {
+        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[]; /**
+             * @method isReady
+             * @description Checks if the Codebolt instance is ready for use.
+             * @returns {boolean} True if the instance is ready, false otherwise.
+             */
+        };
+        parseErrors: (output: any) => string[];
+        parseWarnings: (output: any) => string[];
+    };
+    project: {
+        getProjectSettings: () => Promise<any>;
+        getProjectPath: () => Promise<import("../types/socketMessageTypes").GetProjectPathResponse>;
+        getRepoMap: (message: any) => Promise<import("../types/socketMessageTypes").GetProjectPathResponse>;
+        runProject: () => void;
+        getEditorFileStatus: () => Promise<any>;
+    };
+    dbmemory: {
+        addKnowledge: (key: string, value: any) => Promise<import("../types/socketMessageTypes").MemorySetResponse>;
+        getKnowledge: (key: string) => Promise<import("../types/socketMessageTypes").MemoryGetResponse>; /**
+         * @constructor
+         * @description Initializes the websocket connection.
+         */
+    };
+    cbstate: {
+        getApplicationState: () => Promise<import("../types/commonTypes").ApplicationState>;
+        addToAgentState: (key: string, value: string) => Promise<import("../types/socketMessageTypes").AddToAgentStateResponse>;
+        getAgentState: () => Promise<import("../types/socketMessageTypes").GetAgentStateResponse>;
+        getProjectState: () => Promise<any>;
+        updateProjectState: (key: string, value: any) => Promise<any>;
+    };
+    taskplaner: {
+        addTask: (task: string) => Promise<any>;
+        getTasks: () => Promise<any>;
+        updateTask: (task: string) => Promise<any>;
+    };
+    vectordb: {
+        getVector: (key: string) => Promise<import("../types/socketMessageTypes").GetVectorResponse>;
+        addVectorItem: (item: any) => Promise<import("../types/socketMessageTypes").AddVectorItemResponse>;
+        queryVectorItem: (key: string) => Promise<import("../types/socketMessageTypes").QueryVectorItemResponse>;
+        queryVectorItems: (items: [], dbPath: string) => Promise<import("../types/socketMessageTypes").QueryVectorItemResponse>;
+    };
+    debug: {
+        debug: (log: string, type: import("../modules/debug").logType) => Promise<import("../types/socketMessageTypes").DebugAddLogResponse>;
+        openDebugBrowser: (url: string, port: number) => Promise<import("../types/socketMessageTypes").OpenDebugBrowserResponse>;
+    };
+    tokenizer: {
+        addToken: (key: string) => Promise<import("../types/socketMessageTypes").AddTokenResponse>;
+        getToken: (key: string) => Promise<import("../types/socketMessageTypes").GetTokenResponse>;
+    };
+    chatSummary: {
+        summarizeAll: () => Promise<import("../types/socketMessageTypes").GetSummarizeAllResponse>;
+        summarize: (messages: {
+            role: string;
+            content: string;
+        }[], depth: number) => Promise<import("../types/socketMessageTypes").GetSummarizeResponse>;
+    };
+    mcp: {
+        getEnabledMCPServers: () => Promise<import("../types/socketMessageTypes").GetEnabledToolBoxesResponse>;
+        getLocalMCPServers: () => Promise<import("../types/socketMessageTypes").GetLocalToolBoxesResponse>;
+        getMentionedMCPServers: (userMessage: import("../utils").UserMessage) => Promise<import("../types/socketMessageTypes").GetAvailableToolBoxesResponse>;
+        searchAvailableMCPServers: (query: string) => Promise<import("../types/socketMessageTypes").SearchAvailableToolBoxesResponse>;
+        listMcpFromServers: (toolBoxes: string[]) => Promise<import("../types/socketMessageTypes").ListToolsFromToolBoxesResponse>;
+        configureMCPServer: (name: string, config: any) => Promise<import("../types/socketMessageTypes").ConfigureToolBoxResponse>;
+        getTools: (tools: {
+            toolbox: string;
+            toolName: string;
+        }[]) => Promise<import("../types/socketMessageTypes").GetToolsResponse>;
+        executeTool: (toolbox: string, toolName: string, params: any) => Promise<import("../types/socketMessageTypes").ExecuteToolResponse>;
+    };
+    agent: {
+        findAgent: (task: string, maxResult: number | undefined, agents: never[] | undefined, agentLocaltion: import("../modules/agent").AgentLocation | undefined, getFrom: import("../modules/agent").FilterUsing.USE_VECTOR_DB) => Promise<import("../types/socketMessageTypes").FindAgentByTaskResponse>;
+        /**
+         * @constructor
+         * @description Initializes the websocket connection.
+         */
+        startAgent: (agentId: string, task: string) => Promise<import("../types/socketMessageTypes").TaskCompletionResponse>;
+        getAgentsList: (type?: import("../modules/agent").Agents) => Promise<import("../types/socketMessageTypes").ListAgentsResponse>;
+        getAgentsDetail: (agentList?: never[]) => Promise<import("../types/socketMessageTypes").AgentsDetailResponse>;
+    };
+    utils: {
+        editFileAndApplyDiff: (filePath: string, diff: string, diffIdentifier: string, prompt: string, applyModel?: string | undefined) => Promise<import("../types/socketMessageTypes").FsEditFileAndApplyDiffResponse>;
+    };
+    /**
+     * 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: UserMessage) => void | Promise<void> | any | Promise<any>): void;
+}
+export default Codebolt;

package/dist/core/Codebolt.js

@@ -0,0 +1,159 @@
+"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 fs_1 = __importDefault(require("../modules/fs"));
+const llm_1 = __importDefault(require("../modules/llm"));
+const terminal_1 = __importDefault(require("../modules/terminal"));
+const browser_1 = __importDefault(require("../modules/browser"));
+const chat_1 = __importDefault(require("../modules/chat"));
+const codeutils_1 = __importDefault(require("../modules/codeutils"));
+const crawler_1 = __importDefault(require("../modules/crawler"));
+const search_1 = __importDefault(require("../modules/search"));
+const knowledge_1 = __importDefault(require("../modules/knowledge"));
+const rag_1 = __importDefault(require("../modules/rag"));
+const codeparsers_1 = __importDefault(require("../modules/codeparsers"));
+const outputparsers_1 = __importDefault(require("../modules/outputparsers"));
+const project_1 = __importDefault(require("../modules/project"));
+const git_1 = __importDefault(require("../modules/git"));
+const dbmemory_1 = __importDefault(require("../modules/dbmemory"));
+const state_1 = __importDefault(require("../modules/state"));
+const task_1 = __importDefault(require("../modules/task"));
+const vectordb_1 = __importDefault(require("../modules/vectordb"));
+const debug_1 = __importDefault(require("../modules/debug"));
+const tokenizer_1 = __importDefault(require("../modules/tokenizer"));
+const history_1 = require("../modules/history");
+const mcp_1 = __importDefault(require("../modules/mcp"));
+const agent_1 = __importDefault(require("../modules/agent"));
+const utils_1 = __importDefault(require("../modules/utils"));
+/**
+ * @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 = null;
+        this.isReady = false;
+        this.fs = fs_1.default;
+        this.git = git_1.default;
+        this.llm = llm_1.default;
+        this.browser = browser_1.default;
+        this.chat = chat_1.default;
+        this.terminal = terminal_1.default;
+        this.codeutils = codeutils_1.default;
+        this.crawler = crawler_1.default;
+        this.search = search_1.default;
+        this.knowledge = knowledge_1.default;
+        this.rag = rag_1.default;
+        this.codeparsers = codeparsers_1.default;
+        this.outputparsers = outputparsers_1.default;
+        this.project = project_1.default;
+        this.dbmemory = dbmemory_1.default;
+        this.cbstate = state_1.default;
+        this.taskplaner = task_1.default;
+        this.vectordb = vectordb_1.default;
+        this.debug = debug_1.default;
+        this.tokenizer = tokenizer_1.default;
+        this.chatSummary = history_1.chatSummary;
+        this.mcp = mcp_1.default;
+        this.agent = agent_1.default;
+        this.utils = utils_1.default;
+        console.log("Codebolt Agent initialized");
+        this.readyPromise = this.initializeConnection();
+    }
+    /**
+     * @method initializeConnection
+     * @description Initializes the WebSocket connection asynchronously.
+     * @private
+     */
+    async initializeConnection() {
+        try {
+            await websocket_1.default.initializeWebSocket();
+            this.websocket = websocket_1.default.getWebsocket;
+            this.isReady = true;
+            console.log("Codebolt WebSocket connection established");
+        }
+        catch (error) {
+            console.error('Failed to initialize WebSocket connection:', error);
+            throw error;
+        }
+    }
+    /**
+     * @method waitForReady
+     * @description Waits for the Codebolt instance to be fully initialized.
+     * @returns {Promise<void>} A promise that resolves when the instance is ready.
+     */
+    async waitForReady() {
+        return this.readyPromise;
+    }
+    /**
+     * @method isReady
+     * @description Checks if the Codebolt instance is ready for use.
+     * @returns {boolean} True if the instance is ready, false otherwise.
+     */
+    get ready() {
+        return this.isReady;
+    }
+    /**
+     * 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) {
+        // Wait for the WebSocket to be ready before setting up the handler
+        this.waitForReady().then(() => {
+            const handleUserMessage = async (response) => {
+                var _a, _b;
+                console.log("Message received By Agent Library Starting Custom Agent Handler Logic");
+                if (response.type === "messageResponse") {
+                    try {
+                        // Extract user-facing message from internal socket message
+                        const userMessage = {
+                            userMessage: response.message.userMessage,
+                            currentFile: response.message.currentFile,
+                            mentionedFiles: response.message.mentionedFiles || [],
+                            mentionedFullPaths: response.message.mentionedFullPaths || [],
+                            mentionedFolders: response.message.mentionedFolders || [],
+                            uploadedImages: response.message.uploadedImages || [],
+                            selectedAgent: {
+                                id: ((_a = response.message.selectedAgent) === null || _a === void 0 ? void 0 : _a.id) || '',
+                                name: ((_b = response.message.selectedAgent) === null || _b === void 0 ? void 0 : _b.name) || ''
+                            },
+                            messageId: response.message.messageId,
+                            threadId: response.message.threadId,
+                            selection: response.message.selection
+                        };
+                        const result = await handler(userMessage);
+                        // 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);
+        }).catch(error => {
+            console.error('Failed to set up message handler:', error);
+        });
+    }
+}
+exports.default = Codebolt;

package/dist/index.d.ts

@@ -1,302 +1,6 @@
-/// <reference types="node" />
-import WebSocket from 'ws';
-import { EventEmitter } from 'events';
-import type { ChatMessageFromUser, LLMResponse, UserMessage } from './types/socketMessageTypes';
-export type { Message, ToolCall, Tool, LLMInferenceParams, APIResponse, CodeboltConfig, ProgressCallback, ErrorCallback, SuccessCallback, CompletionCallback } from './types/libFunctionTypes';
-/**
- * @class Codebolt
- * @description This class provides a unified interface to interact with various modules.
- */
-declare class Codebolt {
-    websocket: WebSocket | null;
-    private isReady;
-    private readyPromise;
-    /**
-     * @constructor
-     * @description Initializes the websocket connection.
-     */
-    constructor();
-    /**
-     * @method initializeConnection
-     * @description Initializes the WebSocket connection asynchronously.
-     * @private
-     */
-    private initializeConnection;
-    /**
-     * @method waitForReady
-     * @description Waits for the Codebolt instance to be fully initialized.
-     * @returns {Promise<void>} A promise that resolves when the instance is ready.
-     */
-    waitForReady(): Promise<void>;
-    /**
-     * @method isReady
-     * @description Checks if the Codebolt instance is ready for use.
-     * @returns {boolean} True if the instance is ready, false otherwise.
-     */
-    get ready(): boolean;
-    fs: {
-        createFile: (fileName: string, source: string, filePath: string) => Promise<import("./types/socketMessageTypes").CreateFileResponse>;
-        createFolder: (folderName: string, folderPath: string) => Promise<import("./types/socketMessageTypes").CreateFolderResponse>;
-        readFile: (filePath: string) => Promise<import("./types/socketMessageTypes").ReadFileResponse>;
-        updateFile: (filename: string, filePath: string, newContent: string) => Promise<import("./types/socketMessageTypes").UpdateFileResponse>;
-        deleteFile: (filename: string, filePath: string) => Promise<import("./types/socketMessageTypes").DeleteFileResponse>;
-        deleteFolder: (foldername: string, folderpath: string) => Promise<import("./types/socketMessageTypes").DeleteFolderResponse>;
-        listFile: (folderPath: string, isRecursive?: boolean) => Promise<any>;
-        listCodeDefinitionNames: (path: string) => Promise<{
-            success: boolean;
-            result: any;
-        }>;
-        searchFiles: (path: string, regex: string, filePattern: string) => Promise<{
-            success: boolean;
-            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<import("./types/socketMessageTypes").GitInitResponse>;
-        pull: () => Promise<import("./types/socketMessageTypes").GitPullResponse>;
-        push: () => Promise<import("./types/socketMessageTypes").GitPushResponse>;
-        status: () => Promise<import("./types/socketMessageTypes").GitStatusResponse>;
-        addAll: () => Promise<import("./types/socketMessageTypes").AddResponse>;
-        commit: (message: string) => Promise<import("./types/socketMessageTypes").GitCommitResponse>;
-        checkout: (branch: string) => Promise<import("./types/socketMessageTypes").GitCheckoutResponse>;
-        branch: (branch: string) => Promise<import("./types/socketMessageTypes").GitBranchResponse>;
-        logs: (path: string) => Promise<import("./types/socketMessageTypes").GitLogsResponse>;
-        diff: (commitHash: string) => Promise<import("./types/socketMessageTypes").GitDiffResponse>;
-    };
-    llm: {
-        inference: (message: string, llmrole: string) => Promise<LLMResponse>;
-    };
-    browser: {
-        newPage: () => Promise<import("./types/socketMessageTypes").BrowserActionResponseData>;
-        getUrl: () => Promise<import("./types/socketMessageTypes").UrlResponse>;
-        goToPage: (url: string) => Promise<import("./types/socketMessageTypes").GoToPageResponse>;
-        screenshot: () => Promise<import("./types/socketMessageTypes").BrowserScreenshotResponse>;
-        getHTML: () => Promise<import("./types/socketMessageTypes").HtmlReceived>;
-        getMarkdown: () => Promise<import("./types/socketMessageTypes").GetMarkdownResponse>;
-        getPDF: () => void;
-        pdfToText: () => void;
-        getContent: () => Promise<import("./types/socketMessageTypes").GetContentResponse>;
-        getSnapShot: () => Promise<import("./types/socketMessageTypes").BrowserSnapshotResponse>;
-        getBrowserInfo: () => Promise<import("./types/socketMessageTypes").BrowserInfoResponse>;
-        extractText: () => Promise<import("./types/socketMessageTypes").ExtractTextResponse>;
-        close: () => void;
-        scroll: (direction: string, pixels: string) => Promise<import("./types/socketMessageTypes").BrowserActionResponseData>;
-        type: (elementid: string, text: string) => Promise<import("./types/socketMessageTypes").BrowserActionResponseData>;
-        click: (elementid: string) => Promise<import("./types/socketMessageTypes").BrowserActionResponseData>;
-        enter: () => Promise<import("./types/socketMessageTypes").BrowserActionResponseData>;
-        search: (elementid: string, query: string) => Promise<import("./types/socketMessageTypes").BrowserActionResponseData>;
-    };
-    chat: {
-        getChatHistory: () => Promise<import("./types/socketMessageTypes").ChatMessage[]>;
-        setRequestHandler: (handler: (request: any, response: (data: any) => void) => void | Promise<void>) => void;
-        sendMessage: (message: string, payload: any) => void;
-        waitforReply: (message: string) => Promise<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: "browser" | "terminal" | "git" | "debug" | "planner" | "editor" | "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;
-            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)[];
-        };
-        executeCommand: (command: string, returnEmptyStringOnSuccess?: boolean) => Promise<any>;
-        executeCommandRunUntilError: (command: string, executeInMain?: boolean) => Promise<import("./types/socketMessageTypes").CommandError>;
-        sendManualInterrupt(): Promise<import("./types/socketMessageTypes").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;
-            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)[];
-        };
-    };
-    codeutils: {
-        getJsTree: (filePath?: string | undefined) => Promise<import("./types/InternalTypes").JSTreeResponse>;
-        getAllFilesAsMarkDown: () => Promise<string>;
-        performMatch: (matcherDefinition: object, problemPatterns: any[], problems?: any[]) => Promise<import("./types/socketMessageTypes").MatchProblemResponse>;
-        getMatcherList: () => Promise<import("./types/socketMessageTypes").GetMatcherListTreeResponse>;
-        matchDetail: (matcher: string) => Promise<import("./types/socketMessageTypes").getMatchDetail>;
-    };
-    crawler: {
-        start: () => void;
-        screenshot: () => void;
-        goToPage: (url: string) => void;
-        scroll: (direction: string) => void;
-        click: (id: string) => Promise<any>;
-    };
-    search: {
-        init: (engine?: string) => void;
-        search: (query: string) => Promise<string>;
-        get_first_link: (query: string) => Promise<string>;
-    };
-    knowledge: {};
-    rag: {
-        init: () => void;
-        add_file: (filename: string, file_path: string) => void;
-        retrieve_related_knowledge: (query: string, filename: string) => void;
-    };
-    codeparsers: {
-        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("./types/commonTypes").ASTNode | {
-            error: string;
-        }>;
-    };
-    outputparsers: {
-        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: () => Promise<any>;
-        getProjectPath: () => Promise<import("./types/socketMessageTypes").GetProjectPathResponse>;
-        getRepoMap: (message: any) => Promise<import("./types/socketMessageTypes").GetProjectPathResponse>;
-        runProject: () => void;
-        getEditorFileStatus: () => Promise<any>;
-    };
-    dbmemory: {
-        addKnowledge: (key: string, value: any) => Promise<import("./types/socketMessageTypes").MemorySetResponse>;
-        getKnowledge: (key: string) => Promise<import("./types/socketMessageTypes").MemoryGetResponse>;
-    };
-    cbstate: {
-        getApplicationState: () => Promise<import("./types/commonTypes").ApplicationState>;
-        addToAgentState: (key: string, value: string) => Promise<import("./types/socketMessageTypes").AddToAgentStateResponse>;
-        getAgentState: () => Promise<import("./types/socketMessageTypes").GetAgentStateResponse>;
-        getProjectState: () => Promise<any>;
-        updateProjectState: (key: string, value: any) => Promise<any>;
-    };
-    taskplaner: {
-        addTask: (task: string) => Promise<any>;
-        getTasks: () => Promise<any>;
-        updateTask: (task: string) => Promise<any>;
-    };
-    vectordb: {
-        getVector: (key: string) => Promise<import("./types/socketMessageTypes").GetVectorResponse>;
-        addVectorItem: (item: any) => Promise<import("./types/socketMessageTypes").AddVectorItemResponse>;
-        queryVectorItem: (key: string) => Promise<import("./types/socketMessageTypes").QueryVectorItemResponse>;
-        queryVectorItems: (items: [], dbPath: string) => Promise<import("./types/socketMessageTypes").QueryVectorItemResponse>;
-    };
-    debug: {
-        debug: (log: string, type: import("./modules/debug").logType) => Promise<import("./types/socketMessageTypes").DebugAddLogResponse>;
-        openDebugBrowser: (url: string, port: number) => Promise<import("./types/socketMessageTypes").OpenDebugBrowserResponse>;
-    };
-    tokenizer: {
-        addToken: (key: string) => Promise<import("./types/socketMessageTypes").AddTokenResponse>;
-        getToken: (key: string) => Promise<import("./types/socketMessageTypes").GetTokenResponse>;
-    };
-    chatSummary: {
-        summarizeAll: () => Promise<import("./types/socketMessageTypes").GetSummarizeAllResponse>;
-        summarize: (messages: {
-            role: string;
-            content: string;
-        }[], depth: number) => Promise<import("./types/socketMessageTypes").GetSummarizeResponse>;
-    };
-    mcp: {
-        getEnabledMCPServers: () => Promise<import("./types/socketMessageTypes").GetEnabledToolBoxesResponse>;
-        getLocalMCPServers: () => Promise<import("./types/socketMessageTypes").GetLocalToolBoxesResponse>;
-        getMentionedMCPServers: (userMessage: import("./utils").UserMessage) => Promise<import("./types/socketMessageTypes").GetAvailableToolBoxesResponse>;
-        searchAvailableMCPServers: (query: string) => Promise<import("./types/socketMessageTypes").SearchAvailableToolBoxesResponse>;
-        listMcpFromServers: (toolBoxes: string[]) => Promise<import("./types/socketMessageTypes").ListToolsFromToolBoxesResponse>;
-        configureMCPServer: (name: string, config: any) => Promise<import("./types/socketMessageTypes").ConfigureToolBoxResponse>;
-        getTools: (tools: {
-            toolbox: string;
-            toolName: string;
-        }[]) => Promise<import("./types/socketMessageTypes").GetToolsResponse>;
-        executeTool: (toolbox: string, toolName: string, params: any) => Promise<import("./types/socketMessageTypes").ExecuteToolResponse>;
-    };
-    agent: {
-        findAgent: (task: string, maxResult: number | undefined, agents: never[] | undefined, agentLocaltion: import("./modules/agent").AgentLocation | undefined, getFrom: import("./modules/agent").FilterUsing.USE_VECTOR_DB) => Promise<import("./types/socketMessageTypes").FindAgentByTaskResponse>;
-        startAgent: (agentId: string, task: string) => Promise<import("./types/socketMessageTypes").TaskCompletionResponse>;
-        getAgentsList: (type?: import("./modules/agent").Agents) => Promise<import("./types/socketMessageTypes").ListAgentsResponse>;
-        getAgentsDetail: (agentList?: never[]) => Promise<import("./types/socketMessageTypes").AgentsDetailResponse>;
-    };
-    utils: {
-        editFileAndApplyDiff: (filePath: string, diff: string, diffIdentifier: string, prompt: string, applyModel?: string | undefined) => Promise<import("./types/socketMessageTypes").FsEditFileAndApplyDiffResponse>;
-    };
-    /**
-     * 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: ChatMessageFromUser) => void | Promise<void> | any | Promise<any>): void;
-}
+import Codebolt from './core/Codebolt';
+export type { Message, ToolCall, Tool, UserMessage, LLMInferenceParams, APIResponse, CodeboltConfig, ProgressCallback, ErrorCallback, SuccessCallback, CompletionCallback, OpenAIMessage, OpenAITool, ConversationEntry, ToolResult, ToolDetails, UserMessageContent, CodeboltAPI, ReadFileOptions, WriteFileOptions, ListFilesOptions, SearchFilesOptions, GrepSearchOptions, BrowserNavigationOptions, BrowserScreenshotOptions, BrowserElementSelector, TerminalExecuteOptions, GitCommitOptions, GitLogOptions, LLMChatOptions, VectorAddOptions, VectorQueryOptions, AgentMessageHandler, AgentConfiguration, MemorySetOptions, MemoryGetOptions, TaskCreateOptions, TaskUpdateOptions, CodeAnalysisOptions, CodeParseOptions, DebugLogOptions, ProjectInfo, CrawlerOptions, MCPExecuteOptions, MCPConfigureOptions, StateUpdateOptions, ChatSendOptions, ChatHistoryOptions, NotificationOptions, PaginationOptions, FilterOptions, AsyncOperationOptions, APIEventMap } from './types/libFunctionTypes';
+export type { GitFileStatus, StatusResult, CommitSummary, DiffResult, AgentFunction, AgentDetail, Agent, Task, VectorItem, VectorQueryResult, FileEntry, SearchMatch, SearchResult, BrowserElement, CodeIssue, CodeAnalysis, CodeMatcher, MCPTool, MCPServer, ASTNode, Notification, DeepPartial, DeepRequired, Optional, Required } from './types/commonTypes';
 declare const codebolt: Codebolt;
 export default codebolt;
+export { Codebolt };

package/dist/index.js

@@ -3,145 +3,19 @@ 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("./core/websocket"));
-const fs_1 = __importDefault(require("./modules/fs"));
-const llm_1 = __importDefault(require("./modules/llm"));
-const terminal_1 = __importDefault(require("./modules/terminal"));
-const browser_1 = __importDefault(require("./modules/browser"));
-const chat_1 = __importDefault(require("./modules/chat"));
-const codeutils_1 = __importDefault(require("./modules/codeutils"));
-const crawler_1 = __importDefault(require("./modules/crawler"));
-const search_1 = __importDefault(require("./modules/search"));
-const knowledge_1 = __importDefault(require("./modules/knowledge"));
-const rag_1 = __importDefault(require("./modules/rag"));
-const codeparsers_1 = __importDefault(require("./modules/codeparsers"));
-const outputparsers_1 = __importDefault(require("./modules/outputparsers"));
-const project_1 = __importDefault(require("./modules/project"));
-const git_1 = __importDefault(require("./modules/git"));
-const dbmemory_1 = __importDefault(require("./modules/dbmemory"));
-const state_1 = __importDefault(require("./modules/state"));
-const task_1 = __importDefault(require("./modules/task"));
-const vectordb_1 = __importDefault(require("./modules/vectordb"));
-const debug_1 = __importDefault(require("./modules/debug"));
-const tokenizer_1 = __importDefault(require("./modules/tokenizer"));
-const history_1 = require("./modules/history");
-const mcp_1 = __importDefault(require("./modules/mcp"));
-const agent_1 = __importDefault(require("./modules/agent"));
-const utils_1 = __importDefault(require("./modules/utils"));
-/**
- * @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 = null;
-        this.isReady = false;
-        this.fs = fs_1.default;
-        this.git = git_1.default;
-        this.llm = llm_1.default;
-        this.browser = browser_1.default;
-        this.chat = chat_1.default;
-        this.terminal = terminal_1.default;
-        this.codeutils = codeutils_1.default;
-        this.crawler = crawler_1.default;
-        this.search = search_1.default;
-        this.knowledge = knowledge_1.default;
-        this.rag = rag_1.default;
-        this.codeparsers = codeparsers_1.default;
-        this.outputparsers = outputparsers_1.default;
-        this.project = project_1.default;
-        this.dbmemory = dbmemory_1.default;
-        this.cbstate = state_1.default;
-        this.taskplaner = task_1.default;
-        this.vectordb = vectordb_1.default;
-        this.debug = debug_1.default;
-        this.tokenizer = tokenizer_1.default;
-        this.chatSummary = history_1.chatSummary;
-        this.mcp = mcp_1.default;
-        this.agent = agent_1.default;
-        this.utils = utils_1.default;
-        console.log("Codebolt Agent initialized");
-        this.readyPromise = this.initializeConnection();
-    }
-    /**
-     * @method initializeConnection
-     * @description Initializes the WebSocket connection asynchronously.
-     * @private
-     */
-    async initializeConnection() {
-        try {
-            await websocket_1.default.initializeWebSocket();
-            this.websocket = websocket_1.default.getWebsocket;
-            this.isReady = true;
-            console.log("Codebolt WebSocket connection established");
-        }
-        catch (error) {
-            console.error('Failed to initialize WebSocket connection:', error);
-            throw error;
-        }
-    }
-    /**
-     * @method waitForReady
-     * @description Waits for the Codebolt instance to be fully initialized.
-     * @returns {Promise<void>} A promise that resolves when the instance is ready.
-     */
-    async waitForReady() {
-        return this.readyPromise;
-    }
-    /**
-     * @method isReady
-     * @description Checks if the Codebolt instance is ready for use.
-     * @returns {boolean} True if the instance is ready, false otherwise.
-     */
-    get ready() {
-        return this.isReady;
-    }
-    /**
-     * 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) {
-        // Wait for the WebSocket to be ready before setting up the handler
-        this.waitForReady().then(() => {
-            const handleUserMessage = async (response) => {
-                console.log("Message received By Agent Library Starting Custom Agent Handler Logic");
-                if (response.type === "messageResponse") {
-                    try {
-                        const result = await handler(response.message);
-                        // 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);
-        }).catch(error => {
-            console.error('Failed to set up message handler:', error);
-        });
-    }
-}
-const codebolt = new Codebolt();
+exports.Codebolt = void 0;
+const Codebolt_1 = __importDefault(require("./core/Codebolt"));
+exports.Codebolt = Codebolt_1.default;
+// ================================
+// Main Library Instance
+// ================================
+const codebolt = new Codebolt_1.default();
+// ================================
+// Export the Main Instance and Class
+// ================================
 // For ES6 modules (import)
 exports.default = codebolt;
 // For CommonJS compatibility (require)
 module.exports = codebolt;
 module.exports.default = codebolt;
+module.exports.Codebolt = Codebolt_1.default;

package/dist/types/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Codebolt Types - Essential type exports for the codeboltjs library
+ *
+ * This file provides easy access to all user-facing types exported by the library.
+ * Users can import types from here for better organization.
+ *
+ * Usage:
+ * ```typescript
+ * import type { Message, ToolCall, APIResponse } from 'codeboltjs/types';
+ * // or
+ * import type { LLMChatOptions, BrowserScreenshotOptions } from 'codeboltjs/types';
+ * ```
+ */
+export type { Message, ToolCall, Tool, UserMessage, LLMInferenceParams, APIResponse, CodeboltConfig, ProgressCallback, ErrorCallback, SuccessCallback, CompletionCallback, OpenAIMessage, OpenAITool, ConversationEntry, ToolResult, ToolDetails, UserMessageContent, CodeboltAPI, ReadFileOptions, WriteFileOptions, ListFilesOptions, SearchFilesOptions, GrepSearchOptions, BrowserNavigationOptions, BrowserScreenshotOptions, BrowserElementSelector, TerminalExecuteOptions, GitCommitOptions, GitLogOptions, LLMChatOptions, VectorAddOptions, VectorQueryOptions, AgentMessageHandler, AgentConfiguration, MemorySetOptions, MemoryGetOptions, TaskCreateOptions, TaskUpdateOptions, CodeAnalysisOptions, CodeParseOptions, DebugLogOptions, ProjectInfo, CrawlerOptions, MCPExecuteOptions, MCPConfigureOptions, StateUpdateOptions, ChatSendOptions, ChatHistoryOptions, NotificationOptions, PaginationOptions, FilterOptions, AsyncOperationOptions, APIEventMap } from './libFunctionTypes';
+export type { GitFileStatus, StatusResult, CommitSummary, DiffResult, AgentFunction, AgentDetail, Agent, Task, VectorItem, VectorQueryResult, FileEntry, SearchMatch, SearchResult, BrowserElement, CodeIssue, CodeAnalysis, CodeMatcher, MCPTool, MCPServer, ASTNode, Notification, DeepPartial, DeepRequired, Optional, Required } from './commonTypes';

package/dist/types/index.js

@@ -0,0 +1,15 @@
+"use strict";
+/**
+ * Codebolt Types - Essential type exports for the codeboltjs library
+ *
+ * This file provides easy access to all user-facing types exported by the library.
+ * Users can import types from here for better organization.
+ *
+ * Usage:
+ * ```typescript
+ * import type { Message, ToolCall, APIResponse } from 'codeboltjs/types';
+ * // or
+ * import type { LLMChatOptions, BrowserScreenshotOptions } from 'codeboltjs/types';
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/libFunctionTypes.d.ts

@@ -166,6 +166,35 @@ export interface UserMessageContent {
     /** The text content */
     text: string;
 }
+/**
+ * User message received from the Codebolt platform
+ * This is a simplified, user-friendly version of the internal message format
+ */
+export interface UserMessage {
+    /** The user's message content */
+    userMessage: string;
+    /** Current file being worked on */
+    currentFile: string;
+    /** Files mentioned in the message */
+    mentionedFiles: string[];
+    /** Full file paths mentioned */
+    mentionedFullPaths: string[];
+    /** Folders mentioned */
+    mentionedFolders: string[];
+    /** Images uploaded with the message */
+    uploadedImages: string[];
+    /** Selected agent information */
+    selectedAgent: {
+        id: string;
+        name: string;
+    };
+    /** Unique message identifier */
+    messageId: string;
+    /** Thread identifier */
+    threadId: string;
+    /** Any text selection in the editor */
+    selection?: any;
+}
 /**
  * Interface for codebolt API functionality
  */
@@ -330,7 +359,7 @@ export interface VectorQueryOptions {
     minScore?: number;
 }
 export interface AgentMessageHandler {
-    (userMessage: any): void | Promise<void> | any | Promise<any>;
+    (userMessage: UserMessage): void | Promise<void> | any | Promise<any>;
 }
 export interface AgentConfiguration {
     /** Agent name */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codebolt/codeboltjs",
-  "version": "2.0.12",
+  "version": "2.0.13",
   "description": "",
   "keywords": [],
   "author": "",