@codebolt/codeboltjs 5.0.2 → 5.0.4

package/dist/tools/fileIntent/file-intent-delete.d.ts

@@ -0,0 +1,16 @@
+/**
+ * File Intent Delete Tool - Deletes a file update intent
+ * Wraps the SDK's fileUpdateIntentService.delete() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+export interface FileIntentDeleteParams {
+    /** ID of the intent to delete */
+    id: string;
+}
+export declare class FileIntentDeleteTool extends BaseDeclarativeTool<FileIntentDeleteParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected validateToolParamValues(params: FileIntentDeleteParams): string | null;
+    protected createInvocation(params: FileIntentDeleteParams): ToolInvocation<FileIntentDeleteParams, ToolResult>;
+}

package/dist/tools/fileIntent/file-intent-delete.js

@@ -0,0 +1,75 @@
+"use strict";
+/**
+ * File Intent Delete Tool - Deletes a file update intent
+ * Wraps the SDK's fileUpdateIntentService.delete() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileIntentDeleteTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const fileUpdateIntent_1 = __importDefault(require("../../modules/fileUpdateIntent"));
+class FileIntentDeleteInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        try {
+            const result = await fileUpdateIntent_1.default.delete(this.params.id);
+            if (result.success) {
+                return {
+                    llmContent: `Successfully deleted file update intent: ${this.params.id}`,
+                    returnDisplay: `Deleted intent: ${this.params.id}`,
+                };
+            }
+            else {
+                return {
+                    llmContent: `Failed to delete file update intent: ${this.params.id}`,
+                    returnDisplay: `Failed to delete intent`,
+                    error: {
+                        message: `Failed to delete intent ${this.params.id}`,
+                        type: types_1.ToolErrorType.EXECUTION_FAILED,
+                    },
+                };
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error deleting file intent: ${errorMessage}`,
+                returnDisplay: `Error: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+class FileIntentDeleteTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(FileIntentDeleteTool.Name, 'FileIntentDelete', 'Deletes a file update intent permanently, removing it from the system.', types_1.Kind.Delete, {
+            properties: {
+                id: {
+                    description: 'The ID of the intent to delete.',
+                    type: 'string',
+                },
+            },
+            required: ['id'],
+            type: 'object',
+        });
+    }
+    validateToolParamValues(params) {
+        if (!params.id || params.id.trim() === '') {
+            return "'id' is required";
+        }
+        return null;
+    }
+    createInvocation(params) {
+        return new FileIntentDeleteInvocation(params);
+    }
+}
+exports.FileIntentDeleteTool = FileIntentDeleteTool;
+FileIntentDeleteTool.Name = 'file_intent_delete';

package/dist/tools/fileIntent/file-intent-get-blocked.d.ts

@@ -0,0 +1,16 @@
+/**
+ * File Intent Get Blocked Tool - Gets files that are hard-locked (level 4)
+ * Wraps the SDK's fileUpdateIntentService.getBlockedFiles() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+export interface FileIntentGetBlockedParams {
+    /** Environment ID to check */
+    environmentId: string;
+}
+export declare class FileIntentGetBlockedTool extends BaseDeclarativeTool<FileIntentGetBlockedParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected validateToolParamValues(params: FileIntentGetBlockedParams): string | null;
+    protected createInvocation(params: FileIntentGetBlockedParams): ToolInvocation<FileIntentGetBlockedParams, ToolResult>;
+}

package/dist/tools/fileIntent/file-intent-get-blocked.js

@@ -0,0 +1,76 @@
+"use strict";
+/**
+ * File Intent Get Blocked Tool - Gets files that are hard-locked (level 4)
+ * Wraps the SDK's fileUpdateIntentService.getBlockedFiles() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileIntentGetBlockedTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const fileUpdateIntent_1 = __importDefault(require("../../modules/fileUpdateIntent"));
+class FileIntentGetBlockedInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        try {
+            const result = await fileUpdateIntent_1.default.getBlockedFiles(this.params.environmentId);
+            if (!result.blockedFiles || result.blockedFiles.length === 0) {
+                return {
+                    llmContent: 'No blocked files found in this environment.',
+                    returnDisplay: 'No blocked files',
+                };
+            }
+            let output = `Blocked Files (Level 4 Hard Locks):`;
+            output += `\nEnvironment: ${this.params.environmentId}`;
+            output += `\nCount: ${result.blockedFiles.length}`;
+            output += `\n\nFiles:`;
+            for (const file of result.blockedFiles) {
+                output += `\n  - ${file}`;
+            }
+            return {
+                llmContent: output,
+                returnDisplay: `${result.blockedFiles.length} blocked file(s)`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error getting blocked files: ${errorMessage}`,
+                returnDisplay: `Error: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+class FileIntentGetBlockedTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(FileIntentGetBlockedTool.Name, 'FileIntentGetBlocked', 'Gets all files that are hard-locked (level 4 intents) in an environment. These files cannot be modified by other agents.', types_1.Kind.Read, {
+            properties: {
+                environmentId: {
+                    description: 'The environment ID to check for blocked files.',
+                    type: 'string',
+                },
+            },
+            required: ['environmentId'],
+            type: 'object',
+        });
+    }
+    validateToolParamValues(params) {
+        if (!params.environmentId || params.environmentId.trim() === '') {
+            return "'environmentId' is required";
+        }
+        return null;
+    }
+    createInvocation(params) {
+        return new FileIntentGetBlockedInvocation(params);
+    }
+}
+exports.FileIntentGetBlockedTool = FileIntentGetBlockedTool;
+FileIntentGetBlockedTool.Name = 'file_intent_get_blocked';

package/dist/tools/fileIntent/file-intent-get-by-agent.d.ts

@@ -0,0 +1,16 @@
+/**
+ * File Intent Get By Agent Tool - Gets all intents claimed by a specific agent
+ * Wraps the SDK's fileUpdateIntentService.getByAgent() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+export interface FileIntentGetByAgentParams {
+    /** Agent ID to get intents for */
+    agentId: string;
+}
+export declare class FileIntentGetByAgentTool extends BaseDeclarativeTool<FileIntentGetByAgentParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected validateToolParamValues(params: FileIntentGetByAgentParams): string | null;
+    protected createInvocation(params: FileIntentGetByAgentParams): ToolInvocation<FileIntentGetByAgentParams, ToolResult>;
+}

package/dist/tools/fileIntent/file-intent-get-by-agent.js

@@ -0,0 +1,80 @@
+"use strict";
+/**
+ * File Intent Get By Agent Tool - Gets all intents claimed by a specific agent
+ * Wraps the SDK's fileUpdateIntentService.getByAgent() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileIntentGetByAgentTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const fileUpdateIntent_1 = __importDefault(require("../../modules/fileUpdateIntent"));
+class FileIntentGetByAgentInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        try {
+            const intents = await fileUpdateIntent_1.default.getByAgent(this.params.agentId);
+            if (!intents || intents.length === 0) {
+                return {
+                    llmContent: `No file update intents found for agent: ${this.params.agentId}`,
+                    returnDisplay: 'No intents found for agent',
+                };
+            }
+            let output = `File Update Intents for Agent: ${this.params.agentId}`;
+            output += `\nCount: ${intents.length}`;
+            for (const intent of intents) {
+                output += `\n\n---\nIntent: ${intent.id}`;
+                output += `\n  Environment: ${intent.environmentId}`;
+                output += `\n  Description: ${intent.description}`;
+                output += `\n  Files: ${intent.files.map(f => f.filePath).join(', ')}`;
+                output += `\n  Priority: ${intent.priority}`;
+                output += `\n  Status: ${intent.status}`;
+                output += `\n  Created: ${intent.createdAt}`;
+            }
+            return {
+                llmContent: output,
+                returnDisplay: `${intents.length} intent(s) for agent ${this.params.agentId}`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error getting intents by agent: ${errorMessage}`,
+                returnDisplay: `Error: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+class FileIntentGetByAgentTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(FileIntentGetByAgentTool.Name, 'FileIntentGetByAgent', 'Gets all file update intents claimed by a specific agent, useful for seeing what files an agent has reserved.', types_1.Kind.Read, {
+            properties: {
+                agentId: {
+                    description: 'The agent ID to get intents for.',
+                    type: 'string',
+                },
+            },
+            required: ['agentId'],
+            type: 'object',
+        });
+    }
+    validateToolParamValues(params) {
+        if (!params.agentId || params.agentId.trim() === '') {
+            return "'agentId' is required";
+        }
+        return null;
+    }
+    createInvocation(params) {
+        return new FileIntentGetByAgentInvocation(params);
+    }
+}
+exports.FileIntentGetByAgentTool = FileIntentGetByAgentTool;
+FileIntentGetByAgentTool.Name = 'file_intent_get_by_agent';

package/dist/tools/fileIntent/file-intent-get-files-with-intents.d.ts

@@ -0,0 +1,16 @@
+/**
+ * File Intent Get Files With Intents Tool - Gets all files that have active intents
+ * Wraps the SDK's fileUpdateIntentService.getFilesWithIntents() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+export interface FileIntentGetFilesWithIntentsParams {
+    /** Environment ID to check */
+    environmentId: string;
+}
+export declare class FileIntentGetFilesWithIntentsTool extends BaseDeclarativeTool<FileIntentGetFilesWithIntentsParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected validateToolParamValues(params: FileIntentGetFilesWithIntentsParams): string | null;
+    protected createInvocation(params: FileIntentGetFilesWithIntentsParams): ToolInvocation<FileIntentGetFilesWithIntentsParams, ToolResult>;
+}

package/dist/tools/fileIntent/file-intent-get-files-with-intents.js

@@ -0,0 +1,80 @@
+"use strict";
+/**
+ * File Intent Get Files With Intents Tool - Gets all files that have active intents
+ * Wraps the SDK's fileUpdateIntentService.getFilesWithIntents() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileIntentGetFilesWithIntentsTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const fileUpdateIntent_1 = __importDefault(require("../../modules/fileUpdateIntent"));
+class FileIntentGetFilesWithIntentsInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        try {
+            const filesWithIntents = await fileUpdateIntent_1.default.getFilesWithIntents(this.params.environmentId);
+            if (!filesWithIntents || filesWithIntents.length === 0) {
+                return {
+                    llmContent: 'No files with active intents found in this environment.',
+                    returnDisplay: 'No files with intents',
+                };
+            }
+            let output = `Files With Active Intents:`;
+            output += `\nEnvironment: ${this.params.environmentId}`;
+            output += `\nCount: ${filesWithIntents.length}`;
+            output += `\n`;
+            for (const fileWithIntent of filesWithIntents) {
+                output += `\n- ${fileWithIntent.filePath}`;
+                output += `\n    Intent ID: ${fileWithIntent.intentId}`;
+                output += `\n    Claimed by: ${fileWithIntent.claimedByName || fileWithIntent.claimedBy}`;
+                output += `\n    Level: ${fileWithIntent.intentLevel}`;
+                output += `\n    Priority: ${fileWithIntent.priority}`;
+            }
+            return {
+                llmContent: output,
+                returnDisplay: `${filesWithIntents.length} file(s) with intents`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error getting files with intents: ${errorMessage}`,
+                returnDisplay: `Error: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+class FileIntentGetFilesWithIntentsTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(FileIntentGetFilesWithIntentsTool.Name, 'FileIntentGetFilesWithIntents', 'Gets all files that have active intents in an environment, showing which files are currently reserved and by whom.', types_1.Kind.Read, {
+            properties: {
+                environmentId: {
+                    description: 'The environment ID to check for files with intents.',
+                    type: 'string',
+                },
+            },
+            required: ['environmentId'],
+            type: 'object',
+        });
+    }
+    validateToolParamValues(params) {
+        if (!params.environmentId || params.environmentId.trim() === '') {
+            return "'environmentId' is required";
+        }
+        return null;
+    }
+    createInvocation(params) {
+        return new FileIntentGetFilesWithIntentsInvocation(params);
+    }
+}
+exports.FileIntentGetFilesWithIntentsTool = FileIntentGetFilesWithIntentsTool;
+FileIntentGetFilesWithIntentsTool.Name = 'file_intent_get_files_with_intents';

package/dist/tools/fileIntent/file-intent-get.d.ts

@@ -0,0 +1,16 @@
+/**
+ * File Intent Get Tool - Gets a single file update intent by ID
+ * Wraps the SDK's fileUpdateIntentService.get() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+export interface FileIntentGetParams {
+    /** ID of the intent to retrieve */
+    id: string;
+}
+export declare class FileIntentGetTool extends BaseDeclarativeTool<FileIntentGetParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected validateToolParamValues(params: FileIntentGetParams): string | null;
+    protected createInvocation(params: FileIntentGetParams): ToolInvocation<FileIntentGetParams, ToolResult>;
+}

package/dist/tools/fileIntent/file-intent-get.js

@@ -0,0 +1,94 @@
+"use strict";
+/**
+ * File Intent Get Tool - Gets a single file update intent by ID
+ * Wraps the SDK's fileUpdateIntentService.get() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileIntentGetTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const fileUpdateIntent_1 = __importDefault(require("../../modules/fileUpdateIntent"));
+class FileIntentGetInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        try {
+            const intent = await fileUpdateIntent_1.default.get(this.params.id);
+            if (!intent) {
+                return {
+                    llmContent: `File intent not found: ${this.params.id}`,
+                    returnDisplay: `Intent not found: ${this.params.id}`,
+                    error: {
+                        message: `Intent with ID ${this.params.id} not found`,
+                        type: types_1.ToolErrorType.EXECUTION_FAILED,
+                    },
+                };
+            }
+            let output = `File Update Intent: ${intent.id}`;
+            output += `\nEnvironment: ${intent.environmentId}`;
+            output += `\nDescription: ${intent.description}`;
+            output += `\nFiles:`;
+            for (const file of intent.files) {
+                output += `\n  - ${file.filePath} (Level ${file.intentLevel})`;
+                if (file.targetSections && file.targetSections.length > 0) {
+                    output += ` [Sections: ${file.targetSections.join(', ')}]`;
+                }
+            }
+            output += `\nPriority: ${intent.priority}`;
+            output += `\nClaimed by: ${intent.claimedByName || intent.claimedBy}`;
+            output += `\nStatus: ${intent.status}`;
+            output += `\nCreated: ${intent.createdAt}`;
+            output += `\nUpdated: ${intent.updatedAt}`;
+            if (intent.expiresAt) {
+                output += `\nExpires: ${intent.expiresAt}`;
+            }
+            if (intent.closedAt) {
+                output += `\nClosed: ${intent.closedAt} by ${intent.closedBy}`;
+            }
+            return {
+                llmContent: output,
+                returnDisplay: `Retrieved intent: ${intent.id}`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error getting file intent: ${errorMessage}`,
+                returnDisplay: `Error: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+class FileIntentGetTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(FileIntentGetTool.Name, 'FileIntentGet', 'Retrieves a single file update intent by its ID, including all details about files, status, and ownership.', types_1.Kind.Read, {
+            properties: {
+                id: {
+                    description: 'The ID of the intent to retrieve.',
+                    type: 'string',
+                },
+            },
+            required: ['id'],
+            type: 'object',
+        });
+    }
+    validateToolParamValues(params) {
+        if (!params.id || params.id.trim() === '') {
+            return "'id' is required";
+        }
+        return null;
+    }
+    createInvocation(params) {
+        return new FileIntentGetInvocation(params);
+    }
+}
+exports.FileIntentGetTool = FileIntentGetTool;
+FileIntentGetTool.Name = 'file_intent_get';

package/dist/tools/fileIntent/file-intent-list.d.ts

@@ -0,0 +1,26 @@
+/**
+ * File Intent List Tool - Lists file update intents with optional filters
+ * Wraps the SDK's fileUpdateIntentService.list() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+import type { IntentStatus } from '../../types/fileUpdateIntent';
+export interface FileIntentListParams {
+    /** Filter by environment ID (optional) */
+    environmentId?: string;
+    /** Filter by status (optional) */
+    status?: IntentStatus[];
+    /** Filter by agent who claimed (optional) */
+    claimedBy?: string;
+    /** Filter by file path containing string (optional) */
+    filePathContains?: string;
+    /** Filter by creation date after (optional) */
+    createdAfter?: string;
+    /** Filter by creation date before (optional) */
+    createdBefore?: string;
+}
+export declare class FileIntentListTool extends BaseDeclarativeTool<FileIntentListParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected createInvocation(params: FileIntentListParams): ToolInvocation<FileIntentListParams, ToolResult>;
+}

package/dist/tools/fileIntent/file-intent-list.js

@@ -0,0 +1,97 @@
+"use strict";
+/**
+ * File Intent List Tool - Lists file update intents with optional filters
+ * Wraps the SDK's fileUpdateIntentService.list() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileIntentListTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const fileUpdateIntent_1 = __importDefault(require("../../modules/fileUpdateIntent"));
+class FileIntentListInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        try {
+            const intents = await fileUpdateIntent_1.default.list(this.params);
+            if (!intents || intents.length === 0) {
+                return {
+                    llmContent: 'No file update intents found matching the filters.',
+                    returnDisplay: 'No intents found',
+                };
+            }
+            let output = `Found ${intents.length} file update intent(s):\n`;
+            for (const intent of intents) {
+                output += `\n---\nIntent: ${intent.id}`;
+                output += `\n  Description: ${intent.description}`;
+                output += `\n  Files: ${intent.files.map(f => f.filePath).join(', ')}`;
+                output += `\n  Priority: ${intent.priority}`;
+                output += `\n  Claimed by: ${intent.claimedByName || intent.claimedBy}`;
+                output += `\n  Status: ${intent.status}`;
+                output += `\n  Created: ${intent.createdAt}`;
+            }
+            return {
+                llmContent: output,
+                returnDisplay: `Found ${intents.length} intent(s)`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error listing file intents: ${errorMessage}`,
+                returnDisplay: `Error: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+class FileIntentListTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(FileIntentListTool.Name, 'FileIntentList', 'Lists file update intents with optional filters for environment, status, agent, file path, and date range.', types_1.Kind.Read, {
+            properties: {
+                environmentId: {
+                    description: 'Filter by environment ID (optional).',
+                    type: 'string',
+                },
+                status: {
+                    description: "Filter by status array: 'active', 'completed', 'expired', 'cancelled' (optional).",
+                    type: 'array',
+                    items: {
+                        type: 'string',
+                        enum: ['active', 'completed', 'expired', 'cancelled'],
+                    },
+                },
+                claimedBy: {
+                    description: 'Filter by agent ID who claimed the intent (optional).',
+                    type: 'string',
+                },
+                filePathContains: {
+                    description: 'Filter by file path containing this string (optional).',
+                    type: 'string',
+                },
+                createdAfter: {
+                    description: 'Filter by creation date after this ISO timestamp (optional).',
+                    type: 'string',
+                },
+                createdBefore: {
+                    description: 'Filter by creation date before this ISO timestamp (optional).',
+                    type: 'string',
+                },
+            },
+            required: [],
+            type: 'object',
+        });
+    }
+    createInvocation(params) {
+        return new FileIntentListInvocation(params);
+    }
+}
+exports.FileIntentListTool = FileIntentListTool;
+FileIntentListTool.Name = 'file_intent_list';

package/dist/tools/fileIntent/file-intent-update.d.ts

@@ -0,0 +1,33 @@
+/**
+ * File Intent Update Tool - Updates an existing file update intent
+ * Wraps the SDK's fileUpdateIntentService.update() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+import type { IntentLevel } from '../../types/fileUpdateIntent';
+export interface FileIntentUpdateParams {
+    /** ID of the intent to update */
+    id: string;
+    /** Updated list of files with their intent levels (optional) */
+    files?: Array<{
+        filePath: string;
+        intentLevel: IntentLevel;
+        targetSections?: string[];
+    }>;
+    /** Updated description (optional) */
+    description?: string;
+    /** Updated estimated duration in minutes (optional) */
+    estimatedDuration?: number;
+    /** Updated priority 1-10 (optional) */
+    priority?: number;
+    /** Updated auto-expire setting (optional) */
+    autoExpire?: boolean;
+    /** Updated max auto-expire minutes (optional) */
+    maxAutoExpireMinutes?: number;
+}
+export declare class FileIntentUpdateTool extends BaseDeclarativeTool<FileIntentUpdateParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected validateToolParamValues(params: FileIntentUpdateParams): string | null;
+    protected createInvocation(params: FileIntentUpdateParams): ToolInvocation<FileIntentUpdateParams, ToolResult>;
+}