@codebolt/codeboltjs 5.0.7 → 5.0.9

package/dist/tools/job/job-remove-dependency.js

@@ -0,0 +1,86 @@
+"use strict";
+/**
+ * Job Remove Dependency Tool - Removes a dependency between two jobs
+ * Wraps the SDK's jobService.removeDependency() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JobRemoveDependencyTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const job_1 = __importDefault(require("../../modules/job"));
+class JobRemoveDependencyToolInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        try {
+            const response = await job_1.default.removeDependency(this.params.job_id, this.params.depends_on_job_id);
+            if (!response.job) {
+                return {
+                    llmContent: `Failed to remove dependency: Job not found or operation failed`,
+                    returnDisplay: `Failed to remove dependency between jobs`,
+                    error: {
+                        message: 'Failed to remove dependency: Job not found or operation failed',
+                        type: types_1.ToolErrorType.EXECUTION_FAILED,
+                    },
+                };
+            }
+            return {
+                llmContent: `Successfully removed dependency: ${this.params.job_id} no longer depends on ${this.params.depends_on_job_id}\n\nUpdated Job:\n${JSON.stringify(response.job, null, 2)}`,
+                returnDisplay: `Removed dependency: ${this.params.job_id} -/-> ${this.params.depends_on_job_id}`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error removing dependency: ${errorMessage}`,
+                returnDisplay: `Error removing dependency: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+/**
+ * Implementation of the JobRemoveDependency tool
+ */
+class JobRemoveDependencyTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(JobRemoveDependencyTool.Name, 'JobRemoveDependency', `Removes a dependency between two jobs. The dependency from the first job (job_id) on the second job (depends_on_job_id) will be removed, potentially unblocking the first job.`, types_1.Kind.Edit, {
+            properties: {
+                job_id: {
+                    description: 'The ID of the job to remove a dependency from',
+                    type: 'string',
+                },
+                depends_on_job_id: {
+                    description: 'The ID of the dependency job to remove',
+                    type: 'string',
+                },
+            },
+            required: ['job_id', 'depends_on_job_id'],
+            type: 'object',
+        });
+    }
+    validateToolParamValues(params) {
+        if (!params.job_id || params.job_id.trim() === '') {
+            return "The 'job_id' parameter must be non-empty.";
+        }
+        if (!params.depends_on_job_id || params.depends_on_job_id.trim() === '') {
+            return "The 'depends_on_job_id' parameter must be non-empty.";
+        }
+        if (params.job_id === params.depends_on_job_id) {
+            return "A job cannot have a dependency on itself.";
+        }
+        return null;
+    }
+    createInvocation(params) {
+        return new JobRemoveDependencyToolInvocation(params);
+    }
+}
+exports.JobRemoveDependencyTool = JobRemoveDependencyTool;
+JobRemoveDependencyTool.Name = 'job_remove_dependency';

package/dist/tools/requirementPlan/requirement-plan-add-section.js

@@ -40,7 +40,7 @@ class RequirementPlanAddSectionTool extends base_tool_1.BaseDeclarativeTool {
         super('requirement_plan_add_section', 'Add Section to Requirement Plan', 'Add a section to a requirement plan', types_1.Kind.FileSystem, {
             type: 'object',
             properties: {
-                filePath: { type: 'string', description: 'Path to the plan file' },
+                filePath: { type: 'string', description: 'Path to the plan file or actionplan id' },
                 section: {
                     type: 'object',
                     description: 'Section data to add',

package/dist/tools/requirementPlan/requirement-plan-review.js

@@ -22,7 +22,7 @@ class RequirementPlanReviewInvocation extends base_tool_1.BaseToolInvocation {
                 };
             }
             return {
-                llmContent: `Requirement plan review status: ${response.status || 'pending'}`,
+                llmContent: `Requirement plan review status: ${response.data.status || 'pending'} `,
                 returnDisplay: `Review status: ${response.status || 'pending'}`,
             };
         }

package/dist/tools/review/review-create.js

@@ -40,7 +40,7 @@ class ReviewCreateToolInvocation extends base_tool_1.BaseToolInvocation {
             const response = await reviewMergeRequest_1.default.create(createData);
             return {
                 llmContent: JSON.stringify(response, null, 2),
-                returnDisplay: `Successfully created review request: ${response.request.id}`,
+                returnDisplay: `Successfully created review request: ${response}`,
             };
         }
         catch (error) {

package/dist/tools/reviewMergeRequest/rmr-create.js

@@ -12,6 +12,7 @@ class CreateReviewMergeRequestInvocation extends base_tool_1.BaseToolInvocation
         super(params);
     }
     async execute(_signal) {
+        var _a;
         try {
             // Map tool params to CreateReviewMergeRequest interface
             const response = await reviewMergeRequest_1.default.create({
@@ -25,14 +26,14 @@ class CreateReviewMergeRequestInvocation extends base_tool_1.BaseToolInvocation
                 agentName: this.params.authorId,
                 swarmId: this.params.swarmId,
             });
-            if (!response.request) {
+            const req = ((_a = response.data) === null || _a === void 0 ? void 0 : _a.request) || response.request;
+            if (!req) {
                 return {
                     llmContent: `Error: Failed to create review merge request - no request returned`,
                     returnDisplay: `Error: Failed to create`,
                     error: { message: 'Failed to create', type: types_1.ToolErrorType.EXECUTION_FAILED },
                 };
             }
-            const req = response.request;
             const content = `Review merge request created: ${req.id} - ${req.title} (${req.status})`;
             return { llmContent: content, returnDisplay: content };
         }

package/dist/tools/thread/thread-create-background.js

@@ -95,7 +95,7 @@ class ThreadCreateBackgroundTool extends base_tool_1.BaseDeclarativeTool {
                     type: 'string',
                 },
                 isGrouped: {
-                    description: 'Whether the thread belongs to a group.',
+                    description: 'Whether the thread belongs to a group',
                     type: 'boolean',
                 },
             },

package/dist/tools/utils/schema-validator.d.ts

@@ -5,5 +5,6 @@
  * Simple JSON Schema validator
  */
 export declare class SchemaValidator {
+    private static tryParseJson;
     static validate(schema: unknown, data: unknown): string | null;
 }

package/dist/tools/utils/schema-validator.js

@@ -8,6 +8,16 @@ exports.SchemaValidator = void 0;
  * Simple JSON Schema validator
  */
 class SchemaValidator {
+    static tryParseJson(value) {
+        if (typeof value !== 'string')
+            return value;
+        try {
+            return JSON.parse(value);
+        }
+        catch {
+            return value;
+        }
+    }
     static validate(schema, data) {
         if (!schema || typeof schema !== 'object') {
             return null; // No schema to validate against
@@ -49,7 +59,9 @@ class SchemaValidator {
             const dataObj = data;
             for (const [key, propSchema] of Object.entries(properties)) {
                 if (key in dataObj) {
-                    const propError = this.validate(propSchema, dataObj[key]);
+                    // Try parsing JSON strings before validating nested properties
+                    const resolvedValue = this.tryParseJson(dataObj[key]);
+                    const propError = this.validate(propSchema, resolvedValue);
                     if (propError) {
                         return `Property '${key}': ${propError}`;
                     }

package/dist/types/job.d.ts

@@ -6,7 +6,7 @@ export interface JobGroup {
     createdAt: string;
     updatedAt: string;
 }
-export type JobStatus = 'open' | 'working' | 'hold' | 'closed';
+export type JobStatus = 'open' | 'working' | 'hold' | 'review' | 'closed';
 export type JobType = 'bug' | 'feature' | 'task' | 'epic' | 'chore';
 export type JobPriority = 1 | 2 | 3 | 4;
 export type DependencyType = 'blocks' | 'related' | 'parent-child' | 'discovered-from';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codebolt/codeboltjs",
-  "version": "5.0.7",
+  "version": "5.0.9",
   "description": "",
   "keywords": [],
   "author": "",
@@ -35,7 +35,7 @@
     "uuid": "^11.1.0",
     "ws": "^8.18.3",
     "yargs": "^17.7.2",
-    "@codebolt/types": "5.0.7"
+    "@codebolt/types": "5.0.9"
   },
   "devDependencies": {
     "@types/events": "^3.0.3",

package/dist/modules/codeboltEvent.d.ts

@@ -1,57 +0,0 @@
-/**
- * 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

@@ -1,217 +0,0 @@
-"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/tools/browser/browser-action.d.ts

@@ -1,56 +0,0 @@
-/**
- * Browser Action Tool - Performs browser automation actions
- * Wraps the SDK's cbbrowser methods
- */
-import type { ToolInvocation, ToolResult } from '../types';
-import { BaseDeclarativeTool } from '../base-tool';
-/**
- * Supported browser actions
- */
-export type BrowserActionType = 'navigate' | 'screenshot' | 'click' | 'type' | 'scroll' | 'get_content' | 'get_html' | 'get_markdown' | 'get_url' | 'close' | 'enter' | 'search';
-/**
- * Parameters for the BrowserAction tool
- */
-export interface BrowserActionToolParams {
-    /**
-     * The browser action to perform
-     */
-    action: BrowserActionType;
-    /**
-     * URL for navigate action
-     */
-    url?: string;
-    /**
-     * Element ID for click/type/search actions
-     */
-    element_id?: string;
-    /**
-     * Text for type action
-     */
-    text?: string;
-    /**
-     * Query for search action
-     */
-    query?: string;
-    /**
-     * Scroll direction ('up', 'down', 'left', 'right')
-     */
-    direction?: string;
-    /**
-     * Pixels to scroll
-     */
-    pixels?: string;
-    /**
-     * Browser instance ID (optional)
-     */
-    instance_id?: string;
-}
-/**
- * Implementation of the BrowserAction tool logic
- */
-export declare class BrowserActionTool extends BaseDeclarativeTool<BrowserActionToolParams, ToolResult> {
-    static readonly Name: string;
-    constructor();
-    protected validateToolParamValues(params: BrowserActionToolParams): string | null;
-    protected createInvocation(params: BrowserActionToolParams): ToolInvocation<BrowserActionToolParams, ToolResult>;
-}