@codebolt/codeboltjs 5.0.8 → 5.1.10

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/registry.d.ts

@@ -2,11 +2,14 @@
  * Tool Registry for managing and executing tools
  */
 import type { AnyDeclarativeTool, ToolResult, OpenAIToolSchema, OpenAIFunctionCall } from './types';
+import { type ToolSearchResult, type ToolSearchOptions } from './tool-search';
 /**
  * Registry for managing tools
  */
 export declare class ToolRegistry {
     private tools;
+    private searchEngine;
+    private searchIndexDirty;
     /**
      * Register a tool with the registry
      * @param tool - The tool to register
@@ -83,6 +86,24 @@ export declare class ToolRegistry {
      * Clear all registered tools
      */
     clear(): void;
+    /**
+     * Ensure the search index is up to date
+     */
+    private ensureSearchIndex;
+    /**
+     * Search for tools matching a query using full-text search
+     * @param query - The search query (e.g. "create environment", "file read", "git commit")
+     * @param options - Search options (limit, fuzzy, prefix, kind filter, boost)
+     * @returns Array of matching tools sorted by relevance
+     */
+    searchTools(query: string, options?: ToolSearchOptions): ToolSearchResult[];
+    /**
+     * Get auto-complete suggestions for a partial query
+     * @param query - The partial query to get suggestions for
+     * @param options - Search options (limit, fuzzy, kind filter)
+     * @returns Array of suggested tool matches
+     */
+    suggestTools(query: string, options?: ToolSearchOptions): ToolSearchResult[];
 }
 /**
  * Default global registry instance

package/dist/tools/registry.js

@@ -5,12 +5,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.defaultRegistry = exports.ToolRegistry = void 0;
 const types_1 = require("./types");
+const tool_search_1 = require("./tool-search");
 /**
  * Registry for managing tools
  */
 class ToolRegistry {
     constructor() {
         this.tools = new Map();
+        this.searchEngine = new tool_search_1.ToolSearchEngine();
+        this.searchIndexDirty = true;
     }
     /**
      * Register a tool with the registry
@@ -21,6 +24,7 @@ class ToolRegistry {
             console.warn(`Tool "${tool.name}" is already registered. Overwriting.`);
         }
         this.tools.set(tool.name, tool);
+        this.searchIndexDirty = true;
     }
     /**
      * Register multiple tools at once
@@ -37,7 +41,10 @@ class ToolRegistry {
      * @returns true if the tool was found and removed
      */
     unregisterTool(name) {
-        return this.tools.delete(name);
+        const result = this.tools.delete(name);
+        if (result)
+            this.searchIndexDirty = true;
+        return result;
     }
     /**
      * Get a tool by name
@@ -189,6 +196,36 @@ class ToolRegistry {
      */
     clear() {
         this.tools.clear();
+        this.searchIndexDirty = true;
+    }
+    /**
+     * Ensure the search index is up to date
+     */
+    ensureSearchIndex() {
+        if (this.searchIndexDirty) {
+            this.searchEngine.buildIndex(this.tools);
+            this.searchIndexDirty = false;
+        }
+    }
+    /**
+     * Search for tools matching a query using full-text search
+     * @param query - The search query (e.g. "create environment", "file read", "git commit")
+     * @param options - Search options (limit, fuzzy, prefix, kind filter, boost)
+     * @returns Array of matching tools sorted by relevance
+     */
+    searchTools(query, options) {
+        this.ensureSearchIndex();
+        return this.searchEngine.search(query, options);
+    }
+    /**
+     * Get auto-complete suggestions for a partial query
+     * @param query - The partial query to get suggestions for
+     * @param options - Search options (limit, fuzzy, kind filter)
+     * @returns Array of suggested tool matches
+     */
+    suggestTools(query, options) {
+        this.ensureSearchIndex();
+        return this.searchEngine.suggest(query, options);
     }
 }
 exports.ToolRegistry = ToolRegistry;

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/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/tool-search.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Tool Search Engine - Full-text search over registered tools using MiniSearch
+ */
+import type { AnyDeclarativeTool } from './types';
+export interface ToolSearchResult {
+    /** Tool name (internal identifier) */
+    name: string;
+    /** User-friendly display name */
+    displayName: string;
+    /** Tool description */
+    description: string;
+    /** Tool kind/category */
+    kind: string;
+    /** Search relevance score */
+    score: number;
+}
+export interface ToolSearchOptions {
+    /** Maximum number of results to return (default: 10) */
+    limit?: number;
+    /** Enable fuzzy matching (default: 0.2) */
+    fuzzy?: number | boolean;
+    /** Enable prefix matching (default: true) */
+    prefix?: boolean;
+    /** Filter by tool kind */
+    kind?: string;
+    /** Field-specific boost weights */
+    boost?: Record<string, number>;
+}
+export declare class ToolSearchEngine {
+    private miniSearch;
+    private indexed;
+    constructor();
+    /**
+     * Build the search index from a map of tools
+     */
+    buildIndex(tools: Map<string, AnyDeclarativeTool>): void;
+    /**
+     * Search for tools matching a query
+     */
+    search(query: string, options?: ToolSearchOptions): ToolSearchResult[];
+    /**
+     * Get auto-complete suggestions for a partial query
+     */
+    suggest(query: string, options?: ToolSearchOptions): ToolSearchResult[];
+    /**
+     * Get the number of indexed tools
+     */
+    get size(): number;
+}

package/dist/tools/tool-search.js

@@ -0,0 +1,140 @@
+"use strict";
+/**
+ * Tool Search Engine - Full-text search over registered tools using MiniSearch
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolSearchEngine = void 0;
+const minisearch_1 = __importDefault(require("minisearch"));
+class ToolSearchEngine {
+    constructor() {
+        this.indexed = false;
+        this.miniSearch = new minisearch_1.default({
+            fields: ['name', 'displayName', 'description', 'kind', 'parameterNames'],
+            storeFields: ['name', 'displayName', 'description', 'kind'],
+            searchOptions: {
+                boost: { displayName: 3, description: 2, name: 1.5, kind: 1, parameterNames: 0.5 },
+                fuzzy: 0.2,
+                prefix: true,
+            },
+            tokenize: (text) => {
+                // Split on spaces, underscores, hyphens, and camelCase boundaries
+                return text
+                    .replace(/([a-z])([A-Z])/g, '$1 $2')
+                    .replace(/[_\-]/g, ' ')
+                    .toLowerCase()
+                    .split(/\s+/)
+                    .filter(t => t.length > 0);
+            },
+        });
+    }
+    /**
+     * Build the search index from a map of tools
+     */
+    buildIndex(tools) {
+        var _a, _b;
+        // Clear existing index
+        if (this.indexed) {
+            this.miniSearch.removeAll();
+        }
+        const documents = [];
+        for (const [name, tool] of tools) {
+            const params = (_b = (_a = tool.schema) === null || _a === void 0 ? void 0 : _a.function) === null || _b === void 0 ? void 0 : _b.parameters;
+            const paramNames = (params === null || params === void 0 ? void 0 : params.properties)
+                ? Object.keys(params.properties).filter(p => p !== 'explanation').join(' ')
+                : '';
+            documents.push({
+                id: name,
+                name: tool.name,
+                displayName: tool.displayName,
+                description: tool.description,
+                kind: tool.kind,
+                parameterNames: paramNames,
+            });
+        }
+        this.miniSearch.addAll(documents);
+        this.indexed = true;
+    }
+    /**
+     * Search for tools matching a query
+     */
+    search(query, options) {
+        var _a;
+        if (!this.indexed) {
+            return [];
+        }
+        const limit = (_a = options === null || options === void 0 ? void 0 : options.limit) !== null && _a !== void 0 ? _a : 10;
+        const searchOpts = {};
+        if ((options === null || options === void 0 ? void 0 : options.fuzzy) !== undefined) {
+            searchOpts.fuzzy = options.fuzzy;
+        }
+        if ((options === null || options === void 0 ? void 0 : options.prefix) !== undefined) {
+            searchOpts.prefix = options.prefix;
+        }
+        if (options === null || options === void 0 ? void 0 : options.boost) {
+            searchOpts.boost = options.boost;
+        }
+        if (options === null || options === void 0 ? void 0 : options.kind) {
+            const kindFilter = options.kind;
+            searchOpts.filter = (result) => result.kind === kindFilter;
+        }
+        const results = this.miniSearch.search(query, searchOpts);
+        return results.slice(0, limit).map(r => ({
+            name: r.name,
+            displayName: r.displayName,
+            description: r.description,
+            kind: r.kind,
+            score: r.score,
+        }));
+    }
+    /**
+     * Get auto-complete suggestions for a partial query
+     */
+    suggest(query, options) {
+        var _a;
+        if (!this.indexed) {
+            return [];
+        }
+        const limit = (_a = options === null || options === void 0 ? void 0 : options.limit) !== null && _a !== void 0 ? _a : 5;
+        const suggestOpts = {};
+        if ((options === null || options === void 0 ? void 0 : options.fuzzy) !== undefined) {
+            suggestOpts.fuzzy = options.fuzzy;
+        }
+        if (options === null || options === void 0 ? void 0 : options.kind) {
+            const kindFilter = options.kind;
+            suggestOpts.filter = (result) => result.kind === kindFilter;
+        }
+        const suggestions = this.miniSearch.autoSuggest(query, suggestOpts);
+        // autoSuggest returns grouped suggestions; map them to tool results
+        const toolNames = new Set();
+        const results = [];
+        for (const suggestion of suggestions) {
+            // Search for this suggestion to get actual tool matches
+            const searchResults = this.miniSearch.search(suggestion.suggestion, { prefix: true });
+            for (const r of searchResults) {
+                if (!toolNames.has(r.name) && results.length < limit) {
+                    toolNames.add(r.name);
+                    results.push({
+                        name: r.name,
+                        displayName: r.displayName,
+                        description: r.description,
+                        kind: r.kind,
+                        score: r.score * suggestion.score,
+                    });
+                }
+            }
+            if (results.length >= limit)
+                break;
+        }
+        return results;
+    }
+    /**
+     * Get the number of indexed tools
+     */
+    get size() {
+        return this.miniSearch.documentCount;
+    }
+}
+exports.ToolSearchEngine = ToolSearchEngine;

package/dist/tools/toolSearch/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Tool Search Tool - Searches for available tools using full-text search (MiniSearch)
+ */
+export { ToolSearchTool, type ToolSearchToolParams } from './tool-search-tool';
+import { ToolSearchTool } from './tool-search-tool';
+/**
+ * All tool search tools
+ */
+export declare const toolSearchTools: ToolSearchTool[];

package/dist/tools/toolSearch/index.js

@@ -0,0 +1,15 @@
+"use strict";
+/**
+ * Tool Search Tool - Searches for available tools using full-text search (MiniSearch)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toolSearchTools = exports.ToolSearchTool = void 0;
+var tool_search_tool_1 = require("./tool-search-tool");
+Object.defineProperty(exports, "ToolSearchTool", { enumerable: true, get: function () { return tool_search_tool_1.ToolSearchTool; } });
+const tool_search_tool_2 = require("./tool-search-tool");
+/**
+ * All tool search tools
+ */
+exports.toolSearchTools = [
+    new tool_search_tool_2.ToolSearchTool(),
+];

package/dist/tools/toolSearch/tool-search-tool.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Tool Search Tool - An LLM-callable tool that searches for available tools
+ * Uses MiniSearch for full-text fuzzy search over all registered tools
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+import type { AnyDeclarativeTool } from '../types';
+export interface ToolSearchToolParams {
+    /** One sentence explanation of why this tool is being used */
+    explanation?: string;
+    /** The search query to find relevant tools (e.g. "create environment", "read file", "git commit") */
+    query: string;
+    /** Maximum number of results to return (default: 10) */
+    limit?: number;
+    /** Filter results by tool kind (e.g. "read", "edit", "execute", "delete") */
+    kind?: string;
+}
+export declare class ToolSearchTool extends BaseDeclarativeTool<ToolSearchToolParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    /**
+     * Initialize the search index with a set of tools.
+     * Call this before using the tool so the search engine knows what tools are available.
+     * @param tools - Array of tools to index
+     */
+    static setTools(tools: AnyDeclarativeTool[]): void;
+    /**
+     * Get the currently indexed tools
+     */
+    static getIndexedTools(): AnyDeclarativeTool[];
+    protected createInvocation(params: ToolSearchToolParams): ToolInvocation<ToolSearchToolParams, ToolResult>;
+}

package/dist/tools/toolSearch/tool-search-tool.js

@@ -0,0 +1,110 @@
+"use strict";
+/**
+ * Tool Search Tool - An LLM-callable tool that searches for available tools
+ * Uses MiniSearch for full-text fuzzy search over all registered tools
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolSearchTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const tool_search_1 = require("../tool-search");
+// Singleton search engine instance shared across invocations
+let searchEngine = null;
+let indexedTools = [];
+class ToolSearchInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        var _a;
+        try {
+            if (!searchEngine) {
+                return {
+                    llmContent: 'Tool search index not initialized. Call ToolSearchTool.setTools() first.',
+                    returnDisplay: 'Error: search index not initialized',
+                    error: {
+                        message: 'Tool search index not initialized',
+                        type: types_1.ToolErrorType.EXECUTION_FAILED,
+                    },
+                };
+            }
+            const results = searchEngine.search(this.params.query, {
+                limit: (_a = this.params.limit) !== null && _a !== void 0 ? _a : 10,
+                kind: this.params.kind,
+            });
+            if (results.length === 0) {
+                return {
+                    llmContent: `No tools found matching "${this.params.query}".`,
+                    returnDisplay: `No tools found for: ${this.params.query}`,
+                };
+            }
+            let output = `Found ${results.length} tool(s) matching "${this.params.query}":\n\n`;
+            for (const r of results) {
+                output += `- **${r.name}** (${r.kind}): ${r.description} [score: ${r.score.toFixed(2)}]\n`;
+            }
+            return {
+                llmContent: output,
+                returnDisplay: `Found ${results.length} tool(s)`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error searching tools: ${errorMessage}`,
+                returnDisplay: `Error: ${errorMessage}`,
+                error: { message: errorMessage, type: types_1.ToolErrorType.EXECUTION_FAILED },
+            };
+        }
+    }
+}
+class ToolSearchTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(ToolSearchTool.Name, 'ToolSearch', 'Searches for available tools by name, description, or functionality using full-text search. Use this to discover which tools are available for a given task.', types_1.Kind.Search, {
+            properties: {
+                explanation: {
+                    description: "One sentence explanation as to why this tool is being used, and how it contributes to the goal.",
+                    type: 'string',
+                },
+                query: {
+                    description: 'The search query to find relevant tools (e.g. "create environment", "read file", "git commit").',
+                    type: 'string',
+                },
+                limit: {
+                    description: 'Maximum number of results to return (default: 10).',
+                    type: 'number',
+                },
+                kind: {
+                    description: 'Filter results by tool kind: "read", "edit", "delete", "execute", "search", "fetch", "other".',
+                    type: 'string',
+                },
+            },
+            required: ['query'],
+            type: 'object',
+        });
+    }
+    /**
+     * Initialize the search index with a set of tools.
+     * Call this before using the tool so the search engine knows what tools are available.
+     * @param tools - Array of tools to index
+     */
+    static setTools(tools) {
+        indexedTools = tools;
+        searchEngine = new tool_search_1.ToolSearchEngine();
+        const toolMap = new Map();
+        for (const tool of tools) {
+            toolMap.set(tool.name, tool);
+        }
+        searchEngine.buildIndex(toolMap);
+    }
+    /**
+     * Get the currently indexed tools
+     */
+    static getIndexedTools() {
+        return indexedTools;
+    }
+    createInvocation(params) {
+        return new ToolSearchInvocation(params);
+    }
+}
+exports.ToolSearchTool = ToolSearchTool;
+ToolSearchTool.Name = 'tool_search';

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/agentDeliberation.d.ts

@@ -5,6 +5,7 @@ export declare enum AgentDeliberationAction {
     UPDATE = "agentdeliberation.update",
     RESPOND = "agentdeliberation.respond",
     VOTE = "agentdeliberation.vote",
+    VOTE_OPTION = "agentdeliberation.vote-option",
     WINNER = "agentdeliberation.winner",
     SUMMARY = "agentdeliberation.summary"
 }
@@ -15,10 +16,17 @@ export declare enum AgentDeliberationResponseType {
     UPDATE_RESPONSE = "agentdeliberation.update.response",
     RESPOND_RESPONSE = "agentdeliberation.respond.response",
     VOTE_RESPONSE = "agentdeliberation.vote.response",
+    VOTE_OPTION_RESPONSE = "agentdeliberation.vote-option.response",
     WINNER_RESPONSE = "agentdeliberation.winner.response",
     SUMMARY_RESPONSE = "agentdeliberation.summary.response"
 }
 export type DeliberationStatus = 'draft' | 'collecting-responses' | 'voting' | 'completed' | 'closed';
+export interface DeliberationOption {
+    id: string;
+    text: string;
+    proposedBy: string;
+    voteCount: number;
+}
 export interface Deliberation {
     id: string;
     type: DeliberationType;
@@ -36,6 +44,7 @@ export interface Deliberation {
     summary?: string;
     summaryAuthorId?: string;
     summaryAuthorName?: string;
+    options?: DeliberationOption[];
     createdAt: string;
     updatedAt: string;
     deletedAt?: string;
@@ -65,6 +74,10 @@ export interface ICreateDeliberationParams {
     creatorName: string;
     participants?: string[];
     status?: DeliberationStatus;
+    options?: {
+        text: string;
+        proposedBy: string;
+    }[];
 }
 export interface IGetDeliberationParams {
     id: string;
@@ -92,7 +105,8 @@ export interface IRespondParams {
 }
 export interface IVoteParams {
     deliberationId: string;
-    responseId: string;
+    responseId?: string;
+    optionId?: string;
     voterId: string;
     voterName: string;
 }