@andrebuzeli/git-mcp 5.0.4 → 5.0.6

package/dist/tools/git-tags.d.ts

@@ -1,19 +1,146 @@
-import { UniversalResponse } from '../utils/auto-detection.js';
-export declare const gitTagsTool: {
-    name: string;
-    description: string;
-    inputSchema: {
-        type: string;
-        properties: {
-            action: {
-                type: string;
-            };
-            projectPath: {
-                type: string;
+/**
+ * Git Tags Tool
+ *
+ * Tag management tool providing comprehensive Git tag operations.
+ * Supports both local Git operations and remote provider operations.
+ *
+ * Operations: create, list, get, delete, search
+ */
+import { ToolParams } from '../utils/parameter-validator.js';
+import { ToolResult } from '../utils/operation-error-handler.js';
+import { ProviderConfig } from '../providers/types.js';
+export interface GitTagsParams extends ToolParams {
+    action: 'create' | 'list' | 'get' | 'delete' | 'search';
+    tagName?: string;
+    message?: string;
+    commit?: string;
+    pattern?: string;
+    query?: string;
+    force?: boolean;
+    annotated?: boolean;
+    lightweight?: boolean;
+    owner?: string;
+    repo?: string;
+    remote?: string;
+}
+export declare class GitTagsTool {
+    private gitExecutor;
+    private providerHandler?;
+    constructor(providerConfig?: ProviderConfig);
+    /**
+     * Execute git-tags operation
+     */
+    execute(params: GitTagsParams): Promise<ToolResult>;
+    /**
+     * Execute local Git tag operations
+     */
+    private executeLocalOperation;
+    /**
+     * Execute remote provider operations
+     */
+    private executeRemoteOperation;
+    /**
+     * Handle create tag operation
+     */
+    private handleCreateTag;
+    /**
+     * Handle list tags operation
+     */
+    private handleListTags;
+    /**
+     * Handle get tag operation
+     */
+    private handleGetTag;
+    /**
+     * Handle delete tag operation
+     */
+    private handleDeleteTag;
+    /**
+     * Handle search tags operation
+     */
+    private handleSearchTags;
+    /**
+     * Check if operation is a remote operation
+     */
+    private isRemoteOperation;
+    /**
+     * Extract parameters for remote operations
+     */
+    private extractRemoteParameters;
+    /**
+     * Map git-tags actions to provider operations
+     */
+    private mapActionToProviderOperation;
+    /**
+     * Get tool schema for MCP registration
+     */
+    static getToolSchema(): {
+        name: string;
+        description: string;
+        inputSchema: {
+            type: string;
+            properties: {
+                action: {
+                    type: string;
+                    enum: string[];
+                    description: string;
+                };
+                projectPath: {
+                    type: string;
+                    description: string;
+                };
+                provider: {
+                    type: string;
+                    enum: string[];
+                    description: string;
+                };
+                tagName: {
+                    type: string;
+                    description: string;
+                };
+                message: {
+                    type: string;
+                    description: string;
+                };
+                commit: {
+                    type: string;
+                    description: string;
+                };
+                pattern: {
+                    type: string;
+                    description: string;
+                };
+                query: {
+                    type: string;
+                    description: string;
+                };
+                force: {
+                    type: string;
+                    description: string;
+                };
+                annotated: {
+                    type: string;
+                    description: string;
+                };
+                lightweight: {
+                    type: string;
+                    description: string;
+                };
+                owner: {
+                    type: string;
+                    description: string;
+                };
+                repo: {
+                    type: string;
+                    description: string;
+                };
+                remote: {
+                    type: string;
+                    description: string;
+                };
             };
+            required: string[];
         };
-        required: string[];
     };
-    handler(input: any): Promise<UniversalResponse>;
-};
+}
 //# sourceMappingURL=git-tags.d.ts.map

package/dist/tools/git-tags.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"git-tags.d.ts","sourceRoot":"","sources":["../../src/tools/git-tags.ts"],"names":[],"mappings":"AAAA,OAAO,EAA2B,iBAAiB,EAAc,MAAM,4BAA4B,CAAC;AAEpG,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;mBAID,GAAG,GAAG,OAAO,CAAC,iBAAiB,CAAC;CAItD,CAAC"}
+{"version":3,"file":"git-tags.d.ts","sourceRoot":"","sources":["../../src/tools/git-tags.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EAAsB,UAAU,EAAE,MAAM,iCAAiC,CAAC;AACjF,OAAO,EAAyB,UAAU,EAAE,MAAM,qCAAqC,CAAC;AAExF,OAAO,EAAE,cAAc,EAAqB,MAAM,uBAAuB,CAAC;AAE1E,MAAM,WAAW,aAAc,SAAQ,UAAU;IAC/C,MAAM,EAAE,QAAQ,GAAG,MAAM,GAAG,KAAK,GAAG,QAAQ,GAAG,QAAQ,CAAC;IAGxD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAGhB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IAGf,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,WAAW,CAAC,EAAE,OAAO,CAAC;IAGtB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,qBAAa,WAAW;IACtB,OAAO,CAAC,WAAW,CAAqB;IACxC,OAAO,CAAC,eAAe,CAAC,CAA2B;gBAEvC,cAAc,CAAC,EAAE,cAAc;IAO3C;;OAEG;IACG,OAAO,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,UAAU,CAAC;IAiDzD;;OAEG;YACW,qBAAqB;IAuBnC;;OAEG;YACW,sBAAsB;IA4DpC;;OAEG;YACW,eAAe;IAuE7B;;OAEG;YACW,cAAc;IAuD5B;;OAEG;YACW,YAAY;IAiE1B;;OAEG;YACW,eAAe;IAqE7B;;OAEG;YACW,gBAAgB;IAiE9B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAMzB;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAa/B;;OAEG;IACH,OAAO,CAAC,4BAA4B;IAYpC;;OAEG;IACH,MAAM,CAAC,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsErB"}

package/dist/tools/git-tags.js

@@ -1,14 +1,474 @@
 "use strict";
+/**
+ * Git Tags Tool
+ *
+ * Tag management tool providing comprehensive Git tag operations.
+ * Supports both local Git operations and remote provider operations.
+ *
+ * Operations: create, list, get, delete, search
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.gitTagsTool = void 0;
-const auto_detection_js_1 = require("../utils/auto-detection.js");
-exports.gitTagsTool = {
-    name: 'git-tags',
-    description: '🏷️ TAGS - Gerenciamento de tags',
-    inputSchema: { type: 'object', properties: { action: { type: 'string' }, projectPath: { type: 'string' } }, required: ['action', 'projectPath'] },
-    async handler(input) {
-        const detection = (0, auto_detection_js_1.autoDetect)(input.projectPath);
-        return (0, auto_detection_js_1.createUniversalResponse)(true, input.action, 'Tag processada', detection, 'git-tags', { tags: [] });
-    }
-};
+exports.GitTagsTool = void 0;
+const git_command_executor_js_1 = require("../utils/git-command-executor.js");
+const parameter_validator_js_1 = require("../utils/parameter-validator.js");
+const operation_error_handler_js_1 = require("../utils/operation-error-handler.js");
+const provider_operation_handler_js_1 = require("../providers/provider-operation-handler.js");
+class GitTagsTool {
+    gitExecutor;
+    providerHandler;
+    constructor(providerConfig) {
+        this.gitExecutor = new git_command_executor_js_1.GitCommandExecutor();
+        if (providerConfig) {
+            this.providerHandler = new provider_operation_handler_js_1.ProviderOperationHandler(providerConfig);
+        }
+    }
+    /**
+     * Execute git-tags operation
+     */
+    async execute(params) {
+        const startTime = Date.now();
+        try {
+            // Validate basic parameters
+            const validation = parameter_validator_js_1.ParameterValidator.validateToolParams('git-tags', params);
+            if (!validation.isValid) {
+                return operation_error_handler_js_1.OperationErrorHandler.createToolError('VALIDATION_ERROR', `Parameter validation failed: ${validation.errors.join(', ')}`, params.action, { validationErrors: validation.errors }, validation.suggestions);
+            }
+            // Validate operation-specific parameters
+            const operationValidation = parameter_validator_js_1.ParameterValidator.validateOperationParams('git-tags', params.action, params);
+            if (!operationValidation.isValid) {
+                return operation_error_handler_js_1.OperationErrorHandler.createToolError('VALIDATION_ERROR', `Operation validation failed: ${operationValidation.errors.join(', ')}`, params.action, { validationErrors: operationValidation.errors }, operationValidation.suggestions);
+            }
+            // Route to appropriate handler
+            const isRemoteOperation = this.isRemoteOperation(params.action);
+            if (isRemoteOperation && params.provider) {
+                return await this.executeRemoteOperation(params, startTime);
+            }
+            else {
+                return await this.executeLocalOperation(params, startTime);
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return operation_error_handler_js_1.OperationErrorHandler.createToolError('EXECUTION_ERROR', `Failed to execute ${params.action}: ${errorMessage}`, params.action, { error: errorMessage }, ['Check the error details and try again']);
+        }
+    }
+    /**
+     * Execute local Git tag operations
+     */
+    async executeLocalOperation(params, startTime) {
+        switch (params.action) {
+            case 'create':
+                return await this.handleCreateTag(params, startTime);
+            case 'list':
+                return await this.handleListTags(params, startTime);
+            case 'get':
+                return await this.handleGetTag(params, startTime);
+            case 'delete':
+                return await this.handleDeleteTag(params, startTime);
+            case 'search':
+                return await this.handleSearchTags(params, startTime);
+            default:
+                return operation_error_handler_js_1.OperationErrorHandler.createToolError('UNSUPPORTED_OPERATION', `Local operation '${params.action}' is not supported`, params.action, {}, ['Use one of: create, list, get, delete, search']);
+        }
+    }
+    /**
+     * Execute remote provider operations
+     */
+    async executeRemoteOperation(params, startTime) {
+        if (!this.providerHandler) {
+            return operation_error_handler_js_1.OperationErrorHandler.createToolError('PROVIDER_NOT_CONFIGURED', 'Provider handler is not configured for remote operations', params.action, {}, ['Configure GitHub or Gitea provider to use remote operations']);
+        }
+        if (!params.provider) {
+            return operation_error_handler_js_1.OperationErrorHandler.createToolError('PROVIDER_REQUIRED', 'Provider parameter is required for remote operations', params.action, {}, ['Specify provider as: github, gitea, or both']);
+        }
+        const operation = {
+            provider: params.provider,
+            operation: this.mapActionToProviderOperation(params.action),
+            parameters: this.extractRemoteParameters(params),
+            requiresAuth: true,
+            isRemoteOperation: true
+        };
+        try {
+            const result = await this.providerHandler.executeOperation(operation);
+            return {
+                success: result.success,
+                data: result.partialFailure ? result : result.results[0]?.data,
+                error: result.success ? undefined : {
+                    code: result.errors[0]?.error?.code || 'REMOTE_OPERATION_ERROR',
+                    message: result.errors[0]?.error?.message || 'Remote operation failed',
+                    details: result.errors,
+                    suggestions: ['Check provider configuration and credentials']
+                },
+                metadata: {
+                    provider: params.provider,
+                    operation: params.action,
+                    timestamp: new Date().toISOString(),
+                    executionTime: Date.now() - startTime
+                }
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return operation_error_handler_js_1.OperationErrorHandler.createToolError('REMOTE_OPERATION_ERROR', `Remote operation failed: ${errorMessage}`, params.action, { error: errorMessage }, ['Check provider configuration and network connectivity']);
+        }
+    }
+    /**
+     * Handle create tag operation
+     */
+    async handleCreateTag(params, startTime) {
+        try {
+            if (!params.tagName) {
+                return operation_error_handler_js_1.OperationErrorHandler.createToolError('MISSING_PARAMETER', 'tagName is required for tag creation', 'create', {}, ['Provide a name for the new tag']);
+            }
+            // Check if tag already exists
+            const existingTags = await this.gitExecutor.listTags(params.projectPath);
+            if (existingTags.success && existingTags.tags?.includes(params.tagName)) {
+                if (!params.force) {
+                    return operation_error_handler_js_1.OperationErrorHandler.createToolError('TAG_EXISTS', `Tag '${params.tagName}' already exists`, 'create', { tagName: params.tagName }, ['Use force=true to overwrite the existing tag or choose a different name']);
+                }
+            }
+            // Determine tag type
+            const isAnnotated = Boolean(params.annotated || (params.message && !params.lightweight));
+            const result = await this.gitExecutor.createTag(params.projectPath, params.tagName, {
+                message: params.message,
+                commit: params.commit,
+                annotated: isAnnotated,
+                force: Boolean(params.force)
+            });
+            if (!result.success) {
+                return operation_error_handler_js_1.OperationErrorHandler.handleGitError(result.stderr, 'create tag', params.projectPath);
+            }
+            return {
+                success: true,
+                data: {
+                    message: `Tag '${params.tagName}' created successfully`,
+                    tagName: params.tagName,
+                    type: isAnnotated ? 'annotated' : 'lightweight',
+                    commit: params.commit || 'HEAD',
+                    tagMessage: params.message,
+                    output: result.stdout
+                },
+                metadata: {
+                    operation: 'create',
+                    timestamp: new Date().toISOString(),
+                    executionTime: Date.now() - startTime
+                }
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return operation_error_handler_js_1.OperationErrorHandler.createToolError('CREATE_TAG_ERROR', `Failed to create tag: ${errorMessage}`, 'create', { error: errorMessage, projectPath: params.projectPath });
+        }
+    }
+    /**
+     * Handle list tags operation
+     */
+    async handleListTags(params, startTime) {
+        try {
+            const result = await this.gitExecutor.listTags(params.projectPath, {
+                pattern: params.pattern,
+                sort: 'version:refname'
+            });
+            if (!result.success) {
+                return operation_error_handler_js_1.OperationErrorHandler.handleGitError(result.stderr, 'list tags', params.projectPath);
+            }
+            // Get detailed information for each tag
+            const tagDetails = [];
+            if (result.tags && result.tags.length > 0) {
+                for (const tag of result.tags.slice(0, 50)) { // Limit to 50 tags for performance
+                    const tagInfo = await this.gitExecutor.getTagInfo(params.projectPath, tag);
+                    if (tagInfo.success) {
+                        tagDetails.push({
+                            name: tag,
+                            type: tagInfo.type,
+                            commit: tagInfo.commit,
+                            message: tagInfo.message,
+                            tagger: tagInfo.tagger,
+                            date: tagInfo.date
+                        });
+                    }
+                }
+            }
+            return {
+                success: true,
+                data: {
+                    tags: result.tags || [],
+                    tagDetails,
+                    total: result.tags?.length || 0,
+                    pattern: params.pattern,
+                    raw: result.stdout
+                },
+                metadata: {
+                    operation: 'list',
+                    timestamp: new Date().toISOString(),
+                    executionTime: Date.now() - startTime
+                }
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return operation_error_handler_js_1.OperationErrorHandler.createToolError('LIST_TAGS_ERROR', `Failed to list tags: ${errorMessage}`, 'list', { error: errorMessage, projectPath: params.projectPath });
+        }
+    }
+    /**
+     * Handle get tag operation
+     */
+    async handleGetTag(params, startTime) {
+        try {
+            if (!params.tagName) {
+                return operation_error_handler_js_1.OperationErrorHandler.createToolError('MISSING_PARAMETER', 'tagName is required for get tag operation', 'get', {}, ['Provide the name of the tag to get information about']);
+            }
+            // Get tag information
+            const tagInfo = await this.gitExecutor.getTagInfo(params.projectPath, params.tagName);
+            if (!tagInfo.success) {
+                return operation_error_handler_js_1.OperationErrorHandler.handleGitError(tagInfo.stderr, 'get tag info', params.projectPath);
+            }
+            if (!tagInfo.exists) {
+                return operation_error_handler_js_1.OperationErrorHandler.createToolError('TAG_NOT_FOUND', `Tag '${params.tagName}' does not exist`, 'get', { tagName: params.tagName }, ['Check the tag name or list available tags first']);
+            }
+            // Get commit information for the tag
+            const commitInfo = await this.gitExecutor.getCommitInfo(params.projectPath, tagInfo.commit || params.tagName);
+            return {
+                success: true,
+                data: {
+                    tagName: params.tagName,
+                    type: tagInfo.type,
+                    commit: tagInfo.commit,
+                    message: tagInfo.message,
+                    tagger: tagInfo.tagger,
+                    date: tagInfo.date,
+                    commitInfo: commitInfo.success ? {
+                        hash: commitInfo.hash,
+                        author: commitInfo.author,
+                        date: commitInfo.date,
+                        message: commitInfo.message
+                    } : null
+                },
+                metadata: {
+                    operation: 'get',
+                    timestamp: new Date().toISOString(),
+                    executionTime: Date.now() - startTime
+                }
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return operation_error_handler_js_1.OperationErrorHandler.createToolError('GET_TAG_ERROR', `Failed to get tag information: ${errorMessage}`, 'get', { error: errorMessage, projectPath: params.projectPath });
+        }
+    }
+    /**
+     * Handle delete tag operation
+     */
+    async handleDeleteTag(params, startTime) {
+        try {
+            if (!params.tagName) {
+                return operation_error_handler_js_1.OperationErrorHandler.createToolError('MISSING_PARAMETER', 'tagName is required for tag deletion', 'delete', {}, ['Provide the name of the tag to delete']);
+            }
+            // Check if tag exists
+            const tagInfo = await this.gitExecutor.getTagInfo(params.projectPath, params.tagName);
+            if (tagInfo.success && !tagInfo.exists) {
+                return operation_error_handler_js_1.OperationErrorHandler.createToolError('TAG_NOT_FOUND', `Tag '${params.tagName}' does not exist`, 'delete', { tagName: params.tagName }, ['Check the tag name or list available tags first']);
+            }
+            const result = await this.gitExecutor.deleteTag(params.projectPath, params.tagName, {
+                force: Boolean(params.force)
+            });
+            if (!result.success) {
+                return operation_error_handler_js_1.OperationErrorHandler.handleGitError(result.stderr, 'delete tag', params.projectPath);
+            }
+            // Also delete from remote if specified
+            let remoteDeleteResult = null;
+            if (params.remote) {
+                remoteDeleteResult = await this.gitExecutor.deleteRemoteTag(params.projectPath, params.remote, params.tagName);
+            }
+            return {
+                success: true,
+                data: {
+                    message: `Tag '${params.tagName}' deleted successfully`,
+                    tagName: params.tagName,
+                    deletedFromRemote: params.remote ? remoteDeleteResult?.success : false,
+                    remote: params.remote,
+                    output: result.stdout,
+                    remoteOutput: remoteDeleteResult?.stdout
+                },
+                metadata: {
+                    operation: 'delete',
+                    timestamp: new Date().toISOString(),
+                    executionTime: Date.now() - startTime
+                }
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return operation_error_handler_js_1.OperationErrorHandler.createToolError('DELETE_TAG_ERROR', `Failed to delete tag: ${errorMessage}`, 'delete', { error: errorMessage, projectPath: params.projectPath });
+        }
+    }
+    /**
+     * Handle search tags operation
+     */
+    async handleSearchTags(params, startTime) {
+        try {
+            const searchPattern = params.pattern || params.query || '*';
+            const result = await this.gitExecutor.listTags(params.projectPath, {
+                pattern: searchPattern,
+                sort: 'version:refname'
+            });
+            if (!result.success) {
+                return operation_error_handler_js_1.OperationErrorHandler.handleGitError(result.stderr, 'search tags', params.projectPath);
+            }
+            // Filter tags based on query if provided
+            let filteredTags = result.tags || [];
+            if (params.query && params.query !== searchPattern) {
+                const queryLower = params.query.toLowerCase();
+                filteredTags = filteredTags.filter(tag => tag.toLowerCase().includes(queryLower));
+            }
+            // Get detailed information for matching tags
+            const tagDetails = [];
+            for (const tag of filteredTags.slice(0, 20)) { // Limit to 20 tags for performance
+                const tagInfo = await this.gitExecutor.getTagInfo(params.projectPath, tag);
+                if (tagInfo.success) {
+                    tagDetails.push({
+                        name: tag,
+                        type: tagInfo.type,
+                        commit: tagInfo.commit,
+                        message: tagInfo.message,
+                        tagger: tagInfo.tagger,
+                        date: tagInfo.date
+                    });
+                }
+            }
+            return {
+                success: true,
+                data: {
+                    query: params.query || params.pattern,
+                    pattern: searchPattern,
+                    matches: filteredTags,
+                    tagDetails,
+                    total: filteredTags.length,
+                    totalTags: result.tags?.length || 0
+                },
+                metadata: {
+                    operation: 'search',
+                    timestamp: new Date().toISOString(),
+                    executionTime: Date.now() - startTime
+                }
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return operation_error_handler_js_1.OperationErrorHandler.createToolError('SEARCH_TAGS_ERROR', `Failed to search tags: ${errorMessage}`, 'search', { error: errorMessage, projectPath: params.projectPath });
+        }
+    }
+    /**
+     * Check if operation is a remote operation
+     */
+    isRemoteOperation(action) {
+        // Tags can be synchronized with remote, but core operations are local
+        // Remote operations would be handled through provider APIs for releases
+        return false;
+    }
+    /**
+     * Extract parameters for remote operations
+     */
+    extractRemoteParameters(params) {
+        const remoteParams = {
+            projectPath: params.projectPath
+        };
+        if (params.owner)
+            remoteParams.owner = params.owner;
+        if (params.repo)
+            remoteParams.repo = params.repo;
+        if (params.tagName)
+            remoteParams.tagName = params.tagName;
+        if (params.message)
+            remoteParams.message = params.message;
+        return remoteParams;
+    }
+    /**
+     * Map git-tags actions to provider operations
+     */
+    mapActionToProviderOperation(action) {
+        const actionMap = {
+            'list': 'tag-list',
+            'get': 'tag-get',
+            'create': 'tag-create',
+            'delete': 'tag-delete',
+            'search': 'tag-search'
+        };
+        return actionMap[action] || action;
+    }
+    /**
+     * Get tool schema for MCP registration
+     */
+    static getToolSchema() {
+        return {
+            name: 'git-tags',
+            description: 'Git tag management tool for tag operations. Supports create, list, get, delete, and search operations for both lightweight and annotated tags.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    action: {
+                        type: 'string',
+                        enum: ['create', 'list', 'get', 'delete', 'search'],
+                        description: 'The tag operation to perform'
+                    },
+                    projectPath: {
+                        type: 'string',
+                        description: 'Absolute path to the project directory'
+                    },
+                    provider: {
+                        type: 'string',
+                        enum: ['github', 'gitea', 'both'],
+                        description: 'Provider for remote operations (optional)'
+                    },
+                    tagName: {
+                        type: 'string',
+                        description: 'Name of the tag (required for create, get, delete)'
+                    },
+                    message: {
+                        type: 'string',
+                        description: 'Tag message for annotated tags (for create action)'
+                    },
+                    commit: {
+                        type: 'string',
+                        description: 'Specific commit to tag (default: HEAD, for create action)'
+                    },
+                    pattern: {
+                        type: 'string',
+                        description: 'Pattern to filter tags (for list, search actions)'
+                    },
+                    query: {
+                        type: 'string',
+                        description: 'Search query for tags (for search action)'
+                    },
+                    force: {
+                        type: 'boolean',
+                        description: 'Force operation (for create, delete actions)'
+                    },
+                    annotated: {
+                        type: 'boolean',
+                        description: 'Create annotated tag (for create action)'
+                    },
+                    lightweight: {
+                        type: 'boolean',
+                        description: 'Create lightweight tag (for create action)'
+                    },
+                    owner: {
+                        type: 'string',
+                        description: 'Repository owner (for remote operations)'
+                    },
+                    repo: {
+                        type: 'string',
+                        description: 'Repository name (for remote operations)'
+                    },
+                    remote: {
+                        type: 'string',
+                        description: 'Remote name for remote tag operations (default: origin)'
+                    }
+                },
+                required: ['action', 'projectPath']
+            }
+        };
+    }
+}
+exports.GitTagsTool = GitTagsTool;
 //# sourceMappingURL=git-tags.js.map