@andrebuzeli/git-mcp 3.3.0 → 4.0.2

package/dist/tools/git-tags.js

@@ -1,486 +1,615 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.tagsTool = void 0;
+exports.gitTagsTool = void 0;
 const zod_1 = require("zod");
-const index_js_1 = require("../providers/index.js");
-const user_detection_js_1 = require("../utils/user-detection.js");
+const auto_detection_js_1 = require("../utils/auto-detection.js");
+const error_handler_js_1 = require("../utils/error-handler.js");
+const git_operations_js_1 = require("../utils/git-operations.js");
 /**
- * Tool: tags
+ * Tool: git-tags
  *
- * DESCRIÇÃO:
- * Gerenciamento completo de tags com suporte multi-provider (GitHub e Gitea)
+ * GERENCIAMENTO DE TAGS UNIFICADO
+ * Tags inteligentes com versionamento semântico e multi-provider
  *
- * FUNCIONALIDADES:
- * - Criação de novas tags
- * - Listagem e busca de tags
- * - Obtenção de detalhes específicos
- * - Exclusão de tags
- * - Controle de versão
- * - Busca por padrões
- *
- * USO:
- * - Para marcar versões específicas
- * - Para controle de release
- * - Para rollback de código
- * - Para identificação de commits
- *
- * RECOMENDAÇÕES:
- * - Use versionamento semântico
- * - Mantenha tags organizadas
- * - Documente propósito das tags
- * - Use para pontos de referência
- */
-/**
- * Schema de validação para entrada da tool tags
- *
- * VALIDAÇÕES:
- * - action: Ação obrigatória (create, list, get, delete, search)
- * - Parâmetros específicos por ação
- * - Validação de tipos e formatos
- *
- * RECOMENDAÇÕES:
- * - Sempre valide entrada antes de usar
- * - Use parâmetros opcionais adequadamente
- * - Documente parâmetros obrigatórios
+ * DESIGNED FOR: Programador individual autônomo
+ * PHILOSOPHY: Tags organizadas automaticamente para versionamento
  */
-const TagsInputSchema = zod_1.z.object({
-    action: zod_1.z.enum(['create', 'list', 'get', 'delete', 'search']),
-    // Parâmetros comuns
-    provider: zod_1.z.enum(['gitea', 'github']).describe('Provider to use (gitea or github)'),
-    projectPath: zod_1.z.string().describe('Local project path for git operations'),
-    repo: zod_1.z.string().optional().describe('Repository name (extracted from projectPath)'),
-    // Para create
-    tag_name: zod_1.z.string().optional(),
-    message: zod_1.z.string().optional(),
-    target: zod_1.z.string().optional(),
-    type: zod_1.z.enum(['lightweight', 'annotated']).optional(),
-    tagger_name: zod_1.z.string().optional(),
-    tagger_email: zod_1.z.string().optional(),
-    // Para get/delete
-    tag: zod_1.z.string().optional(),
-    // Para list
-    page: zod_1.z.number().min(1).optional(),
-    // Para search
-    query: zod_1.z.string().optional(),
-    pattern: zod_1.z.string().optional(),
-});
+const GitTagsInputSchema = zod_1.z.discriminatedUnion('action', [
+    // CREATE TAG - Criação inteligente
+    zod_1.z.object({
+        action: zod_1.z.literal('create'),
+        projectPath: zod_1.z.string(),
+        name: zod_1.z.string(),
+        message: zod_1.z.string().optional(), // Auto-generate se não fornecido
+        target: zod_1.z.string().optional(), // Commit/branch, default HEAD
+        type: zod_1.z.enum(['lightweight', 'annotated']).default('annotated'),
+        force: zod_1.z.boolean().default(false)
+    }),
+    // LIST TAGS - Listagem com filtros
+    zod_1.z.object({
+        action: zod_1.z.literal('list'),
+        projectPath: zod_1.z.string(),
+        pattern: zod_1.z.string().optional(), // Filtrar por padrão (ex: v*)
+        sort: zod_1.z.enum(['version', 'date', 'name']).default('version'),
+        limit: zod_1.z.number().default(20)
+    }),
+    // GET TAG - Detalhes específicos
+    zod_1.z.object({
+        action: zod_1.z.literal('get'),
+        projectPath: zod_1.z.string(),
+        name: zod_1.z.string(),
+        detailed: zod_1.z.boolean().default(false)
+    }),
+    // DELETE TAG - Remoção segura
+    zod_1.z.object({
+        action: zod_1.z.literal('delete'),
+        projectPath: zod_1.z.string(),
+        name: zod_1.z.string(),
+        remote: zod_1.z.boolean().default(true), // Deletar também do remote
+        force: zod_1.z.boolean().default(false)
+    }),
+    // SEARCH TAGS - Busca avançada
+    zod_1.z.object({
+        action: zod_1.z.literal('search'),
+        projectPath: zod_1.z.string(),
+        query: zod_1.z.string(),
+        pattern: zod_1.z.string().optional(),
+        sort: zod_1.z.enum(['relevance', 'date', 'name']).default('relevance'),
+        limit: zod_1.z.number().default(10)
+    })
+]);
 /**
- * Schema de saída padronizado
- *
- * ESTRUTURA:
- * - success: Status da operação
- * - action: Ação executada
- * - message: Mensagem descritiva
- * - data: Dados retornados (opcional)
- * - error: Detalhes do erro (opcional)
+ * Smart Tag Manager
+ * Gerencia operações de tags com inteligência
  */
-const TagsResultSchema = zod_1.z.object({
-    success: zod_1.z.boolean(),
-    action: zod_1.z.string(),
-    message: zod_1.z.string(),
-    data: zod_1.z.any().optional(),
-    error: zod_1.z.string().optional()
-});
-/**
- * Tool: tags
- *
- * DESCRIÇÃO:
- * Gerenciamento completo de tags Gitea com múltiplas ações
- *
- * ACTIONS DISPONÍVEIS:
- *
- * 1. create - Criar nova tag
- *    Parâmetros:
- *    - owner (obrigatório): Proprietário do repositório
- *    - repo (obrigatório): Nome do repositório
- *    - tag_name (obrigatório): Nome da tag
- *    - message (opcional): Mensagem da tag (para tags anotadas)
- *    - target (obrigatório): Commit, branch ou tag alvo
- *    - type (opcional): Tipo de tag (lightweight, annotated) - padrão: lightweight
- *    - tagger_name (opcional): Nome do tagger (para tags anotadas)
- *    - tagger_email (opcional): Email do tagger (para tags anotadas)
- *
- * 2. list - Listar tags
- *    Parâmetros:
- *    - owner (obrigatório): Proprietário do repositório
- *    - repo (obrigatório): Nome do repositório
- *    - page (opcional): Página da listagem (padrão: 1)
- *    - limit (opcional): Itens por página (padrão: 30, máximo: 100)
- *
- * 3. get - Obter detalhes da tag
- *    Parâmetros:
- *    - owner (obrigatório): Proprietário do repositório
- *    - repo (obrigatório): Nome do repositório
- *    - tag (obrigatório): Nome da tag
- *
- * 4. delete - Deletar tag
- *    Parâmetros:
- *    - owner (obrigatório): Proprietário do repositório
- *    - repo (obrigatório): Nome do repositório
- *    - tag (obrigatório): Nome da tag
- *
- * 5. search - Buscar tags
- *    Parâmetros:
- *    - owner (obrigatório): Proprietário do repositório
- *    - repo (obrigatório): Nome do repositório
- *    - query (opcional): Termo de busca
- *    - pattern (opcional): Padrão de busca (ex: v*.*.*)
- *
- * RECOMENDAÇÕES DE USO:
- * - Use convenções de nomenclatura consistentes
- * - Documente propósito das tags
- * - Mantenha tags organizadas
- * - Use versionamento semântico
- * - Use tags anotadas para releases importantes
- * - Limpe tags antigas regularmente
- */
-exports.tagsTool = {
-    name: 'git-tags',
-    description: 'tool: Gerencia tags Git para versionamento e releases\n──────────────\naction create: cria nova tag\naction create requires: repo, tag_name, message, target, type, tagger_name, tagger_email, provider\n───────────────\naction list: lista tags do repositório\naction list requires: repo, page,provider\n───────────────\naction get: obtém detalhes de tag\naction get requires: repo, tag, provider\n───────────────\naction delete: remove tag\naction delete requires: repo, tag, provider\n───────────────\naction search: busca tags por critérios\naction search requires: repo, query, pattern, provider',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            action: {
-                type: 'string',
-                enum: ['create', 'list', 'get', 'delete', 'search'],
-                description: 'Action to perform on tags'
-            },
-            repo: { type: 'string', description: 'Repository name' },
-            provider: { type: 'string', description: 'Provider to use (github, gitea, or omit for default)' },
-            tag_name: { type: 'string', description: 'Tag name' },
-            message: { type: 'string', description: 'Tag message (for annotated tags)' },
-            target: { type: 'string', description: 'Target commit SHA, branch or tag' },
-            type: { type: 'string', enum: ['lightweight', 'annotated'], description: 'Tag type' },
-            tagger_name: { type: 'string', description: 'Tagger name' },
-            tagger_email: { type: 'string', description: 'Tagger email' },
-            tag: { type: 'string', description: 'Tag name for get/delete operations' },
-            page: { type: 'number', description: 'Page number', minimum: 1 },
-            query: { type: 'string', description: 'Search query' },
-            pattern: { type: 'string', description: 'Search pattern (e.g., v*.*.*)' }
-        },
-        required: ['action', 'provider', 'projectPath']
-    },
-    /**
-     * Handler principal da tool tags
-     *
-     * FUNCIONALIDADE:
-     * - Valida entrada usando Zod schema
-     * - Roteia para método específico baseado na ação
-     * - Trata erros de forma uniforme
-     * - Retorna resultado padronizado
-     *
-     * FLUXO:
-     * 1. Validação de entrada
-     * 2. Seleção do provider
-     * 3. Roteamento por ação
-     * 4. Execução do método específico
-     * 5. Tratamento de erros
-     * 6. Retorno de resultado
-     *
-     * TRATAMENTO DE ERROS:
-     * - Validação: erro de schema
-     * - Execução: erro da operação
-     * - Roteamento: ação não suportada
-     *
-     * RECOMENDAÇÕES:
-     * - Sempre valide entrada antes de processar
-     * - Trate erros específicos adequadamente
-     * - Log detalhes de erro para debug
-     * - Retorne mensagens de erro úteis
-     */
-    async handler(input) {
+class SmartTagManager {
+    static async getAllTags(projectPath) {
+        const gitOps = new git_operations_js_1.GitOperations(projectPath);
         try {
-            const validatedInput = TagsInputSchema.parse(input);
-            // Aplicar extração automática do nome do repositório
-            const processedInput = (0, user_detection_js_1.applyAutoRepoExtraction)(validatedInput);
-            // Aplicar auto-detecção apenas para owner dentro do provider especificado
-            const finalInput = await (0, user_detection_js_1.applyAutoUserDetection)(processedInput, processedInput.provider);
-            // Usar o provider especificado pelo usuário (obrigatório)
-            if (!processedInput.provider) {
-                throw new Error("Parâmetro 'provider' é obrigatório e não pode ser omitido");
-            }
-            const provider = index_js_1.globalProviderFactory.getProvider(processedInput.provider);
-            if (!provider) {
-                throw new Error(`Provider '${processedInput.provider}' não encontrado`);
-            }
-            switch (processedInput.action) {
-                case 'create':
-                    return await this.createTag(processedInput, provider);
-                case 'list':
-                    return await this.listTags(processedInput, provider);
-                case 'get':
-                    return await this.getTag(processedInput, provider);
-                case 'delete':
-                    return await this.deleteTag(processedInput, provider);
-                case 'search':
-                    return await this.searchTags(processedInput, provider);
-                default:
-                    throw new Error(`Ação não suportada: ${processedInput.action}`);
+            // Get all tags with details
+            const tagResult = await gitOps.runCommand('git', ['tag', '-l', '--format=%(refname:short)|%(objectname)|%(creatordate)|%(subject)']);
+            if (!tagResult.success) {
+                return [];
             }
+            const lines = tagResult.output.trim().split('\n');
+            const tags = [];
+            lines.forEach(line => {
+                const parts = line.split('|');
+                if (parts.length >= 4) {
+                    const [name, hash, date, message] = parts;
+                    tags.push({
+                        name,
+                        hash,
+                        date: new Date(date),
+                        message: message.trim(),
+                        type: this.detectTagType(name),
+                        version: this.parseVersion(name)
+                    });
+                }
+            });
+            return tags;
         }
         catch (error) {
+            return [];
+        }
+    }
+    static async getTagInfo(projectPath, tagName) {
+        const gitOps = new git_operations_js_1.GitOperations(projectPath);
+        try {
+            // Check if tag exists
+            const existsResult = await gitOps.runCommand('git', ['tag', '-l', tagName]);
+            const exists = existsResult.success && existsResult.output.trim() === tagName;
+            if (!exists) {
+                return { name: tagName, exists: false };
+            }
+            // Get detailed info
+            const showResult = await gitOps.runCommand('git', ['show', '--quiet', '--format=fuller', tagName]);
+            const info = this.parseTagShow(showResult.success ? showResult.output : '');
             return {
-                success: false,
-                action: input.action,
-                message: 'Erro na operação de tags',
-                error: error instanceof Error ? error.message : String(error)
+                name: tagName,
+                exists: true,
+                ...info,
+                type: this.detectTagType(tagName),
+                version: this.parseVersion(tagName)
             };
         }
-    },
+        catch (error) {
+            return { name: tagName, exists: false, error: error instanceof Error ? error.message : String(error) };
+        }
+    }
+    static parseTagShow(output) {
+        const lines = output.split('\n');
+        let info = {
+            hash: '',
+            author: '',
+            date: null,
+            message: ''
+        };
+        let inMessage = false;
+        let messageLines = [];
+        lines.forEach(line => {
+            if (line.startsWith('commit ')) {
+                info.hash = line.substring(7);
+            }
+            else if (line.startsWith('Tagger:')) {
+                info.author = line.substring(7).trim();
+            }
+            else if (line.startsWith('Date:')) {
+                info.date = new Date(line.substring(5).trim());
+            }
+            else if (line.startsWith('Tag:')) {
+                // Lightweight tag
+                info.lightweight = true;
+            }
+            else if (inMessage || (!line.trim() && messageLines.length > 0)) {
+                inMessage = true;
+                messageLines.push(line);
+            }
+        });
+        info.message = messageLines.join('\n').trim();
+        return info;
+    }
+    static detectTagType(tagName) {
+        // Check for semantic versioning
+        if (/^v?\d+\.\d+\.\d+/.test(tagName)) {
+            return 'semantic';
+        }
+        // For now, we can't easily distinguish annotated vs lightweight without more git commands
+        // This would require checking if the tag points to a tag object or directly to a commit
+        return 'other';
+    }
+    static parseVersion(tagName) {
+        const match = tagName.match(/^v?(\d+)\.(\d+)\.(\d+)(?:-(.+))?$/);
+        if (!match)
+            return null;
+        return {
+            major: parseInt(match[1]),
+            minor: parseInt(match[2]),
+            patch: parseInt(match[3]),
+            prerelease: match[4]
+        };
+    }
+    static generateTagMessage(tagName, customMessage) {
+        if (customMessage)
+            return customMessage;
+        const version = this.parseVersion(tagName);
+        if (version) {
+            return `Release ${tagName}`;
+        }
+        return `Tag: ${tagName}`;
+    }
+    static validateTagName(name) {
+        // Git tag name rules
+        if (!name || name.trim().length === 0) {
+            return { valid: false, error: 'Tag name cannot be empty' };
+        }
+        if (name.includes(' ')) {
+            return { valid: false, error: 'Tag name cannot contain spaces' };
+        }
+        if (name.startsWith('-') || name.endsWith('-')) {
+            return { valid: false, error: 'Tag name cannot start or end with dash' };
+        }
+        // Check for invalid characters
+        if (/[^a-zA-Z0-9._-]/g.test(name)) {
+            return { valid: false, error: 'Tag name contains invalid characters' };
+        }
+        return { valid: true };
+    }
+    static sortTags(tags, sortBy) {
+        return tags.sort((a, b) => {
+            switch (sortBy) {
+                case 'version':
+                    const aVer = a.version;
+                    const bVer = b.version;
+                    if (!aVer && !bVer)
+                        return a.name.localeCompare(b.name);
+                    if (!aVer)
+                        return 1;
+                    if (!bVer)
+                        return -1;
+                    if (aVer.major !== bVer.major)
+                        return bVer.major - aVer.major;
+                    if (aVer.minor !== bVer.minor)
+                        return bVer.minor - aVer.minor;
+                    return bVer.patch - aVer.patch;
+                case 'date':
+                    return b.date.getTime() - a.date.getTime();
+                case 'name':
+                default:
+                    return a.name.localeCompare(b.name);
+            }
+        });
+    }
+    static filterTags(tags, pattern) {
+        if (!pattern)
+            return tags;
+        const regex = new RegExp(pattern.replace(/\*/g, '.*'), 'i');
+        return tags.filter(tag => regex.test(tag.name));
+    }
+}
+/**
+ * Classe principal para executar operações Git tags
+ */
+class GitTagsExecutor {
+    errorHandler = new error_handler_js_1.UniversalErrorHandler();
     /**
-     * Cria uma nova tag no repositório
-     *
-     * FUNCIONALIDADE:
-     * - Cria tag com nome e target especificados
-     * - Suporta tags lightweight e anotadas
-     * - Permite configuração de tagger
-     *
-     * PARÂMETROS OBRIGATÓRIOS:
-     * - owner: Proprietário do repositório
-     * - repo: Nome do repositório
-     * - tag_name: Nome da tag
-     * - target: Commit, branch ou tag alvo
-     *
-     * PARÂMETROS OPCIONAIS:
-     * - message: Mensagem da tag (para tags anotadas)
-     * - type: Tipo de tag (lightweight, annotated) - padrão: lightweight
-     * - tagger_name: Nome do tagger (para tags anotadas)
-     * - tagger_email: Email do tagger (para tags anotadas)
-     *
-     * VALIDAÇÕES:
-     * - Todos os parâmetros obrigatórios
-     * - Nome da tag deve ser único no repositório
-     * - Target deve existir
-     * - Usuário deve ter permissão de escrita
-     *
-     * RECOMENDAÇÕES:
-     * - Use convenções de nomenclatura consistentes
-     * - Use tags anotadas para releases importantes
-     * - Documente propósito da tag
-     * - Use versionamento semântico
+     * Executa operação create
      */
-    async createTag(params, provider) {
+    async executeCreate(detection, input) {
         try {
-            if (!params.repo || !params.tag_name || !params.target) {
-                throw new Error('Repo, tag_name e target são obrigatórios');
+            const gitOps = new git_operations_js_1.GitOperations(detection.projectPath);
+            // Validate tag name
+            const nameValidation = SmartTagManager.validateTagName(input.name);
+            if (!nameValidation.valid) {
+                throw new Error(`Invalid tag name: ${nameValidation.error}`);
             }
-            const currentUser = await provider.getCurrentUser();
-            const owner = currentUser.login;
-            const tagData = {
-                tag_name: params.tag_name,
-                target: params.target
-            };
-            if (params.type === 'annotated') {
-                if (params.message)
-                    tagData.message = params.message;
-                if (params.tagger_name)
-                    tagData.tagger_name = params.tagger_name;
-                if (params.tagger_email)
-                    tagData.tagger_email = params.tagger_email;
+            // Check if tag already exists
+            const existingTag = await SmartTagManager.getTagInfo(detection.projectPath, input.name);
+            if (existingTag.exists && !input.force) {
+                throw new Error(`Tag '${input.name}' already exists. Use force=true to overwrite.`);
             }
-            const tag = await provider.createTag(owner, params.repo, tagData);
-            return {
+            // Determine target
+            const target = input.target || 'HEAD';
+            // Validate target exists
+            const targetResult = await gitOps.runCommand('git', ['rev-parse', '--verify', target]);
+            if (!targetResult.success) {
+                throw new Error(`Invalid target reference: ${target}`);
+            }
+            // Generate message if not provided
+            const message = SmartTagManager.generateTagMessage(input.name, input.message);
+            // Create tag
+            const tagArgs = input.type === 'annotated' ?
+                ['tag', '-a', input.name, '-m', message, target] :
+                ['tag', input.name, target];
+            if (input.force) {
+                tagArgs.splice(1, 0, '-f');
+            }
+            const tagResult = await gitOps.runCommand('git', tagArgs);
+            if (!tagResult.success) {
+                throw new Error(`Failed to create tag: ${tagResult.error}`);
+            }
+            // Push tag to all providers
+            for (const provider of detection.providers) {
+                try {
+                    await gitOps.runCommand('git', ['push', provider, input.name]);
+                }
+                catch (error) {
+                    console.warn(`Failed to push tag to ${provider}:`, error);
+                }
+            }
+            return (0, auto_detection_js_1.createUniversalResponse)({
                 success: true,
                 action: 'create',
-                message: `Tag '${params.tag_name}' criada com sucesso`,
-                data: tag
-            };
+                message: `Tag '${input.name}' created successfully`,
+                data: {
+                    tag: input.name,
+                    message: message,
+                    target: target,
+                    type: input.type,
+                    force: input.force,
+                    pushed: detection.providers,
+                    tagType: SmartTagManager.detectTagType(input.name)
+                },
+                autoDetected: {
+                    repo: detection.repoName,
+                    owner: detection.owner,
+                    providers: detection.providers
+                }
+            });
         }
         catch (error) {
-            throw new Error(`Falha ao criar tag: ${error instanceof Error ? error.message : String(error)}`);
+            return this.errorHandler.toUniversalResponse();
         }
-    },
+    }
     /**
-     * Lista tags do repositório
-     *
-     * FUNCIONALIDADE:
-     * - Lista tags com paginação
-     * - Retorna informações básicas de cada tag
-     * - Inclui commit alvo e URLs de download
-     *
-     * PARÂMETROS OBRIGATÓRIOS:
-     * - owner: Proprietário do repositório
-     * - repo: Nome do repositório
-     *
-     * PARÂMETROS OPCIONAIS:
-     * - page: Página da listagem (padrão: 1)
-     * - limit: Itens por página (padrão: 30, máximo: 100)
-     *
-     * VALIDAÇÕES:
-     * - e repo obrigatórios
-     * - Page deve ser >= 1
-     * - Limit deve ser entre 1 e 100
-     *
-     * RECOMENDAÇÕES:
-     * - Use paginação para repositórios com muitas tags
-     * - Monitore número total de tags
-     * - Verifique commit alvo de cada tag
-     * - Mantenha tags organizadas
+     * Executa operação list
      */
-    async listTags(params, provider) {
+    async executeList(detection, input) {
         try {
-            if (!params.repo) {
-                throw new Error('Repo é obrigatório');
-            }
-            const currentUser = await provider.getCurrentUser();
-            const owner = currentUser.login;
-            const page = params.page || 1;
-            const tags = await provider.listTags((await provider.getCurrentUser()).login, params.repo, page);
-            return {
+            const allTags = await SmartTagManager.getAllTags(detection.projectPath);
+            const filteredTags = SmartTagManager.filterTags(allTags, input.pattern);
+            const sortedTags = SmartTagManager.sortTags(filteredTags, input.sort);
+            const limitedTags = sortedTags.slice(0, input.limit);
+            return (0, auto_detection_js_1.createUniversalResponse)({
                 success: true,
                 action: 'list',
-                message: `${tags.length} tags encontradas`,
+                message: `Found ${limitedTags.length} tags`,
                 data: {
-                    tags,
-                    page,
-                    total: tags.length
+                    tags: limitedTags,
+                    total: allTags.length,
+                    filtered: filteredTags.length,
+                    pattern: input.pattern,
+                    sort: input.sort,
+                    limit: input.limit
+                },
+                autoDetected: {
+                    repo: detection.repoName,
+                    owner: detection.owner,
+                    providers: detection.providers
                 }
-            };
+            });
         }
         catch (error) {
-            throw new Error(`Falha ao listar tags: ${error instanceof Error ? error.message : String(error)}`);
+            return this.errorHandler.toUniversalResponse();
         }
-    },
+    }
     /**
-     * Obtém detalhes de uma tag específica
-     *
-     * FUNCIONALIDADE:
-     * - Retorna informações completas da tag
-     * - Inclui nome, commit alvo e URLs
-     * - Mostra tipo da tag (lightweight/anotada)
-     *
-     * PARÂMETROS OBRIGATÓRIOS:
-     * - owner: Proprietário do repositório
-     * - repo: Nome do repositório
-     * - tag: Nome da tag
-     *
-     * VALIDAÇÕES:
-     * - Todos os parâmetros obrigatórios
-     * - Tag deve existir no repositório
-     * - Nome deve ser válido
-     *
-     * RECOMENDAÇÕES:
-     * - Use para obter detalhes completos
-     * - Verifique commit alvo da tag
-     * - Analise URLs de download
-     * - Monitore mudanças importantes
+     * Executa operação get
      */
-    async getTag(params, provider) {
+    async executeGet(detection, input) {
         try {
-            if (!params.repo || !params.tag) {
-                throw new Error('Repo e tag são obrigatórios');
+            const tagInfo = await SmartTagManager.getTagInfo(detection.projectPath, input.name);
+            if (!tagInfo.exists) {
+                return (0, auto_detection_js_1.createUniversalResponse)({
+                    success: false,
+                    action: 'get',
+                    message: `Tag '${input.name}' not found`,
+                    error: {
+                        code: 'TAG_NOT_FOUND',
+                        message: `Tag '${input.name}' does not exist`,
+                        cause: 'Tag not found in repository',
+                        suggestion: 'Check tag name or create it first'
+                    },
+                    autoDetected: {
+                        repo: detection.repoName,
+                        owner: detection.owner,
+                        providers: detection.providers
+                    }
+                });
             }
-            const currentUser = await provider.getCurrentUser();
-            const owner = currentUser.login;
-            // Implementar obtenção de tag específica
-            // Por enquanto, retorna mensagem de funcionalidade
-            return {
+            return (0, auto_detection_js_1.createUniversalResponse)({
                 success: true,
                 action: 'get',
-                message: `Tag '${params.tag}' obtida com sucesso`,
+                message: `Tag '${input.name}' details`,
                 data: {
-                    tag: params.tag,
-                    note: 'Funcionalidade de obtenção de tag específica será implementada'
+                    tag: tagInfo,
+                    detailed: input.detailed
+                },
+                autoDetected: {
+                    repo: detection.repoName,
+                    owner: detection.owner,
+                    providers: detection.providers
                 }
-            };
+            });
         }
         catch (error) {
-            throw new Error(`Falha ao obter tag: ${error instanceof Error ? error.message : String(error)}`);
+            return this.errorHandler.toUniversalResponse();
         }
-    },
+    }
     /**
-     * Deleta uma tag do repositório
-     *
-     * FUNCIONALIDADE:
-     * - Remove tag especificada
-     * - Mantém commit alvo intacto
-     * - Confirma exclusão bem-sucedida
-     *
-     * PARÂMETROS OBRIGATÓRIOS:
-     * - owner: Proprietário do repositório
-     * - repo: Nome do repositório
-     * - tag: Nome da tag
-     *
-     * VALIDAÇÕES:
-     * - Todos os parâmetros obrigatórios
-     * - Tag deve existir
-     * - Usuário deve ter permissão de exclusão
-     *
-     * RECOMENDAÇÕES:
-     * - Confirme exclusão antes de executar
-     * - Verifique se tag não está sendo usada
-     * - Mantenha backup se necessário
-     * - Documente motivo da exclusão
+     * Executa operação delete
      */
-    async deleteTag(params, provider) {
+    async executeDelete(detection, input) {
         try {
-            if (!params.repo || !params.tag) {
-                throw new Error('Repo e tag são obrigatórios');
+            const gitOps = new git_operations_js_1.GitOperations(detection.projectPath);
+            // Check if tag exists
+            const tagInfo = await SmartTagManager.getTagInfo(detection.projectPath, input.name);
+            if (!tagInfo.exists && !input.force) {
+                throw new Error(`Tag '${input.name}' does not exist`);
             }
-            const currentUser = await provider.getCurrentUser();
-            const owner = currentUser.login;
-            await provider.deleteTag((await provider.getCurrentUser()).login, params.repo, params.tag);
-            return {
+            // Delete local tag
+            const deleteArgs = input.force ? ['tag', '-d', input.name] : ['tag', '-d', input.name];
+            const deleteResult = await gitOps.runCommand('git', deleteArgs);
+            if (!deleteResult.success && !input.force) {
+                throw new Error(`Failed to delete tag: ${deleteResult.error}`);
+            }
+            // Delete from remotes if requested
+            const remoteResults = [];
+            if (input.remote) {
+                for (const provider of detection.providers) {
+                    try {
+                        const remoteDeleteResult = await gitOps.runCommand('git', ['push', provider, `:${input.name}`]);
+                        remoteResults.push({
+                            provider,
+                            success: remoteDeleteResult.success,
+                            error: remoteDeleteResult.error
+                        });
+                    }
+                    catch (error) {
+                        remoteResults.push({
+                            provider,
+                            success: false,
+                            error: error instanceof Error ? error.message : String(error)
+                        });
+                    }
+                }
+            }
+            return (0, auto_detection_js_1.createUniversalResponse)({
                 success: true,
                 action: 'delete',
-                message: `Tag '${params.tag}' deletada com sucesso`,
-                data: { deleted: true }
-            };
+                message: `Tag '${input.name}' deleted successfully`,
+                data: {
+                    tag: input.name,
+                    force: input.force,
+                    remote: input.remote,
+                    remoteResults: remoteResults,
+                    existed: tagInfo.exists
+                },
+                autoDetected: {
+                    repo: detection.repoName,
+                    owner: detection.owner,
+                    providers: detection.providers
+                }
+            });
         }
         catch (error) {
-            throw new Error(`Falha ao deletar tag: ${error instanceof Error ? error.message : String(error)}`);
+            return this.errorHandler.toUniversalResponse();
         }
-    },
+    }
     /**
-     * Busca tags por critérios específicos
-     *
-     * FUNCIONALIDADE:
-     * - Busca tags por nome ou padrão
-     * - Suporta padrões glob (ex: v*.*.*)
-     * - Retorna resultados relevantes
-     *
-     * PARÂMETROS OBRIGATÓRIOS:
-     * - owner: Proprietário do repositório
-     * - repo: Nome do repositório
-     *
-     * PARÂMETROS OPCIONAIS:
-     * - query: Termo de busca
-     * - pattern: Padrão de busca (ex: v*.*.*)
-     *
-     * VALIDAÇÕES:
-     * - e repo obrigatórios
-     * - Query ou pattern deve ser fornecido
-     * - Repositório deve existir
-     *
-     * RECOMENDAÇÕES:
-     * - Use padrões glob para busca eficiente
-     * - Combine com filtros de nome
-     * - Analise resultados para relevância
-     * - Use para encontrar tags relacionadas
+     * Executa operação search
      */
-    async searchTags(params, provider) {
+    async executeSearch(detection, input) {
         try {
-            if (!params.repo) {
-                throw new Error('Repo é obrigatório');
+            const allTags = await SmartTagManager.getAllTags(detection.projectPath);
+            // Search by query
+            let matchedTags = allTags.filter(tag => tag.name.toLowerCase().includes(input.query.toLowerCase()) ||
+                tag.message.toLowerCase().includes(input.query.toLowerCase()));
+            // Apply pattern filter if provided
+            if (input.pattern) {
+                matchedTags = SmartTagManager.filterTags(matchedTags, input.pattern);
             }
-            if (!params.query && !params.pattern) {
-                throw new Error('Query ou pattern deve ser fornecido');
+            // Sort results
+            let sortedTags;
+            switch (input.sort) {
+                case 'date':
+                    sortedTags = SmartTagManager.sortTags(matchedTags, 'date');
+                    break;
+                case 'name':
+                    sortedTags = SmartTagManager.sortTags(matchedTags, 'name');
+                    break;
+                case 'relevance':
+                default:
+                    // For relevance, keep current order (already filtered by query)
+                    sortedTags = matchedTags;
+                    break;
             }
-            // Implementar busca de tags
-            // Por enquanto, retorna mensagem de funcionalidade
-            return {
+            const limitedTags = sortedTags.slice(0, input.limit);
+            return (0, auto_detection_js_1.createUniversalResponse)({
                 success: true,
                 action: 'search',
-                message: `Busca por tags solicitada`,
+                message: `Found ${limitedTags.length} tags matching '${input.query}'`,
                 data: {
-                    query: params.query || 'não fornecido',
-                    pattern: params.pattern || 'não fornecido',
-                    results: 'Funcionalidade de busca será implementada'
+                    query: input.query,
+                    results: limitedTags,
+                    total: allTags.length,
+                    matched: matchedTags.length,
+                    pattern: input.pattern,
+                    sort: input.sort,
+                    limit: input.limit
+                },
+                autoDetected: {
+                    repo: detection.repoName,
+                    owner: detection.owner,
+                    providers: detection.providers
                 }
-            };
+            });
+        }
+        catch (error) {
+            return this.errorHandler.toUniversalResponse();
+        }
+    }
+}
+/**
+ * Tool principal git-tags
+ */
+exports.gitTagsTool = {
+    name: 'git-tags',
+    description: `🏷️ GERENCIAMENTO DE TAGS UNIFICADO
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+🎯 TAGS INTELIGENTES:
+• create: Criação com auto-detecção de tipo
+• list: Listagem com filtros e ordenação
+• get: Detalhes completos de tags
+• delete: Remoção local e remota
+• search: Busca avançada por nome/mensagem
+
+🔍 VERSIONAMENTO SEMÂNTICO:
+• Detecção automática de tags semânticas
+• Suporte a versionamento (major.minor.patch)
+• Validação de nomes de tags
+• Ordenação por versão
+
+⚡ OPERAÇÕES MULTI-PROVIDER:
+• Push automático para todos os providers
+• Delete remoto opcional
+• Sincronização automática
+• Validação de consistência
+
+🤖 COMPATÍVEL COM AI AGENTS:
+• Interface universal para qualquer IDE
+• Auto-detecção completa de contexto
+• Respostas estruturadas consistentes
+• Error handling inteligente
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`,
+    inputSchema: {
+        type: 'object',
+        properties: {
+            action: {
+                type: 'string',
+                enum: ['create', 'list', 'get', 'delete', 'search'],
+                description: 'Ação do sistema de tags'
+            },
+            projectPath: {
+                type: 'string',
+                description: 'Caminho absoluto do projeto'
+            },
+            name: {
+                type: 'string',
+                description: 'Nome da tag'
+            },
+            message: {
+                type: 'string',
+                description: 'Mensagem da tag (para annotated)'
+            },
+            target: {
+                type: 'string',
+                description: 'Target da tag (commit/branch)'
+            },
+            type: {
+                type: 'string',
+                enum: ['lightweight', 'annotated'],
+                description: 'Tipo da tag'
+            },
+            force: {
+                type: 'boolean',
+                description: 'Forçar operação'
+            },
+            pattern: {
+                type: 'string',
+                description: 'Padrão para filtrar tags'
+            },
+            sort: {
+                type: 'string',
+                enum: ['version', 'date', 'name', 'relevance'],
+                description: 'Critério de ordenação'
+            },
+            limit: {
+                type: 'number',
+                description: 'Limite de resultados'
+            },
+            detailed: {
+                type: 'boolean',
+                description: 'Informações detalhadas'
+            },
+            remote: {
+                type: 'boolean',
+                description: 'Operação também no remote'
+            },
+            query: {
+                type: 'string',
+                description: 'Termo de busca'
+            }
+        },
+        required: ['action', 'projectPath']
+    },
+    async handler(input) {
+        const executor = new GitTagsExecutor();
+        try {
+            // Validate input
+            const validatedInput = GitTagsInputSchema.parse(input);
+            // Auto-detect context
+            const detection = await (0, auto_detection_js_1.autoDetect)(validatedInput.projectPath);
+            await (0, auto_detection_js_1.validateAutoDetection)(detection);
+            // Execute specific action
+            switch (validatedInput.action) {
+                case 'create':
+                    return await executor['executeCreate'](detection, validatedInput);
+                case 'list':
+                    return await executor['executeList'](detection, validatedInput);
+                case 'get':
+                    return await executor['executeGet'](detection, validatedInput);
+                case 'delete':
+                    return await executor['executeDelete'](detection, validatedInput);
+                case 'search':
+                    return await executor['executeSearch'](detection, validatedInput);
+                default:
+                    throw new Error(`Ação '${validatedInput.action}' não suportada`);
+            }
         }
         catch (error) {
-            throw new Error(`Falha ao buscar tags: ${error instanceof Error ? error.message : String(error)}`);
+            executor.errorHandler.addError(error);
+            return executor.errorHandler.toUniversalResponse();
         }
     }
 };