@codebolt/codeboltjs 5.0.2 → 5.0.3

package/dist/tools/rag/rag-retrieve.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RAGRetrieveKnowledgeTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const rag_1 = __importDefault(require("../../modules/rag"));
+class RAGRetrieveKnowledgeInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute(_signal) {
+        try {
+            const result = await rag_1.default.retrieve_related_knowledge(this.params.query, this.params.filename);
+            return {
+                llmContent: `Related knowledge:\n${result}`,
+                returnDisplay: `Retrieved knowledge for "${this.params.query}"`,
+            };
+        }
+        catch (error) {
+            return {
+                llmContent: `Error: ${error}`,
+                returnDisplay: `Error: ${error}`,
+                error: { message: String(error), type: types_1.ToolErrorType.EXECUTION_FAILED },
+            };
+        }
+    }
+}
+class RAGRetrieveKnowledgeTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super('rag_retrieve_knowledge', 'Retrieve RAG Knowledge', 'Retrieve related knowledge from RAG', types_1.Kind.Other, {
+            type: 'object',
+            properties: {
+                query: { type: 'string', description: 'Query' },
+                filename: { type: 'string', description: 'Filename' },
+                explanation: { type: 'string', description: 'Explanation' },
+            },
+            required: ['query', 'filename'],
+        });
+    }
+    createInvocation(params) {
+        return new RAGRetrieveKnowledgeInvocation(params);
+    }
+}
+exports.RAGRetrieveKnowledgeTool = RAGRetrieveKnowledgeTool;

package/dist/tools/registry.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Tool Registry for managing and executing tools
+ */
+import type { AnyDeclarativeTool, ToolResult, OpenAIToolSchema, OpenAIFunctionCall } from './types';
+/**
+ * Registry for managing tools
+ */
+export declare class ToolRegistry {
+    private tools;
+    /**
+     * Register a tool with the registry
+     * @param tool - The tool to register
+     */
+    registerTool(tool: AnyDeclarativeTool): void;
+    /**
+     * Register multiple tools at once
+     * @param tools - Array of tools to register
+     */
+    registerTools(tools: AnyDeclarativeTool[]): void;
+    /**
+     * Unregister a tool by name
+     * @param name - The name of the tool to unregister
+     * @returns true if the tool was found and removed
+     */
+    unregisterTool(name: string): boolean;
+    /**
+     * Get a tool by name
+     * @param name - The name of the tool
+     * @returns The tool if found, undefined otherwise
+     */
+    getTool(name: string): AnyDeclarativeTool | undefined;
+    /**
+     * Check if a tool is registered
+     * @param name - The name of the tool
+     * @returns true if the tool is registered
+     */
+    hasTool(name: string): boolean;
+    /**
+     * Get all registered tools
+     * @returns Array of all registered tools
+     */
+    getAllTools(): AnyDeclarativeTool[];
+    /**
+     * Get the names of all registered tools
+     * @returns Array of tool names
+     */
+    getToolNames(): string[];
+    /**
+     * Get the count of registered tools
+     * @returns Number of registered tools
+     */
+    getToolCount(): number;
+    /**
+     * Get OpenAI tool schemas for all registered tools
+     * @returns Array of OpenAI tool schemas
+     */
+    getToolSchemas(): OpenAIToolSchema[];
+    /**
+     * Get OpenAI function call schemas for all registered tools
+     * @returns Array of OpenAI function call schemas
+     */
+    getFunctionCallSchemas(): OpenAIFunctionCall[];
+    /**
+     * Execute a tool by name with given parameters
+     * @param name - The name of the tool to execute
+     * @param params - The parameters to pass to the tool
+     * @param signal - Optional AbortSignal for cancellation
+     * @param updateOutput - Optional callback for streaming output
+     * @returns The tool execution result
+     */
+    executeTool(name: string, params: object, signal?: AbortSignal, updateOutput?: (output: string) => void): Promise<ToolResult>;
+    /**
+     * Execute a tool with confirmation support
+     * @param name - The name of the tool
+     * @param params - The parameters to pass
+     * @param signal - AbortSignal for cancellation
+     * @param onConfirmation - Callback when confirmation is needed
+     * @param updateOutput - Optional callback for streaming output
+     * @returns The tool execution result
+     */
+    executeToolWithConfirmation(name: string, params: object, signal: AbortSignal, onConfirmation: (details: any) => Promise<boolean>, updateOutput?: (output: string) => void): Promise<ToolResult>;
+    /**
+     * Clear all registered tools
+     */
+    clear(): void;
+}
+/**
+ * Default global registry instance
+ */
+export declare const defaultRegistry: ToolRegistry;

package/dist/tools/registry.js

@@ -0,0 +1,198 @@
+"use strict";
+/**
+ * Tool Registry for managing and executing tools
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultRegistry = exports.ToolRegistry = void 0;
+const types_1 = require("./types");
+/**
+ * Registry for managing tools
+ */
+class ToolRegistry {
+    constructor() {
+        this.tools = new Map();
+    }
+    /**
+     * Register a tool with the registry
+     * @param tool - The tool to register
+     */
+    registerTool(tool) {
+        if (this.tools.has(tool.name)) {
+            console.warn(`Tool "${tool.name}" is already registered. Overwriting.`);
+        }
+        this.tools.set(tool.name, tool);
+    }
+    /**
+     * Register multiple tools at once
+     * @param tools - Array of tools to register
+     */
+    registerTools(tools) {
+        for (const tool of tools) {
+            this.registerTool(tool);
+        }
+    }
+    /**
+     * Unregister a tool by name
+     * @param name - The name of the tool to unregister
+     * @returns true if the tool was found and removed
+     */
+    unregisterTool(name) {
+        return this.tools.delete(name);
+    }
+    /**
+     * Get a tool by name
+     * @param name - The name of the tool
+     * @returns The tool if found, undefined otherwise
+     */
+    getTool(name) {
+        return this.tools.get(name);
+    }
+    /**
+     * Check if a tool is registered
+     * @param name - The name of the tool
+     * @returns true if the tool is registered
+     */
+    hasTool(name) {
+        return this.tools.has(name);
+    }
+    /**
+     * Get all registered tools
+     * @returns Array of all registered tools
+     */
+    getAllTools() {
+        return Array.from(this.tools.values());
+    }
+    /**
+     * Get the names of all registered tools
+     * @returns Array of tool names
+     */
+    getToolNames() {
+        return Array.from(this.tools.keys());
+    }
+    /**
+     * Get the count of registered tools
+     * @returns Number of registered tools
+     */
+    getToolCount() {
+        return this.tools.size;
+    }
+    /**
+     * Get OpenAI tool schemas for all registered tools
+     * @returns Array of OpenAI tool schemas
+     */
+    getToolSchemas() {
+        return this.getAllTools().map(tool => tool.schema);
+    }
+    /**
+     * Get OpenAI function call schemas for all registered tools
+     * @returns Array of OpenAI function call schemas
+     */
+    getFunctionCallSchemas() {
+        return this.getAllTools().map(tool => ({
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.schema.function.parameters,
+        }));
+    }
+    /**
+     * Execute a tool by name with given parameters
+     * @param name - The name of the tool to execute
+     * @param params - The parameters to pass to the tool
+     * @param signal - Optional AbortSignal for cancellation
+     * @param updateOutput - Optional callback for streaming output
+     * @returns The tool execution result
+     */
+    async executeTool(name, params, signal, updateOutput) {
+        const tool = this.tools.get(name);
+        if (!tool) {
+            return {
+                llmContent: `Error: Tool "${name}" is not registered.`,
+                returnDisplay: `Tool "${name}" not found`,
+                error: {
+                    message: `Tool "${name}" is not registered`,
+                    type: types_1.ToolErrorType.TOOL_NOT_REGISTERED,
+                },
+            };
+        }
+        const abortSignal = signal || new AbortController().signal;
+        try {
+            return await tool.validateBuildAndExecute(params, abortSignal);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                llmContent: `Error executing tool "${name}": ${errorMessage}`,
+                returnDisplay: `Error: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+    /**
+     * Execute a tool with confirmation support
+     * @param name - The name of the tool
+     * @param params - The parameters to pass
+     * @param signal - AbortSignal for cancellation
+     * @param onConfirmation - Callback when confirmation is needed
+     * @param updateOutput - Optional callback for streaming output
+     * @returns The tool execution result
+     */
+    async executeToolWithConfirmation(name, params, signal, onConfirmation, updateOutput) {
+        const tool = this.tools.get(name);
+        if (!tool) {
+            return {
+                llmContent: `Error: Tool "${name}" is not registered.`,
+                returnDisplay: `Tool "${name}" not found`,
+                error: {
+                    message: `Tool "${name}" is not registered`,
+                    type: types_1.ToolErrorType.TOOL_NOT_REGISTERED,
+                },
+            };
+        }
+        try {
+            // Build the invocation first
+            const invocation = tool.build(params);
+            // Check if confirmation is needed
+            const confirmationDetails = await invocation.shouldConfirmExecute(signal);
+            if (confirmationDetails) {
+                const shouldProceed = await onConfirmation(confirmationDetails);
+                if (!shouldProceed) {
+                    return {
+                        llmContent: 'Tool execution cancelled by user.',
+                        returnDisplay: 'Execution cancelled',
+                        error: {
+                            message: 'User cancelled the operation',
+                            type: types_1.ToolErrorType.EXECUTION_FAILED,
+                        },
+                    };
+                }
+            }
+            // Execute the tool
+            return await invocation.execute(signal, updateOutput);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                llmContent: `Error executing tool "${name}": ${errorMessage}`,
+                returnDisplay: `Error: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+    /**
+     * Clear all registered tools
+     */
+    clear() {
+        this.tools.clear();
+    }
+}
+exports.ToolRegistry = ToolRegistry;
+/**
+ * Default global registry instance
+ */
+exports.defaultRegistry = new ToolRegistry();

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

@@ -0,0 +1,27 @@
+/**
+ * Requirement Plan Tools
+ *
+ * Tools for managing Requirement Plan documents.
+ */
+export { RequirementPlanCreateTool } from './requirement-plan-create';
+export { RequirementPlanGetTool } from './requirement-plan-get';
+export { RequirementPlanUpdateTool } from './requirement-plan-update';
+export { RequirementPlanListTool } from './requirement-plan-list';
+export { RequirementPlanAddSectionTool } from './requirement-plan-add-section';
+export { RequirementPlanUpdateSectionTool } from './requirement-plan-update-section';
+export { RequirementPlanRemoveSectionTool } from './requirement-plan-remove-section';
+export { RequirementPlanReorderSectionsTool } from './requirement-plan-reorder-sections';
+export { RequirementPlanReviewTool } from './requirement-plan-review';
+import { RequirementPlanCreateTool } from './requirement-plan-create';
+import { RequirementPlanGetTool } from './requirement-plan-get';
+import { RequirementPlanUpdateTool } from './requirement-plan-update';
+import { RequirementPlanListTool } from './requirement-plan-list';
+import { RequirementPlanAddSectionTool } from './requirement-plan-add-section';
+import { RequirementPlanUpdateSectionTool } from './requirement-plan-update-section';
+import { RequirementPlanRemoveSectionTool } from './requirement-plan-remove-section';
+import { RequirementPlanReorderSectionsTool } from './requirement-plan-reorder-sections';
+import { RequirementPlanReviewTool } from './requirement-plan-review';
+/**
+ * Array of all requirement plan tools
+ */
+export declare const requirementPlanTools: (RequirementPlanCreateTool | RequirementPlanGetTool | RequirementPlanUpdateTool | RequirementPlanListTool | RequirementPlanAddSectionTool | RequirementPlanUpdateSectionTool | RequirementPlanRemoveSectionTool | RequirementPlanReorderSectionsTool | RequirementPlanReviewTool)[];

package/dist/tools/requirementPlan/index.js

@@ -0,0 +1,49 @@
+"use strict";
+/**
+ * Requirement Plan Tools
+ *
+ * Tools for managing Requirement Plan documents.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requirementPlanTools = exports.RequirementPlanReviewTool = exports.RequirementPlanReorderSectionsTool = exports.RequirementPlanRemoveSectionTool = exports.RequirementPlanUpdateSectionTool = exports.RequirementPlanAddSectionTool = exports.RequirementPlanListTool = exports.RequirementPlanUpdateTool = exports.RequirementPlanGetTool = exports.RequirementPlanCreateTool = void 0;
+var requirement_plan_create_1 = require("./requirement-plan-create");
+Object.defineProperty(exports, "RequirementPlanCreateTool", { enumerable: true, get: function () { return requirement_plan_create_1.RequirementPlanCreateTool; } });
+var requirement_plan_get_1 = require("./requirement-plan-get");
+Object.defineProperty(exports, "RequirementPlanGetTool", { enumerable: true, get: function () { return requirement_plan_get_1.RequirementPlanGetTool; } });
+var requirement_plan_update_1 = require("./requirement-plan-update");
+Object.defineProperty(exports, "RequirementPlanUpdateTool", { enumerable: true, get: function () { return requirement_plan_update_1.RequirementPlanUpdateTool; } });
+var requirement_plan_list_1 = require("./requirement-plan-list");
+Object.defineProperty(exports, "RequirementPlanListTool", { enumerable: true, get: function () { return requirement_plan_list_1.RequirementPlanListTool; } });
+var requirement_plan_add_section_1 = require("./requirement-plan-add-section");
+Object.defineProperty(exports, "RequirementPlanAddSectionTool", { enumerable: true, get: function () { return requirement_plan_add_section_1.RequirementPlanAddSectionTool; } });
+var requirement_plan_update_section_1 = require("./requirement-plan-update-section");
+Object.defineProperty(exports, "RequirementPlanUpdateSectionTool", { enumerable: true, get: function () { return requirement_plan_update_section_1.RequirementPlanUpdateSectionTool; } });
+var requirement_plan_remove_section_1 = require("./requirement-plan-remove-section");
+Object.defineProperty(exports, "RequirementPlanRemoveSectionTool", { enumerable: true, get: function () { return requirement_plan_remove_section_1.RequirementPlanRemoveSectionTool; } });
+var requirement_plan_reorder_sections_1 = require("./requirement-plan-reorder-sections");
+Object.defineProperty(exports, "RequirementPlanReorderSectionsTool", { enumerable: true, get: function () { return requirement_plan_reorder_sections_1.RequirementPlanReorderSectionsTool; } });
+var requirement_plan_review_1 = require("./requirement-plan-review");
+Object.defineProperty(exports, "RequirementPlanReviewTool", { enumerable: true, get: function () { return requirement_plan_review_1.RequirementPlanReviewTool; } });
+const requirement_plan_create_2 = require("./requirement-plan-create");
+const requirement_plan_get_2 = require("./requirement-plan-get");
+const requirement_plan_update_2 = require("./requirement-plan-update");
+const requirement_plan_list_2 = require("./requirement-plan-list");
+const requirement_plan_add_section_2 = require("./requirement-plan-add-section");
+const requirement_plan_update_section_2 = require("./requirement-plan-update-section");
+const requirement_plan_remove_section_2 = require("./requirement-plan-remove-section");
+const requirement_plan_reorder_sections_2 = require("./requirement-plan-reorder-sections");
+const requirement_plan_review_2 = require("./requirement-plan-review");
+/**
+ * Array of all requirement plan tools
+ */
+exports.requirementPlanTools = [
+    new requirement_plan_create_2.RequirementPlanCreateTool(),
+    new requirement_plan_get_2.RequirementPlanGetTool(),
+    new requirement_plan_update_2.RequirementPlanUpdateTool(),
+    new requirement_plan_list_2.RequirementPlanListTool(),
+    new requirement_plan_add_section_2.RequirementPlanAddSectionTool(),
+    new requirement_plan_update_section_2.RequirementPlanUpdateSectionTool(),
+    new requirement_plan_remove_section_2.RequirementPlanRemoveSectionTool(),
+    new requirement_plan_reorder_sections_2.RequirementPlanReorderSectionsTool(),
+    new requirement_plan_review_2.RequirementPlanReviewTool(),
+];

package/dist/tools/requirementPlan/requirement-plan-add-section.d.ts

@@ -0,0 +1,12 @@
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+import type { RequirementPlanSection } from '../../modules/requirementPlan';
+export interface RequirementPlanAddSectionParams {
+    filePath: string;
+    section: Omit<RequirementPlanSection, 'id' | 'order'>;
+    afterIndex?: number;
+}
+export declare class RequirementPlanAddSectionTool extends BaseDeclarativeTool<RequirementPlanAddSectionParams, ToolResult> {
+    constructor();
+    protected createInvocation(params: RequirementPlanAddSectionParams): ToolInvocation<RequirementPlanAddSectionParams, ToolResult>;
+}

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

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequirementPlanAddSectionTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const requirementPlan_1 = __importDefault(require("../../modules/requirementPlan"));
+class RequirementPlanAddSectionInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute(_signal) {
+        try {
+            const response = await requirementPlan_1.default.addSection(this.params.filePath, this.params.section, this.params.afterIndex);
+            if (!response.success) {
+                return {
+                    llmContent: `Error: ${response.error}`,
+                    returnDisplay: `Error: ${response.error}`,
+                    error: { message: response.error || 'Unknown error', type: types_1.ToolErrorType.EXECUTION_FAILED },
+                };
+            }
+            return {
+                llmContent: `Section added to requirement plan`,
+                returnDisplay: JSON.stringify(response.document, null, 2),
+            };
+        }
+        catch (error) {
+            return {
+                llmContent: `Error: ${error}`,
+                returnDisplay: `Error: ${error}`,
+                error: { message: String(error), type: types_1.ToolErrorType.EXECUTION_FAILED },
+            };
+        }
+    }
+}
+class RequirementPlanAddSectionTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        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' },
+                section: {
+                    type: 'object',
+                    description: 'Section data to add',
+                    properties: {
+                        type: { type: 'string', enum: ['markdown', 'specs-link', 'actionplan-link', 'uiflow-link', 'code-block'], description: 'Section type' },
+                        title: { type: 'string', description: 'Section title' },
+                        content: { type: 'string', description: 'Section content' },
+                        linkedFile: { type: 'string', description: 'Linked file path (for link types)' },
+                    },
+                    required: ['type'],
+                },
+                afterIndex: { type: 'number', description: 'Optional index to insert after (-1 for beginning)' },
+            },
+            required: ['filePath', 'section'],
+        });
+    }
+    createInvocation(params) {
+        return new RequirementPlanAddSectionInvocation(params);
+    }
+}
+exports.RequirementPlanAddSectionTool = RequirementPlanAddSectionTool;

package/dist/tools/requirementPlan/requirement-plan-create.d.ts

@@ -0,0 +1,9 @@
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+export interface RequirementPlanCreateParams {
+    fileName: string;
+}
+export declare class RequirementPlanCreateTool extends BaseDeclarativeTool<RequirementPlanCreateParams, ToolResult> {
+    constructor();
+    protected createInvocation(params: RequirementPlanCreateParams): ToolInvocation<RequirementPlanCreateParams, ToolResult>;
+}

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

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequirementPlanCreateTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const requirementPlan_1 = __importDefault(require("../../modules/requirementPlan"));
+class RequirementPlanCreateInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute(_signal) {
+        try {
+            const response = await requirementPlan_1.default.create(this.params.fileName);
+            if (!response.success) {
+                return {
+                    llmContent: `Error: ${response.error}`,
+                    returnDisplay: `Error: ${response.error}`,
+                    error: { message: response.error || 'Unknown error', type: types_1.ToolErrorType.EXECUTION_FAILED },
+                };
+            }
+            return {
+                llmContent: `Requirement plan created at: ${response.filePath}`,
+                returnDisplay: `Created requirement plan: ${response.filePath}`,
+            };
+        }
+        catch (error) {
+            return {
+                llmContent: `Error: ${error}`,
+                returnDisplay: `Error: ${error}`,
+                error: { message: String(error), type: types_1.ToolErrorType.EXECUTION_FAILED },
+            };
+        }
+    }
+}
+class RequirementPlanCreateTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super('requirement_plan_create', 'Create Requirement Plan', 'Create a new requirement plan file', types_1.Kind.FileSystem, {
+            type: 'object',
+            properties: {
+                fileName: { type: 'string', description: 'Name for the new plan file (without .plan extension)' },
+            },
+            required: ['fileName'],
+        });
+    }
+    createInvocation(params) {
+        return new RequirementPlanCreateInvocation(params);
+    }
+}
+exports.RequirementPlanCreateTool = RequirementPlanCreateTool;

package/dist/tools/requirementPlan/requirement-plan-get.d.ts

@@ -0,0 +1,9 @@
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+export interface RequirementPlanGetParams {
+    filePath: string;
+}
+export declare class RequirementPlanGetTool extends BaseDeclarativeTool<RequirementPlanGetParams, ToolResult> {
+    constructor();
+    protected createInvocation(params: RequirementPlanGetParams): ToolInvocation<RequirementPlanGetParams, ToolResult>;
+}

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

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequirementPlanGetTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const requirementPlan_1 = __importDefault(require("../../modules/requirementPlan"));
+class RequirementPlanGetInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute(_signal) {
+        var _a;
+        try {
+            const response = await requirementPlan_1.default.get(this.params.filePath);
+            if (!response.success) {
+                return {
+                    llmContent: `Error: ${response.error}`,
+                    returnDisplay: `Error: ${response.error}`,
+                    error: { message: response.error || 'Unknown error', type: types_1.ToolErrorType.EXECUTION_FAILED },
+                };
+            }
+            return {
+                llmContent: `Retrieved requirement plan: ${((_a = response.data) === null || _a === void 0 ? void 0 : _a.title) || 'Untitled'}`,
+                returnDisplay: JSON.stringify(response.data, null, 2),
+            };
+        }
+        catch (error) {
+            return {
+                llmContent: `Error: ${error}`,
+                returnDisplay: `Error: ${error}`,
+                error: { message: String(error), type: types_1.ToolErrorType.EXECUTION_FAILED },
+            };
+        }
+    }
+}
+class RequirementPlanGetTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super('requirement_plan_get', 'Get Requirement Plan', 'Get a requirement plan by file path', types_1.Kind.FileSystem, {
+            type: 'object',
+            properties: {
+                filePath: { type: 'string', description: 'Path to the plan file' },
+            },
+            required: ['filePath'],
+        });
+    }
+    createInvocation(params) {
+        return new RequirementPlanGetInvocation(params);
+    }
+}
+exports.RequirementPlanGetTool = RequirementPlanGetTool;

package/dist/tools/requirementPlan/requirement-plan-list.d.ts

@@ -0,0 +1,8 @@
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+export interface RequirementPlanListParams {
+}
+export declare class RequirementPlanListTool extends BaseDeclarativeTool<RequirementPlanListParams, ToolResult> {
+    constructor();
+    protected createInvocation(params: RequirementPlanListParams): ToolInvocation<RequirementPlanListParams, ToolResult>;
+}