@codebolt/codeboltjs 5.0.2 → 5.0.4

package/dist/modules/reviewMergeRequest.js

@@ -0,0 +1,193 @@
+"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");
+/**
+ * Review Merge Request service client for codeboltjs.
+ */
+const reviewMergeRequestService = {
+    /**
+     * List review merge requests
+     */
+    list: async (filters = {}) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'reviewMergeRequest.list',
+            action: 'list',
+            requestId,
+            message: filters
+        }, 'reviewMergeRequestListResponse');
+    },
+    /**
+     * Get a single review merge request
+     */
+    get: async (id) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'reviewMergeRequest.get',
+            action: 'get',
+            requestId,
+            message: { id }
+        }, 'reviewMergeRequestGetResponse');
+    },
+    /**
+     * Create a new review merge request
+     */
+    create: async (data) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'reviewMergeRequest.create',
+            action: 'create',
+            requestId,
+            message: data
+        }, 'reviewMergeRequestCreateResponse');
+    },
+    /**
+     * Update an existing review merge request
+     */
+    update: async (id, data) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'reviewMergeRequest.update',
+            action: 'update',
+            requestId,
+            message: { id, ...data }
+        }, 'reviewMergeRequestUpdateResponse');
+    },
+    /**
+     * Delete a review merge request
+     */
+    delete: async (id) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'reviewMergeRequest.delete',
+            action: 'delete',
+            requestId,
+            message: { id }
+        }, 'reviewMergeRequestDeleteResponse');
+    },
+    /**
+     * Add review feedback
+     */
+    addReview: async (id, feedback) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'reviewMergeRequest.addReview',
+            action: 'addReview',
+            requestId,
+            message: { id, ...feedback }
+        }, 'reviewMergeRequestAddReviewResponse');
+    },
+    /**
+     * Update status
+     */
+    updateStatus: async (id, status) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'reviewMergeRequest.updateStatus',
+            action: 'updateStatus',
+            requestId,
+            message: { id, status }
+        }, 'reviewMergeRequestUpdateStatusResponse');
+    },
+    /**
+     * Merge request
+     */
+    merge: async (id, mergedBy) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'reviewMergeRequest.merge',
+            action: 'merge',
+            requestId,
+            message: { id, mergedBy }
+        }, 'reviewMergeRequestMergeResponse');
+    },
+    /**
+     * Add linked job
+     */
+    addLinkedJob: async (id, jobId) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'reviewMergeRequest.addLinkedJob',
+            action: 'addLinkedJob',
+            requestId,
+            message: { id, jobId }
+        }, 'reviewMergeRequestAddLinkedJobResponse');
+    },
+    /**
+     * Remove linked job
+     */
+    removeLinkedJob: async (id, jobId) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'reviewMergeRequest.removeLinkedJob',
+            action: 'removeLinkedJob',
+            requestId,
+            message: { id, jobId }
+        }, 'reviewMergeRequestRemoveLinkedJobResponse');
+    },
+    /**
+     * Get pending reviews
+     */
+    pending: async () => {
+        const requestId = (0, crypto_1.randomUUID)();
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'reviewMergeRequest.pending',
+            action: 'pending',
+            requestId,
+            message: {}
+        }, 'reviewMergeRequestPendingResponse');
+    },
+    /**
+     * Get ready to merge requests
+     */
+    readyToMerge: async () => {
+        const requestId = (0, crypto_1.randomUUID)();
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'reviewMergeRequest.readyToMerge',
+            action: 'readyToMerge',
+            requestId,
+            message: {}
+        }, 'reviewMergeRequestReadyToMergeResponse');
+    },
+    /**
+     * Get requests by agent
+     */
+    byAgent: async (agentId) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'reviewMergeRequest.byAgent',
+            action: 'byAgent',
+            requestId,
+            message: { agentId }
+        }, 'reviewMergeRequestByAgentResponse');
+    },
+    /**
+     * Get requests by swarm
+     */
+    bySwarm: async (swarmId) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'reviewMergeRequest.bySwarm',
+            action: 'bySwarm',
+            requestId,
+            message: { swarmId }
+        }, 'reviewMergeRequestBySwarmResponse');
+    },
+    /**
+     * Get statistics
+     */
+    statistics: async () => {
+        const requestId = (0, crypto_1.randomUUID)();
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'reviewMergeRequest.statistics',
+            action: 'statistics',
+            requestId,
+            message: {}
+        }, 'reviewMergeRequestStatisticsResponse');
+    }
+};
+exports.default = reviewMergeRequestService;

package/dist/modules/roadmap.d.ts

@@ -0,0 +1,78 @@
+import type { CreatePhaseData, UpdatePhaseData, CreateFeatureData, UpdateFeatureData, MoveFeatureData, CreateIdeaData, UpdateIdeaData, ReviewIdeaData, MoveIdeaToRoadmapData, RoadmapGetResponse, RoadmapPhasesResponse, RoadmapPhaseResponse, RoadmapDeleteResponse, RoadmapFeaturesResponse, RoadmapFeatureResponse, RoadmapIdeasResponse, RoadmapIdeaResponse, RoadmapMoveToRoadmapResponse } from '../types/roadmap';
+/**
+ * Roadmap Module for codeboltjs
+ * Provides functionality for managing project roadmaps, phases, features, and ideas.
+ * Mirrors the roadmapService.cli.ts operations via WebSocket.
+ */
+declare const codeboltRoadmap: {
+    /**
+     * Get the complete roadmap for a project
+     * @param projectPath - Optional project path (uses active project if not provided)
+     */
+    getRoadmap: (projectPath?: string) => Promise<RoadmapGetResponse>;
+    /**
+     * Get all phases in the roadmap
+     */
+    getPhases: (projectPath?: string) => Promise<RoadmapPhasesResponse>;
+    /**
+     * Create a new phase in the roadmap
+     */
+    createPhase: (data: CreatePhaseData, projectPath?: string) => Promise<RoadmapPhaseResponse>;
+    /**
+     * Update an existing phase
+     */
+    updatePhase: (phaseId: string, data: UpdatePhaseData, projectPath?: string) => Promise<RoadmapPhaseResponse>;
+    /**
+     * Delete a phase from the roadmap
+     */
+    deletePhase: (phaseId: string, projectPath?: string) => Promise<RoadmapDeleteResponse>;
+    /**
+     * Get features in a specific phase
+     */
+    getFeatures: (phaseId: string, projectPath?: string) => Promise<RoadmapFeaturesResponse>;
+    /**
+     * Get all features across all phases
+     */
+    getAllFeatures: (projectPath?: string) => Promise<RoadmapFeaturesResponse>;
+    /**
+     * Create a new feature in a phase
+     */
+    createFeature: (phaseId: string, data: CreateFeatureData, projectPath?: string) => Promise<RoadmapFeatureResponse>;
+    /**
+     * Update an existing feature
+     */
+    updateFeature: (featureId: string, data: UpdateFeatureData, projectPath?: string) => Promise<RoadmapFeatureResponse>;
+    /**
+     * Delete a feature
+     */
+    deleteFeature: (featureId: string, projectPath?: string) => Promise<RoadmapDeleteResponse>;
+    /**
+     * Move a feature to a different phase
+     */
+    moveFeature: (featureId: string, data: MoveFeatureData, projectPath?: string) => Promise<RoadmapFeatureResponse>;
+    /**
+     * Get all ideas (pre-roadmap suggestions)
+     */
+    getIdeas: (projectPath?: string) => Promise<RoadmapIdeasResponse>;
+    /**
+     * Create a new idea
+     */
+    createIdea: (data: CreateIdeaData, projectPath?: string) => Promise<RoadmapIdeaResponse>;
+    /**
+     * Update an existing idea
+     */
+    updateIdea: (ideaId: string, data: UpdateIdeaData, projectPath?: string) => Promise<RoadmapIdeaResponse>;
+    /**
+     * Delete an idea
+     */
+    deleteIdea: (ideaId: string, projectPath?: string) => Promise<RoadmapDeleteResponse>;
+    /**
+     * Review an idea (accept or reject)
+     */
+    reviewIdea: (ideaId: string, data: ReviewIdeaData, projectPath?: string) => Promise<RoadmapIdeaResponse>;
+    /**
+     * Move an accepted idea to the roadmap as a feature
+     */
+    moveIdeaToRoadmap: (ideaId: string, data: MoveIdeaToRoadmapData, projectPath?: string) => Promise<RoadmapMoveToRoadmapResponse>;
+};
+export default codeboltRoadmap;

package/dist/modules/roadmap.js

@@ -0,0 +1,232 @@
+"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");
+/**
+ * Roadmap Module for codeboltjs
+ * Provides functionality for managing project roadmaps, phases, features, and ideas.
+ * Mirrors the roadmapService.cli.ts operations via WebSocket.
+ */
+const codeboltRoadmap = {
+    // ================================
+    // Roadmap Operations
+    // ================================
+    /**
+     * Get the complete roadmap for a project
+     * @param projectPath - Optional project path (uses active project if not provided)
+     */
+    getRoadmap: async (projectPath) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'roadmapEvent',
+            action: 'roadmap.getRoadmap',
+            requestId,
+            message: { projectPath }
+        }, 'roadmapGetResponse');
+    },
+    // ================================
+    // Phase Operations
+    // ================================
+    /**
+     * Get all phases in the roadmap
+     */
+    getPhases: async (projectPath) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'roadmapEvent',
+            action: 'roadmap.getPhases',
+            requestId,
+            message: { projectPath }
+        }, 'roadmapGetPhasesResponse');
+    },
+    /**
+     * Create a new phase in the roadmap
+     */
+    createPhase: async (data, projectPath) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'roadmapEvent',
+            action: 'roadmap.createPhase',
+            requestId,
+            message: { ...data, projectPath }
+        }, 'roadmapCreatePhaseResponse');
+    },
+    /**
+     * Update an existing phase
+     */
+    updatePhase: async (phaseId, data, projectPath) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'roadmapEvent',
+            action: 'roadmap.updatePhase',
+            requestId,
+            message: { phaseId, ...data, projectPath }
+        }, 'roadmapUpdatePhaseResponse');
+    },
+    /**
+     * Delete a phase from the roadmap
+     */
+    deletePhase: async (phaseId, projectPath) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'roadmapEvent',
+            action: 'roadmap.deletePhase',
+            requestId,
+            message: { phaseId, projectPath }
+        }, 'roadmapDeletePhaseResponse');
+    },
+    // ================================
+    // Feature Operations
+    // ================================
+    /**
+     * Get features in a specific phase
+     */
+    getFeatures: async (phaseId, projectPath) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'roadmapEvent',
+            action: 'roadmap.getFeatures',
+            requestId,
+            message: { phaseId, projectPath }
+        }, 'roadmapGetFeaturesResponse');
+    },
+    /**
+     * Get all features across all phases
+     */
+    getAllFeatures: async (projectPath) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'roadmapEvent',
+            action: 'roadmap.getAllFeatures',
+            requestId,
+            message: { projectPath }
+        }, 'roadmapGetAllFeaturesResponse');
+    },
+    /**
+     * Create a new feature in a phase
+     */
+    createFeature: async (phaseId, data, projectPath) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'roadmapEvent',
+            action: 'roadmap.createFeature',
+            requestId,
+            message: { phaseId, ...data, projectPath }
+        }, 'roadmapCreateFeatureResponse');
+    },
+    /**
+     * Update an existing feature
+     */
+    updateFeature: async (featureId, data, projectPath) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'roadmapEvent',
+            action: 'roadmap.updateFeature',
+            requestId,
+            message: { featureId, ...data, projectPath }
+        }, 'roadmapUpdateFeatureResponse');
+    },
+    /**
+     * Delete a feature
+     */
+    deleteFeature: async (featureId, projectPath) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'roadmapEvent',
+            action: 'roadmap.deleteFeature',
+            requestId,
+            message: { featureId, projectPath }
+        }, 'roadmapDeleteFeatureResponse');
+    },
+    /**
+     * Move a feature to a different phase
+     */
+    moveFeature: async (featureId, data, projectPath) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'roadmapEvent',
+            action: 'roadmap.moveFeature',
+            requestId,
+            message: { featureId, ...data, projectPath }
+        }, 'roadmapMoveFeatureResponse');
+    },
+    // ================================
+    // Idea Operations
+    // ================================
+    /**
+     * Get all ideas (pre-roadmap suggestions)
+     */
+    getIdeas: async (projectPath) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'roadmapEvent',
+            action: 'roadmap.getIdeas',
+            requestId,
+            message: { projectPath }
+        }, 'roadmapGetIdeasResponse');
+    },
+    /**
+     * Create a new idea
+     */
+    createIdea: async (data, projectPath) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'roadmapEvent',
+            action: 'roadmap.createIdea',
+            requestId,
+            message: { ...data, projectPath }
+        }, 'roadmapCreateIdeaResponse');
+    },
+    /**
+     * Update an existing idea
+     */
+    updateIdea: async (ideaId, data, projectPath) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'roadmapEvent',
+            action: 'roadmap.updateIdea',
+            requestId,
+            message: { ideaId, ...data, projectPath }
+        }, 'roadmapUpdateIdeaResponse');
+    },
+    /**
+     * Delete an idea
+     */
+    deleteIdea: async (ideaId, projectPath) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'roadmapEvent',
+            action: 'roadmap.deleteIdea',
+            requestId,
+            message: { ideaId, projectPath }
+        }, 'roadmapDeleteIdeaResponse');
+    },
+    /**
+     * Review an idea (accept or reject)
+     */
+    reviewIdea: async (ideaId, data, projectPath) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'roadmapEvent',
+            action: 'roadmap.reviewIdea',
+            requestId,
+            message: { ideaId, ...data, projectPath }
+        }, 'roadmapReviewIdeaResponse');
+    },
+    /**
+     * Move an accepted idea to the roadmap as a feature
+     */
+    moveIdeaToRoadmap: async (ideaId, data, projectPath) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'roadmapEvent',
+            action: 'roadmap.moveIdeaToRoadmap',
+            requestId,
+            message: { ideaId, ...data, projectPath }
+        }, 'roadmapMoveIdeaToRoadmapResponse');
+    }
+};
+exports.default = codeboltRoadmap;

package/dist/modules/sideExecution.d.ts

@@ -0,0 +1,43 @@
+import type { StartSideExecutionResponse, StopSideExecutionResponse, ListActionBlocksResponse, GetSideExecutionStatusResponse } from '@codebolt/types/sdk';
+export type { ActionBlock, StartSideExecutionResponse, StopSideExecutionResponse, ListActionBlocksResponse, GetSideExecutionStatusResponse } from '@codebolt/types/sdk';
+/**
+ * Side Execution Module
+ * Provides functionality for running code in isolated child processes
+ */
+declare const codeboltSideExecution: {
+    /**
+     * Start a side execution with an ActionBlock path
+     * @param actionBlockPath - Path to the ActionBlock directory
+     * @param params - Additional parameters to pass to the ActionBlock
+     * @param timeout - Execution timeout in milliseconds (default: 5 minutes)
+     * @returns Promise resolving to the side execution ID
+     */
+    startWithActionBlock: (actionBlockPath: string, params?: Record<string, any>, timeout?: number) => Promise<StartSideExecutionResponse>;
+    /**
+     * Start a side execution with inline JavaScript code
+     * @param inlineCode - JavaScript code to execute
+     * @param params - Additional parameters available in the execution context
+     * @param timeout - Execution timeout in milliseconds (default: 5 minutes)
+     * @returns Promise resolving to the side execution ID
+     */
+    startWithCode: (inlineCode: string, params?: Record<string, any>, timeout?: number) => Promise<StartSideExecutionResponse>;
+    /**
+     * Stop a running side execution
+     * @param sideExecutionId - ID of the side execution to stop
+     * @returns Promise resolving to success status
+     */
+    stop: (sideExecutionId: string) => Promise<StopSideExecutionResponse>;
+    /**
+     * List all available ActionBlocks
+     * @param projectPath - Optional project path to search for ActionBlocks
+     * @returns Promise resolving to list of ActionBlocks
+     */
+    listActionBlocks: (projectPath?: string) => Promise<ListActionBlocksResponse>;
+    /**
+     * Get the status of a side execution
+     * @param sideExecutionId - ID of the side execution
+     * @returns Promise resolving to execution status
+     */
+    getStatus: (sideExecutionId: string) => Promise<GetSideExecutionStatusResponse>;
+};
+export default codeboltSideExecution;

package/dist/modules/sideExecution.js

@@ -0,0 +1,81 @@
+"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"));
+/**
+ * Side Execution Module
+ * Provides functionality for running code in isolated child processes
+ */
+const codeboltSideExecution = {
+    /**
+     * Start a side execution with an ActionBlock path
+     * @param actionBlockPath - Path to the ActionBlock directory
+     * @param params - Additional parameters to pass to the ActionBlock
+     * @param timeout - Execution timeout in milliseconds (default: 5 minutes)
+     * @returns Promise resolving to the side execution ID
+     */
+    startWithActionBlock: (actionBlockPath, params, timeout) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'sideExecution',
+            action: 'startSideExecution',
+            actionBlockPath,
+            params,
+            timeout
+        }, 'startSideExecutionResponse');
+    },
+    /**
+     * Start a side execution with inline JavaScript code
+     * @param inlineCode - JavaScript code to execute
+     * @param params - Additional parameters available in the execution context
+     * @param timeout - Execution timeout in milliseconds (default: 5 minutes)
+     * @returns Promise resolving to the side execution ID
+     */
+    startWithCode: (inlineCode, params, timeout) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'sideExecution',
+            action: 'startSideExecution',
+            inlineCode,
+            params,
+            timeout
+        }, 'startSideExecutionResponse');
+    },
+    /**
+     * Stop a running side execution
+     * @param sideExecutionId - ID of the side execution to stop
+     * @returns Promise resolving to success status
+     */
+    stop: (sideExecutionId) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'sideExecution',
+            action: 'stopSideExecution',
+            sideExecutionId
+        }, 'stopSideExecutionResponse');
+    },
+    /**
+     * List all available ActionBlocks
+     * @param projectPath - Optional project path to search for ActionBlocks
+     * @returns Promise resolving to list of ActionBlocks
+     */
+    listActionBlocks: (projectPath) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'sideExecution',
+            action: 'listActionBlocks',
+            projectPath
+        }, 'listActionBlocksResponse');
+    },
+    /**
+     * Get the status of a side execution
+     * @param sideExecutionId - ID of the side execution
+     * @returns Promise resolving to execution status
+     */
+    getStatus: (sideExecutionId) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'sideExecution',
+            action: 'getSideExecutionStatus',
+            sideExecutionId
+        }, 'getSideExecutionStatusResponse');
+    }
+};
+exports.default = codeboltSideExecution;