@codebolt/codeboltjs 5.0.2 → 5.0.3

package/dist/modules/capability.js

@@ -0,0 +1,208 @@
+"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("../core/websocket"));
+/**
+ * Capability Module
+ * Provides functionality for managing and executing capabilities (Skills, Powers, Talents)
+ *
+ * Implements Requirements: 9.1, 9.2, 9.3, 9.4, 9.5
+ */
+const codeboltCapability = {
+    /**
+     * List all available capabilities with optional filtering
+     * @param filter - Optional filter criteria (type, tags, author)
+     * @returns Promise resolving to list of capabilities
+     *
+     * Requirements: 9.1
+     */
+    listCapabilities: (filter) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'capability',
+            action: 'listCapabilities',
+            filter
+        }, 'listCapabilitiesResponse');
+    },
+    /**
+     * List capabilities by type
+     * @param capabilityType - Type of capabilities to list (skill, power, talent, etc.)
+     * @returns Promise resolving to list of capabilities of the specified type
+     *
+     * Requirements: 9.1
+     */
+    listCapabilitiesByType: (capabilityType) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'capability',
+            action: 'listCapabilities',
+            filter: { type: capabilityType }
+        }, 'listCapabilitiesResponse');
+    },
+    /**
+     * List all available skills
+     * @returns Promise resolving to list of skills
+     *
+     * Requirements: 9.1
+     */
+    listSkills: () => {
+        return codeboltCapability.listCapabilitiesByType('skill');
+    },
+    /**
+     * List all available powers
+     * @returns Promise resolving to list of powers
+     *
+     * Requirements: 9.1
+     */
+    listPowers: () => {
+        return codeboltCapability.listCapabilitiesByType('power');
+    },
+    /**
+     * List all available talents
+     * @returns Promise resolving to list of talents
+     *
+     * Requirements: 9.1
+     */
+    listTalents: () => {
+        return codeboltCapability.listCapabilitiesByType('talent');
+    },
+    /**
+     * Get detailed information about a specific capability
+     * @param capabilityName - Name of the capability
+     * @param capabilityType - Optional type to narrow search
+     * @returns Promise resolving to capability details
+     *
+     * Requirements: 9.2
+     */
+    getCapabilityDetail: (capabilityName, capabilityType) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'capability',
+            action: 'getCapabilityDetail',
+            capabilityName,
+            capabilityType
+        }, 'getCapabilityDetailResponse');
+    },
+    /**
+     * List all available capability executors
+     * @returns Promise resolving to list of executors
+     *
+     * Requirements: 9.3
+     */
+    listExecutors: () => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'capability',
+            action: 'listExecutors'
+        }, 'listExecutorsResponse');
+    },
+    /**
+     * Start a capability execution
+     * @param capabilityName - Name of the capability to execute
+     * @param capabilityType - Type of the capability (skill, power, talent, etc.)
+     * @param params - Optional parameters to pass to the capability
+     * @param timeout - Optional execution timeout in milliseconds
+     * @returns Promise resolving to execution ID
+     *
+     * Requirements: 9.4
+     */
+    startCapability: (capabilityName, capabilityType, params, timeout) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'capability',
+            action: 'startCapability',
+            capabilityName,
+            capabilityType,
+            params,
+            timeout
+        }, 'startCapabilityResponse');
+    },
+    /**
+     * Start a skill execution
+     * @param skillName - Name of the skill to execute
+     * @param params - Optional parameters to pass to the skill
+     * @param timeout - Optional execution timeout in milliseconds
+     * @returns Promise resolving to execution ID
+     *
+     * Requirements: 9.4
+     */
+    startSkill: (skillName, params, timeout) => {
+        return codeboltCapability.startCapability(skillName, 'skill', params, timeout);
+    },
+    /**
+     * Start a power execution
+     * @param powerName - Name of the power to execute
+     * @param params - Optional parameters to pass to the power
+     * @param timeout - Optional execution timeout in milliseconds
+     * @returns Promise resolving to execution ID
+     *
+     * Requirements: 9.4
+     */
+    startPower: (powerName, params, timeout) => {
+        return codeboltCapability.startCapability(powerName, 'power', params, timeout);
+    },
+    /**
+     * Start a talent execution
+     * @param talentName - Name of the talent to execute
+     * @param params - Optional parameters to pass to the talent
+     * @param timeout - Optional execution timeout in milliseconds
+     * @returns Promise resolving to execution ID
+     *
+     * Requirements: 9.4
+     */
+    startTalent: (talentName, params, timeout) => {
+        return codeboltCapability.startCapability(talentName, 'talent', params, timeout);
+    },
+    /**
+     * Stop a running capability execution
+     * @param executionId - ID of the execution to stop
+     * @returns Promise resolving to success status
+     *
+     * Requirements: 9.5
+     */
+    stopCapability: (executionId) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'capability',
+            action: 'stopCapability',
+            executionId
+        }, 'stopCapabilityResponse');
+    },
+    /**
+     * Get the status of a capability execution
+     * @param executionId - ID of the execution
+     * @returns Promise resolving to execution status
+     */
+    getExecutionStatus: (executionId) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'capability',
+            action: 'getExecutionStatus',
+            executionId
+        }, 'getExecutionStatusResponse');
+    },
+    /**
+     * Get capabilities by tag
+     * @param tag - Tag to filter by
+     * @returns Promise resolving to list of capabilities with the specified tag
+     *
+     * Requirements: 9.1
+     */
+    getCapabilitiesByTag: (tag) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'capability',
+            action: 'listCapabilities',
+            filter: { tags: [tag] }
+        }, 'listCapabilitiesResponse');
+    },
+    /**
+     * Get capabilities by author
+     * @param author - Author to filter by
+     * @returns Promise resolving to list of capabilities by the specified author
+     *
+     * Requirements: 9.1
+     */
+    getCapabilitiesByAuthor: (author) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'capability',
+            action: 'listCapabilities',
+            filter: { author }
+        }, 'listCapabilitiesResponse');
+    }
+};
+exports.default = codeboltCapability;

package/dist/modules/chat.d.ts

@@ -58,5 +58,15 @@ declare const cbchat: {
  * @param {string} notificationMessage - The message to be sent in the notification.
  */
     sendNotificationEvent: (notificationMessage: string, type: "debug" | "git" | "planner" | "browser" | "editor" | "terminal" | "preview") => void;
+    /**
+     * Checks if any steering message has been received.
+     * @returns {any} The message data if available, or null
+     */
+    checkForSteeringMessage: () => any;
+    /**
+     * Waits for a steering message.
+     * @returns {Promise<any>} A promise that resolves with the message data
+     */
+    onSteeringMessageReceived: () => Promise<any>;
 };
 export default cbchat;

package/dist/modules/chat.js

@@ -5,7 +5,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 // chat.ts
 const websocket_1 = __importDefault(require("../core/websocket"));
+const crypto_1 = require("crypto");
 const enum_1 = require("@codebolt/types/enum");
+// Steering message state
+let steeringMessageMap = new Map();
+// Subscribe to steering messages
+const steeringSubscription = websocket_1.default.messageManager.subscribe('steeringMessage');
+steeringSubscription.on('message', (message) => {
+    const eventId = (0, crypto_1.randomUUID)();
+    steeringMessageMap.set(eventId, message);
+});
 /**
  * Chat module to interact with the WebSocket server.
  */
@@ -160,5 +169,34 @@ const cbchat = {
             "eventType": type
         });
     },
+    /**
+     * Checks if any steering message has been received.
+     * @returns {any} The message data if available, or null
+     */
+    checkForSteeringMessage: () => {
+        if (steeringMessageMap.size > 0) {
+            const [key, value] = steeringMessageMap.entries().next().value || [];
+            if (key) {
+                steeringMessageMap.delete(key);
+                return value;
+            }
+        }
+        return null;
+    },
+    /**
+     * Waits for a steering message.
+     * @returns {Promise<any>} A promise that resolves with the message data
+     */
+    onSteeringMessageReceived: async () => {
+        const message = cbchat.checkForSteeringMessage();
+        if (message)
+            return message;
+        return new Promise((resolve) => {
+            steeringSubscription.once('message', () => {
+                const data = cbchat.checkForSteeringMessage();
+                resolve(data);
+            });
+        });
+    },
 };
 exports.default = cbchat;

package/dist/modules/codebaseSearch.d.ts

@@ -0,0 +1,21 @@
+import type { CodebaseSearchResponse, McpToolSearchResponse } from '../types/codebaseSearch';
+/**
+ * Codebase Search Module for codeboltjs
+ * Provides semantic code search functionality across the project.
+ * Mirrors the codebaseSearch.cli.ts operations via WebSocket.
+ */
+declare const codeboltCodebaseSearch: {
+    /**
+     * Perform a semantic search across the codebase
+     * @param query - The search query
+     * @param targetDirectories - Optional directories to limit the search
+     */
+    search: (query: string, targetDirectories?: string[]) => Promise<CodebaseSearchResponse>;
+    /**
+     * Search for MCP tools by query and optional tags
+     * @param query - The search query
+     * @param tags - Optional tags to filter results
+     */
+    searchMcpTool: (query: string, tags?: string[]) => Promise<McpToolSearchResponse>;
+};
+export default codeboltCodebaseSearch;

package/dist/modules/codebaseSearch.js

@@ -0,0 +1,43 @@
+"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("../core/websocket"));
+const crypto_1 = require("crypto");
+/**
+ * Codebase Search Module for codeboltjs
+ * Provides semantic code search functionality across the project.
+ * Mirrors the codebaseSearch.cli.ts operations via WebSocket.
+ */
+const codeboltCodebaseSearch = {
+    /**
+     * Perform a semantic search across the codebase
+     * @param query - The search query
+     * @param targetDirectories - Optional directories to limit the search
+     */
+    search: async (query, targetDirectories) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'codebaseSearchEvent',
+            action: 'codebase_search',
+            requestId,
+            message: { query, target_directories: targetDirectories }
+        }, 'codebaseSearchResponse');
+    },
+    /**
+     * Search for MCP tools by query and optional tags
+     * @param query - The search query
+     * @param tags - Optional tags to filter results
+     */
+    searchMcpTool: async (query, tags) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'codebaseSearchEvent',
+            action: 'search_mcp_tool',
+            requestId,
+            message: { query, tags }
+        }, 'mcpToolSearchResponse');
+    }
+};
+exports.default = codeboltCodebaseSearch;

package/dist/modules/codeboltEvent.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Codebolt Event module for handling external events.
+ * This module provides APIs for waiting on and checking for various event types.
+ */
+declare const codeboltEvent: {
+    /**
+     * Adds a running background agent to tracking.
+     * @param {string} threadId - The thread ID
+     * @param {any} data - The agent data
+     * @param {string} [groupId] - Optional group ID
+     */
+    addRunningAgent: (threadId: string, data: any, groupId?: string) => void;
+    /**
+     * Gets the number of currently running background agents.
+     * @returns {number} The count
+     */
+    getRunningAgentCount: () => number;
+    /**
+     * Checks if any background agent has completed.
+     * @returns {any} The completion data if available, or null
+     */
+    checkForBackgroundAgentCompletion: () => any[] | null;
+    /**
+     * Waits for background agent completion.
+     * @returns {Promise<any>} A promise that resolves with the completion data
+     */
+    onBackgroundAgentCompletion: () => Promise<any>;
+    /**
+     * Checks if any grouped background agent has completed.
+     * @returns {any} The completion data if available, or null
+     */
+    checkForBackgroundGroupedAgentCompletion: () => any;
+    /**
+     * Waits for grouped background agent completion.
+     * @returns {Promise<any>} A promise that resolves with the completion data
+     */
+    onBackgroundGroupedAgentCompletion: () => Promise<any>;
+    /**
+     * Checks if any agent event has been received.
+     * @returns {any} The event data if available, or null
+     */
+    checkForAgentEventReceived: () => any;
+    /**
+     * Waits for an agent event.
+     * @returns {Promise<any>} A promise that resolves with the event data
+     */
+    onAgentEventReceived: () => Promise<any>;
+    /**
+     * Waits for any external event (Background Completion, Group Completion, Agent Event).
+     * @returns {Promise<{ type: string, data: any }>} A promise that resolves with the event object
+     */
+    waitForAnyExternalEvent: () => Promise<{
+        type: string;
+        data: any;
+    }>;
+};
+export default codeboltEvent;

package/dist/modules/codeboltEvent.js

@@ -0,0 +1,217 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// codeboltEvent.ts
+const websocket_1 = __importDefault(require("../core/websocket"));
+const crypto_1 = require("crypto");
+// Event state maps - Internal use only
+const runningBackgroundAgents = new Map();
+const completedBackgroundAgents = new Map();
+const agentEventMap = new Map();
+const groupedAgentCompletionMap = new Map();
+const backgroundAgentGroups = new Map();
+// Helper to cleanup group membership
+const cleanupAgentGroup = (threadId) => {
+    for (const [groupId, agents] of backgroundAgentGroups.entries()) {
+        if (agents.has(threadId)) {
+            agents.delete(threadId);
+            if (agents.size === 0) {
+                backgroundAgentGroups.delete(groupId);
+            }
+        }
+    }
+};
+// Handler for background agent completion messages
+const handleBackgroundAgentCompletion = (message) => {
+    // Add to completed queue for orchestrator to process
+    completedBackgroundAgents.set(message.threadId, message);
+    // Remove from running map since agent is now complete
+    runningBackgroundAgents.delete(message.threadId);
+    // Clean up any group associations
+    cleanupAgentGroup(message.threadId);
+};
+// Subscribe to message types
+const agentEventSubscription = websocket_1.default.messageManager.subscribe('agentEvent');
+agentEventSubscription.on('message', (message) => {
+    const eventId = (0, crypto_1.randomUUID)();
+    agentEventMap.set(eventId, message);
+});
+// Subscribe to background agent completion - primary message type
+const backgroundAgentSubscription = websocket_1.default.messageManager.subscribe('startThreadResponse');
+backgroundAgentSubscription.on('message', handleBackgroundAgentCompletion);
+// Also subscribe to ThreadCompleted as an alternative message type for background agent completion
+const threadCompletedSubscription = websocket_1.default.messageManager.subscribe('ThreadCompleted');
+threadCompletedSubscription.on('message', (message) => {
+    // Only handle if this thread was a background agent
+    if (runningBackgroundAgents.has(message.threadId)) {
+        handleBackgroundAgentCompletion(message);
+        // Also emit on the backgroundAgentSubscription for waitForAnyExternalEvent
+        backgroundAgentSubscription.emit('message', message);
+    }
+});
+const groupedAgentSubscription = websocket_1.default.messageManager.subscribe('backgroundGroupedAgentCompletion');
+groupedAgentSubscription.on('message', (message) => {
+    groupedAgentCompletionMap.set(message.threadId, message);
+});
+/**
+ * Codebolt Event module for handling external events.
+ * This module provides APIs for waiting on and checking for various event types.
+ */
+const codeboltEvent = {
+    /**
+     * Adds a running background agent to tracking.
+     * @param {string} threadId - The thread ID
+     * @param {any} data - The agent data
+     * @param {string} [groupId] - Optional group ID
+     */
+    addRunningAgent: (threadId, data, groupId) => {
+        runningBackgroundAgents.set(threadId, data);
+        if (groupId) {
+            if (!backgroundAgentGroups.has(groupId)) {
+                backgroundAgentGroups.set(groupId, new Set());
+            }
+            backgroundAgentGroups.get(groupId).add(threadId);
+        }
+    },
+    /**
+     * Gets the number of currently running background agents.
+     * @returns {number} The count
+     */
+    getRunningAgentCount: () => {
+        return runningBackgroundAgents.size;
+    },
+    /**
+     * Checks if any background agent has completed.
+     * @returns {any} The completion data if available, or null
+     */
+    checkForBackgroundAgentCompletion: () => {
+        if (completedBackgroundAgents.size > 0) {
+            const values = Array.from(completedBackgroundAgents.values());
+            completedBackgroundAgents.clear();
+            return values;
+        }
+        return null;
+    },
+    /**
+     * Waits for background agent completion.
+     * @returns {Promise<any>} A promise that resolves with the completion data
+     */
+    onBackgroundAgentCompletion: async () => {
+        const completion = codeboltEvent.checkForBackgroundAgentCompletion();
+        if (completion)
+            return completion;
+        return new Promise((resolve) => {
+            backgroundAgentSubscription.once('message', () => {
+                const data = codeboltEvent.checkForBackgroundAgentCompletion();
+                resolve(data);
+            });
+        });
+    },
+    /**
+     * Checks if any grouped background agent has completed.
+     * @returns {any} The completion data if available, or null
+     */
+    checkForBackgroundGroupedAgentCompletion: () => {
+        if (groupedAgentCompletionMap.size > 0) {
+            const [key, value] = groupedAgentCompletionMap.entries().next().value || [];
+            if (key) {
+                groupedAgentCompletionMap.delete(key);
+                return value;
+            }
+        }
+        return null;
+    },
+    /**
+     * Waits for grouped background agent completion.
+     * @returns {Promise<any>} A promise that resolves with the completion data
+     */
+    onBackgroundGroupedAgentCompletion: async () => {
+        const completion = codeboltEvent.checkForBackgroundGroupedAgentCompletion();
+        if (completion)
+            return completion;
+        return new Promise((resolve) => {
+            groupedAgentSubscription.once('message', () => {
+                const data = codeboltEvent.checkForBackgroundGroupedAgentCompletion();
+                resolve(data);
+            });
+        });
+    },
+    /**
+     * Checks if any agent event has been received.
+     * @returns {any} The event data if available, or null
+     */
+    checkForAgentEventReceived: () => {
+        if (agentEventMap.size > 0) {
+            const [key, value] = agentEventMap.entries().next().value || [];
+            if (key) {
+                agentEventMap.delete(key);
+                return value;
+            }
+        }
+        return null;
+    },
+    /**
+     * Waits for an agent event.
+     * @returns {Promise<any>} A promise that resolves with the event data
+     */
+    onAgentEventReceived: async () => {
+        const event = codeboltEvent.checkForAgentEventReceived();
+        if (event)
+            return event;
+        return new Promise((resolve) => {
+            agentEventSubscription.once('message', () => {
+                const data = codeboltEvent.checkForAgentEventReceived();
+                resolve(data);
+            });
+        });
+    },
+    /**
+     * Waits for any external event (Background Completion, Group Completion, Agent Event).
+     * @returns {Promise<{ type: string, data: any }>} A promise that resolves with the event object
+     */
+    waitForAnyExternalEvent: async () => {
+        // Check functions mapped to their return type strings
+        const checks = [
+            { fn: () => codeboltEvent.checkForBackgroundAgentCompletion(), type: 'backgroundAgentCompletion' },
+            { fn: () => codeboltEvent.checkForBackgroundGroupedAgentCompletion(), type: 'backgroundGroupedAgentCompletion' },
+            { fn: () => codeboltEvent.checkForAgentEventReceived(), type: 'agentEventReceived' }
+        ];
+        for (const { fn, type } of checks) {
+            const data = fn();
+            if (data)
+                return { type, data };
+        }
+        return new Promise((resolve) => {
+            const cleanup = () => {
+                backgroundAgentSubscription.removeListener('message', onBgComplete);
+                groupedAgentSubscription.removeListener('message', onGroupComplete);
+                agentEventSubscription.removeListener('message', onAgentEvent);
+            };
+            const onBgComplete = () => {
+                // Must unhook first to avoid multi-resolution
+                cleanup();
+                // We must yield slightly to ensure handleBackgroundAgentCompletion has processed the event?
+                // Actually, handleBackgroundAgentCompletion attaches first, so it runs first on the same emitter. 
+                // That should be safe synchronously.
+                const data = codeboltEvent.checkForBackgroundAgentCompletion();
+                resolve({ type: 'backgroundAgentCompletion', data });
+            };
+            const onGroupComplete = () => {
+                cleanup();
+                const data = codeboltEvent.checkForBackgroundGroupedAgentCompletion();
+                resolve({ type: 'backgroundGroupedAgentCompletion', data });
+            };
+            const onAgentEvent = () => {
+                cleanup();
+                const data = codeboltEvent.checkForAgentEventReceived();
+                resolve({ type: 'agentEventReceived', data });
+            };
+            backgroundAgentSubscription.once('message', onBgComplete);
+            groupedAgentSubscription.once('message', onGroupComplete);
+            agentEventSubscription.once('message', onAgentEvent);
+        });
+    }
+};
+exports.default = codeboltEvent;

package/dist/modules/codemap.d.ts

@@ -0,0 +1,38 @@
+import type { Codemap, CodemapStatus, CreateCodemapData, UpdateCodemapData, CodemapListResponse, CodemapGetResponse, CodemapCreateResponse, CodemapSaveResponse, CodemapUpdateResponse, CodemapDeleteResponse } from '../types/codemap';
+/**
+ * Codemap Module for codeboltjs
+ * Provides functionality for managing codemaps (visual representations of code structure).
+ * Mirrors the codemapService.cli.ts operations via WebSocket.
+ */
+declare const codeboltCodemap: {
+    /**
+     * List all codemaps for a project
+     */
+    list: (projectPath?: string) => Promise<CodemapListResponse>;
+    /**
+     * Get a specific codemap by ID
+     */
+    get: (codemapId: string, projectPath?: string) => Promise<CodemapGetResponse>;
+    /**
+     * Create a placeholder codemap (status: 'creating')
+     * Call this before generating the actual codemap content
+     */
+    create: (data: CreateCodemapData, projectPath?: string) => Promise<CodemapCreateResponse>;
+    /**
+     * Save a complete codemap with content
+     */
+    save: (codemapId: string, codemap: Codemap, projectPath?: string) => Promise<CodemapSaveResponse>;
+    /**
+     * Set the status of a codemap
+     */
+    setStatus: (codemapId: string, status: CodemapStatus, error?: string, projectPath?: string) => Promise<CodemapUpdateResponse>;
+    /**
+     * Update codemap info (title, description, etc.)
+     */
+    update: (codemapId: string, data: UpdateCodemapData, projectPath?: string) => Promise<CodemapUpdateResponse>;
+    /**
+     * Delete a codemap
+     */
+    delete: (codemapId: string, projectPath?: string) => Promise<CodemapDeleteResponse>;
+};
+export default codeboltCodemap;