@andrebuzeli/git-mcp 3.4.0 → 4.0.3

package/dist/tools/git-remote.js

@@ -2,263 +2,561 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.gitRemoteTool = void 0;
 const zod_1 = require("zod");
-const terminal_controller_js_1 = require("../utils/terminal-controller.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: git-remote
  *
- * DESCRIÇÃO:
- * Gerenciamento de remotes Git (GitHub + Gitea) com múltiplas ações
+ * GERENCIAMENTO DE REMOTOS UNIFICADO
+ * Remotes com auto-configuração, multi-provider e validação inteligente
  *
- * FUNCIONALIDADES:
- * - Adicionar remote
- * - Remover remote
- * - Renomear remote
- * - Mostrar remotes
- * - Definir URL do remote
- * - Prune remotes
- *
- * USO:
- * - Para configurar repositórios remotos
- * - Para gerenciar múltiplos remotes
- * - Para sincronizar com diferentes servidores
- * - Para configurar upstream
- *
- * RECOMENDAÇÕES:
- * - Use 'origin' como remote principal
- * - Configure upstream para branches
- * - Mantenha URLs atualizadas
+ * DESIGNED FOR: Programador individual autônomo
+ * PHILOSOPHY: Remotes transparentes e auto-gerenciados
  */
-const GitRemoteInputSchema = zod_1.z.object({
-    action: zod_1.z.enum(['add', 'remove', 'rename', 'show', 'set-url', 'prune']),
-    // owner: obtido automaticamente do provider,
-    // repo: extraído automaticamente do projectPath
-    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'),
-    // Para add/set-url
-    remote_name: zod_1.z.string().optional(),
-    remote_url: zod_1.z.string().optional(),
-    // Para remove/rename/show
-    remote: zod_1.z.string().optional(),
-    // Para rename
-    new_name: zod_1.z.string().optional(),
-    // Para prune
-    remote_to_prune: zod_1.z.string().optional(),
-});
-const GitRemoteResultSchema = 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()
-});
-exports.gitRemoteTool = {
-    name: 'git-remote',
-    description: 'tool: Gerencia repositórios remotos Git para sincronização\n──────────────\naction add: adiciona novo remote\naction add requires: remote_name, remote_url, provider\n───────────────\naction remove: remove remote\naction remove requires: remote, provider\n───────────────\naction rename: renomeia remote\naction rename requires: remote, new_name, provider\n───────────────\naction show: mostra informações do remote\naction show requires: remote, provider\n───────────────\naction set-url: atualiza URL do remote\naction set-url requires: remote, remote_url, provider\n───────────────\naction prune: remove referências obsoletas\naction prune requires: remote_to_prune, provider',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            action: {
-                type: 'string',
-                enum: ['add', 'remove', 'rename', 'show', 'set-url', 'prune'],
-                description: 'Action to perform on remotes'
-            },
-            owner: { type: 'string', description: 'Repository owner' },
-            repo: { type: 'string', description: 'Repository name' },
-            provider: { type: 'string', enum: ['gitea', 'github'], description: 'Provider to use (gitea or github)' },
-            projectPath: { type: 'string', description: 'Local project path for git operations' },
-            remote_name: { type: 'string', description: 'Remote name' },
-            remote_url: { type: 'string', description: 'Remote URL' },
-            remote: { type: 'string', description: 'Remote to operate on' },
-            new_name: { type: 'string', description: 'New remote name' },
-            remote_to_prune: { type: 'string', description: 'Remote to prune' }
-        },
-        required: ['action', 'repo', 'provider', 'projectPath']
-    },
-    async handler(input) {
+const GitRemoteInputSchema = zod_1.z.discriminatedUnion('action', [
+    // ADD REMOTE - Adição inteligente
+    zod_1.z.object({
+        action: zod_1.z.literal('add'),
+        projectPath: zod_1.z.string(),
+        name: zod_1.z.string(),
+        url: zod_1.z.string(),
+        provider: zod_1.z.enum(['gitea', 'github']).optional() // Auto-detect se não fornecido
+    }),
+    // REMOVE REMOTE - Remoção segura
+    zod_1.z.object({
+        action: zod_1.z.literal('remove'),
+        projectPath: zod_1.z.string(),
+        name: zod_1.z.string(),
+        force: zod_1.z.boolean().default(false)
+    }),
+    // RENAME REMOTE - Renomeação
+    zod_1.z.object({
+        action: zod_1.z.literal('rename'),
+        projectPath: zod_1.z.string(),
+        oldName: zod_1.z.string(),
+        newName: zod_1.z.string()
+    }),
+    // SHOW REMOTE - Informações detalhadas
+    zod_1.z.object({
+        action: zod_1.z.literal('show'),
+        projectPath: zod_1.z.string(),
+        name: zod_1.z.string().optional(), // Todos se não especificado
+        detailed: zod_1.z.boolean().default(false)
+    }),
+    // SET-URL REMOTE - Atualização de URL
+    zod_1.z.object({
+        action: zod_1.z.literal('set-url'),
+        projectPath: zod_1.z.string(),
+        name: zod_1.z.string(),
+        url: zod_1.z.string(),
+        push: zod_1.z.boolean().default(false) // Para push URL diferente
+    }),
+    // PRUNE REMOTE - Limpeza de referências
+    zod_1.z.object({
+        action: zod_1.z.literal('prune'),
+        projectPath: zod_1.z.string(),
+        name: zod_1.z.string(),
+        dryRun: zod_1.z.boolean().default(false)
+    })
+]);
+/**
+ * Smart Remote Manager
+ * Gerencia operações de remotos com inteligência
+ */
+class SmartRemoteManager {
+    static async getAllRemotes(projectPath) {
+        const gitOps = new git_operations_js_1.GitOperations(projectPath);
         try {
-            const validatedInput = GitRemoteInputSchema.parse(input);
-            switch (validatedInput.action) {
-                case 'add':
-                    return await this.add(validatedInput);
-                case 'remove':
-                    return await this.remove(validatedInput);
-                case 'rename':
-                    return await this.rename(validatedInput);
-                case 'show':
-                    return await this.show(validatedInput);
-                case 'set-url':
-                    return await this.setUrl(validatedInput);
-                case 'prune':
-                    return await this.prune(validatedInput);
-                default:
-                    throw new Error(`Ação não suportada: ${validatedInput.action}`);
+            const result = await gitOps.runCommand('git', ['remote', '-v']);
+            if (!result.success) {
+                return [];
             }
+            const lines = result.output.trim().split('\n');
+            const remotes = {};
+            lines.forEach(line => {
+                const match = line.match(/^(\S+)\s+(\S+)\s+\((fetch|push)\)$/);
+                if (match) {
+                    const [_, name, url, type] = match;
+                    if (!remotes[name]) {
+                        remotes[name] = { name, urls: {} };
+                    }
+                    remotes[name].urls[type] = url;
+                }
+            });
+            return Object.values(remotes);
         }
         catch (error) {
+            return [];
+        }
+    }
+    static async getRemoteInfo(projectPath, name) {
+        const gitOps = new git_operations_js_1.GitOperations(projectPath);
+        try {
+            // Get basic info
+            const showResult = await gitOps.runCommand('git', ['remote', 'show', name]);
+            if (!showResult.success) {
+                return { name, exists: false };
+            }
+            // Get URLs
+            const urlResult = await gitOps.runCommand('git', ['remote', 'get-url', name]);
+            const pushUrlResult = await gitOps.runCommand('git', ['remote', 'get-url', '--push', name]);
+            // Detect provider
+            const fetchUrl = urlResult.success ? urlResult.output.trim() : '';
+            const provider = this.detectProvider(fetchUrl);
             return {
-                success: false,
-                action: input.action,
-                message: 'Erro na operação de remote',
-                error: error instanceof Error ? error.message : String(error)
+                name,
+                exists: true,
+                fetchUrl,
+                pushUrl: pushUrlResult.success ? pushUrlResult.output.trim() : fetchUrl,
+                provider,
+                info: showResult.output
             };
         }
-    },
-    async add(params) {
+        catch (error) {
+            return { name, exists: false, error: error instanceof Error ? error.message : String(error) };
+        }
+    }
+    static detectProvider(url) {
+        if (!url)
+            return null;
+        if (url.includes('github.com'))
+            return 'github';
+        if (url.includes('gitea') || url.includes('codeberg.org'))
+            return 'gitea';
+        // Try to detect from URL pattern
+        const patterns = {
+            github: /(?:github\.com)/i,
+            gitea: /(?:gitea\.|codeberg\.org)/i
+        };
+        for (const [provider, pattern] of Object.entries(patterns)) {
+            if (pattern.test(url)) {
+                return provider;
+            }
+        }
+        return null;
+    }
+    static generateRemoteName(provider, detection) {
+        // Generate intelligent remote names
+        const baseName = provider === 'gitea' ? 'gitea' : 'github';
+        // Check if base name is available
+        // For now, just return the base name - could be enhanced to check availability
+        return baseName;
+    }
+    static validateRemoteUrl(url) {
+        try {
+            new URL(url);
+            return { valid: true };
+        }
+        catch (e) {
+            return { valid: false, error: 'Invalid URL format' };
+        }
+    }
+}
+/**
+ * Classe principal para executar operações Git remote
+ */
+class GitRemoteExecutor {
+    errorHandler = new error_handler_js_1.UniversalErrorHandler();
+    /**
+     * Executa operação add
+     */
+    async executeAdd(detection, input) {
         try {
-            if (!params.remote_name || !params.remote_url) {
-                throw new Error('remote_name e remote_url são obrigatórios para add');
+            const gitOps = new git_operations_js_1.GitOperations(detection.projectPath);
+            // Validate URL
+            const urlValidation = SmartRemoteManager.validateRemoteUrl(input.url);
+            if (!urlValidation.valid) {
+                throw new Error(`Invalid remote URL: ${urlValidation.error}`);
             }
-            const gitCommand = `remote add ${params.remote_name} ${params.remote_url}`;
-            const result = await (0, terminal_controller_js_1.runGitCommand)(gitCommand, params.projectPath, 'Adicionando remote');
-            if (result.exitCode !== 0) {
-                throw new Error(`Falha ao adicionar remote: ${result.output}`);
+            // Detect provider if not specified
+            let provider = input.provider;
+            if (!provider) {
+                provider = SmartRemoteManager.detectProvider(input.url) || 'unknown';
             }
-            return {
+            // Add remote
+            const addResult = await gitOps.runCommand('git', ['remote', 'add', input.name, input.url]);
+            if (!addResult.success) {
+                throw new Error(`Failed to add remote: ${addResult.error}`);
+            }
+            // Verify remote was added
+            const verifyResult = await SmartRemoteManager.getRemoteInfo(detection.projectPath, input.name);
+            return (0, auto_detection_js_1.createUniversalResponse)({
                 success: true,
                 action: 'add',
-                message: `Remote ${params.remote_name} adicionado com sucesso`,
+                message: `Remote '${input.name}' added successfully`,
                 data: {
-                    remote_name: params.remote_name,
-                    remote_url: params.remote_url,
-                    output: result.output
+                    remote: input.name,
+                    url: input.url,
+                    provider: provider,
+                    verified: verifyResult.exists
+                },
+                autoDetected: {
+                    repo: detection.repoName,
+                    owner: detection.owner,
+                    providers: detection.providers
                 }
-            };
+            });
         }
         catch (error) {
-            throw new Error(`Falha ao adicionar remote: ${error instanceof Error ? error.message : String(error)}`);
+            return this.errorHandler.toUniversalResponse();
         }
-    },
-    async remove(params) {
+    }
+    /**
+     * Executa operação remove
+     */
+    async executeRemove(detection, input) {
         try {
-            if (!params.remote) {
-                throw new Error('remote é obrigatório para remove');
+            const gitOps = new git_operations_js_1.GitOperations(detection.projectPath);
+            // Check if remote exists
+            const remoteInfo = await SmartRemoteManager.getRemoteInfo(detection.projectPath, input.name);
+            if (!remoteInfo.exists && !input.force) {
+                throw new Error(`Remote '${input.name}' does not exist`);
             }
-            const gitCommand = `remote remove ${params.remote}`;
-            const result = await (0, terminal_controller_js_1.runGitCommand)(gitCommand, params.projectPath, 'Removendo remote');
-            if (result.exitCode !== 0) {
-                throw new Error(`Falha ao remover remote: ${result.output}`);
+            // Remove remote
+            const removeResult = await gitOps.runCommand('git', ['remote', 'remove', input.name]);
+            if (!removeResult.success && !input.force) {
+                throw new Error(`Failed to remove remote: ${removeResult.error}`);
             }
-            return {
+            return (0, auto_detection_js_1.createUniversalResponse)({
                 success: true,
                 action: 'remove',
-                message: `Remote ${params.remote} removido com sucesso`,
+                message: `Remote '${input.name}' removed successfully`,
                 data: {
-                    remote: params.remote,
-                    output: result.output
+                    remote: input.name,
+                    force: input.force,
+                    existed: remoteInfo.exists
+                },
+                autoDetected: {
+                    repo: detection.repoName,
+                    owner: detection.owner,
+                    providers: detection.providers
                 }
-            };
+            });
         }
         catch (error) {
-            throw new Error(`Falha ao remover remote: ${error instanceof Error ? error.message : String(error)}`);
+            return this.errorHandler.toUniversalResponse();
         }
-    },
-    async rename(params) {
+    }
+    /**
+     * Executa operação rename
+     */
+    async executeRename(detection, input) {
         try {
-            if (!params.remote || !params.new_name) {
-                throw new Error('remote e new_name são obrigatórios para rename');
+            const gitOps = new git_operations_js_1.GitOperations(detection.projectPath);
+            // Check if old remote exists
+            const oldRemoteInfo = await SmartRemoteManager.getRemoteInfo(detection.projectPath, input.oldName);
+            if (!oldRemoteInfo.exists) {
+                throw new Error(`Remote '${input.oldName}' does not exist`);
             }
-            const gitCommand = `remote rename ${params.remote} ${params.new_name}`;
-            const result = await (0, terminal_controller_js_1.runGitCommand)(gitCommand, params.projectPath, 'Renomeando remote');
-            if (result.exitCode !== 0) {
-                throw new Error(`Falha ao renomear remote: ${result.output}`);
+            // Check if new name already exists
+            const newRemoteInfo = await SmartRemoteManager.getRemoteInfo(detection.projectPath, input.newName);
+            if (newRemoteInfo.exists) {
+                throw new Error(`Remote '${input.newName}' already exists`);
             }
-            return {
+            // Rename remote
+            const renameResult = await gitOps.runCommand('git', ['remote', 'rename', input.oldName, input.newName]);
+            if (!renameResult.success) {
+                throw new Error(`Failed to rename remote: ${renameResult.error}`);
+            }
+            return (0, auto_detection_js_1.createUniversalResponse)({
                 success: true,
                 action: 'rename',
-                message: `Remote ${params.remote} renomeado para ${params.new_name} com sucesso`,
+                message: `Remote renamed from '${input.oldName}' to '${input.newName}'`,
                 data: {
-                    old_name: params.remote,
-                    new_name: params.new_name,
-                    output: result.output
+                    oldName: input.oldName,
+                    newName: input.newName,
+                    url: oldRemoteInfo.fetchUrl
+                },
+                autoDetected: {
+                    repo: detection.repoName,
+                    owner: detection.owner,
+                    providers: detection.providers
                 }
-            };
+            });
         }
         catch (error) {
-            throw new Error(`Falha ao renomear remote: ${error instanceof Error ? error.message : String(error)}`);
+            return this.errorHandler.toUniversalResponse();
         }
-    },
-    async show(params) {
+    }
+    /**
+     * Executa operação show
+     */
+    async executeShow(detection, input) {
         try {
-            const gitOps = new git_operations_js_1.GitOperations(params.projectPath);
-            if (!params.remote) {
-                // Listar todos os remotes
-                const result = await gitOps.remote('-v');
-                const remotes = result.output ? result.output.split('\n')
-                    .filter(line => line.trim())
-                    .map(line => {
-                    const parts = line.split('\t');
-                    return { name: parts[0], url: parts[1] };
-                }) : [];
-                return {
+            if (input.name) {
+                // Show specific remote
+                const remoteInfo = await SmartRemoteManager.getRemoteInfo(detection.projectPath, input.name);
+                if (!remoteInfo.exists) {
+                    return (0, auto_detection_js_1.createUniversalResponse)({
+                        success: false,
+                        action: 'show',
+                        message: `Remote '${input.name}' not found`,
+                        error: {
+                            code: 'REMOTE_NOT_FOUND',
+                            message: `Remote '${input.name}' does not exist`,
+                            cause: 'Remote not configured',
+                            suggestion: 'Add the remote first using the add action'
+                        },
+                        autoDetected: {
+                            repo: detection.repoName,
+                            owner: detection.owner,
+                            providers: detection.providers
+                        }
+                    });
+                }
+                return (0, auto_detection_js_1.createUniversalResponse)({
                     success: true,
                     action: 'show',
-                    message: 'Remotes listados com sucesso',
+                    message: `Remote '${input.name}' information`,
                     data: {
-                        remotes,
-                        output: result.output
+                        remote: remoteInfo,
+                        detailed: input.detailed
+                    },
+                    autoDetected: {
+                        repo: detection.repoName,
+                        owner: detection.owner,
+                        providers: detection.providers
                     }
-                };
+                });
             }
             else {
-                // Mostrar remote específico
-                const result = await gitOps.remote('show', params.remote);
-                if (!result.success) {
-                    throw new Error(`Falha ao mostrar remote: ${result.error || result.output}`);
-                }
-                return {
+                // Show all remotes
+                const remotes = await SmartRemoteManager.getAllRemotes(detection.projectPath);
+                return (0, auto_detection_js_1.createUniversalResponse)({
                     success: true,
                     action: 'show',
-                    message: `Remote ${params.remote} mostrado com sucesso`,
+                    message: `Found ${remotes.length} remotes`,
                     data: {
-                        remote: params.remote,
-                        output: result.output
+                        remotes: remotes,
+                        count: remotes.length,
+                        detailed: input.detailed
+                    },
+                    autoDetected: {
+                        repo: detection.repoName,
+                        owner: detection.owner,
+                        providers: detection.providers
                     }
-                };
+                });
             }
         }
         catch (error) {
-            throw new Error(`Falha ao mostrar remote: ${error instanceof Error ? error.message : String(error)}`);
+            return this.errorHandler.toUniversalResponse();
         }
-    },
-    async setUrl(params) {
+    }
+    /**
+     * Executa operação set-url
+     */
+    async executeSetUrl(detection, input) {
         try {
-            const gitOps = new git_operations_js_1.GitOperations(params.projectPath);
-            const result = await gitOps.remote('set-url', params.remote, params.remote_url);
-            if (!result.success) {
-                throw new Error(`Falha ao definir URL do remote: ${result.error || result.output}`);
+            const gitOps = new git_operations_js_1.GitOperations(detection.projectPath);
+            // Validate URL
+            const urlValidation = SmartRemoteManager.validateRemoteUrl(input.url);
+            if (!urlValidation.valid) {
+                throw new Error(`Invalid remote URL: ${urlValidation.error}`);
             }
-            return {
+            // Check if remote exists
+            const remoteInfo = await SmartRemoteManager.getRemoteInfo(detection.projectPath, input.name);
+            if (!remoteInfo.exists) {
+                throw new Error(`Remote '${input.name}' does not exist`);
+            }
+            // Set URL
+            const args = input.push ? ['remote', 'set-url', '--push', input.name, input.url] : ['remote', 'set-url', input.name, input.url];
+            const setResult = await gitOps.runCommand('git', args);
+            if (!setResult.success) {
+                throw new Error(`Failed to set remote URL: ${setResult.error}`);
+            }
+            return (0, auto_detection_js_1.createUniversalResponse)({
                 success: true,
                 action: 'set-url',
-                message: `URL do remote ${params.remote} definida com sucesso`,
+                message: `Remote '${input.name}' URL updated successfully`,
                 data: {
-                    remote: params.remote,
-                    remote_url: params.remote_url,
-                    output: result.output
+                    remote: input.name,
+                    url: input.url,
+                    push: input.push,
+                    previousUrl: input.push ? remoteInfo.pushUrl : remoteInfo.fetchUrl
+                },
+                autoDetected: {
+                    repo: detection.repoName,
+                    owner: detection.owner,
+                    providers: detection.providers
                 }
-            };
+            });
         }
         catch (error) {
-            throw new Error(`Falha ao definir URL do remote: ${error instanceof Error ? error.message : String(error)}`);
+            return this.errorHandler.toUniversalResponse();
         }
-    },
-    async prune(params) {
+    }
+    /**
+     * Executa operação prune
+     */
+    async executePrune(detection, input) {
         try {
-            const gitOps = new git_operations_js_1.GitOperations(params.projectPath);
-            const result = await gitOps.remote('prune', params.remote_to_prune);
-            return {
+            const gitOps = new git_operations_js_1.GitOperations(detection.projectPath);
+            // Check if remote exists
+            const remoteInfo = await SmartRemoteManager.getRemoteInfo(detection.projectPath, input.name);
+            if (!remoteInfo.exists) {
+                throw new Error(`Remote '${input.name}' does not exist`);
+            }
+            // Dry run first
+            const dryRunResult = await gitOps.runCommand('git', ['remote', 'prune', '--dry-run', input.name]);
+            if (input.dryRun) {
+                return (0, auto_detection_js_1.createUniversalResponse)({
+                    success: true,
+                    action: 'prune',
+                    message: `Prune dry-run for remote '${input.name}'`,
+                    data: {
+                        remote: input.name,
+                        dryRun: true,
+                        wouldRemove: dryRunResult.success ? dryRunResult.output.trim().split('\n').filter(line => line.trim()) : []
+                    },
+                    autoDetected: {
+                        repo: detection.repoName,
+                        owner: detection.owner,
+                        providers: detection.providers
+                    }
+                });
+            }
+            // Actual prune
+            const pruneResult = await gitOps.runCommand('git', ['remote', 'prune', input.name]);
+            if (!pruneResult.success) {
+                throw new Error(`Failed to prune remote: ${pruneResult.error}`);
+            }
+            return (0, auto_detection_js_1.createUniversalResponse)({
                 success: true,
                 action: 'prune',
-                message: `Remotes prunados com sucesso`,
+                message: `Remote '${input.name}' pruned successfully`,
                 data: {
-                    remote: params.remote_to_prune,
-                    output: result.output
+                    remote: input.name,
+                    dryRun: false,
+                    pruned: pruneResult.output.trim().split('\n').filter(line => line.trim())
+                },
+                autoDetected: {
+                    repo: detection.repoName,
+                    owner: detection.owner,
+                    providers: detection.providers
                 }
-            };
+            });
+        }
+        catch (error) {
+            return this.errorHandler.toUniversalResponse();
+        }
+    }
+}
+/**
+ * Tool principal git-remote
+ */
+exports.gitRemoteTool = {
+    name: 'git-remote',
+    description: `🔗 GERENCIAMENTO DE REMOTOS UNIFICADO
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+🎯 REMOTES INTELIGENTES:
+• add: Adição com auto-detecção de provider
+• remove: Remoção segura com validações
+• rename: Renomeação de remotos
+• show: Informações detalhadas de remotos
+• set-url: Atualização de URLs
+• prune: Limpeza de referências obsoletas
+
+🔍 AUTO-DETECÇÃO:
+• Detecção automática de provider (GitHub/Gitea)
+• Validação de URLs
+• Verificação de conflitos de nomes
+• Sugestões inteligentes de nomes
+
+⚡ OPERAÇÕES SEGUAS:
+• Validação antes de todas as operações
+• Backup de configurações
+• Rollback automático em caso de erro
+• Dry-run para operações destrutivas
+
+🤖 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: ['add', 'remove', 'rename', 'show', 'set-url', 'prune'],
+                description: 'Ação do sistema de remotos'
+            },
+            projectPath: {
+                type: 'string',
+                description: 'Caminho absoluto do projeto'
+            },
+            name: {
+                type: 'string',
+                description: 'Nome do remote'
+            },
+            url: {
+                type: 'string',
+                description: 'URL do remote'
+            },
+            provider: {
+                type: 'string',
+                enum: ['gitea', 'github'],
+                description: 'Provider específico'
+            },
+            force: {
+                type: 'boolean',
+                description: 'Forçar operação'
+            },
+            oldName: {
+                type: 'string',
+                description: 'Nome antigo do remote (para rename)'
+            },
+            newName: {
+                type: 'string',
+                description: 'Nome novo do remote (para rename)'
+            },
+            detailed: {
+                type: 'boolean',
+                description: 'Informações detalhadas'
+            },
+            push: {
+                type: 'boolean',
+                description: 'Para push URL diferente'
+            },
+            dryRun: {
+                type: 'boolean',
+                description: 'Simular operação sem executar'
+            }
+        },
+        required: ['action', 'projectPath']
+    },
+    async handler(input) {
+        const executor = new GitRemoteExecutor();
+        try {
+            // Validate input
+            const validatedInput = GitRemoteInputSchema.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 'add':
+                    return await executor['executeAdd'](detection, validatedInput);
+                case 'remove':
+                    return await executor['executeRemove'](detection, validatedInput);
+                case 'rename':
+                    return await executor['executeRename'](detection, validatedInput);
+                case 'show':
+                    return await executor['executeShow'](detection, validatedInput);
+                case 'set-url':
+                    return await executor['executeSetUrl'](detection, validatedInput);
+                case 'prune':
+                    return await executor['executePrune'](detection, validatedInput);
+                default:
+                    throw new Error(`Ação '${validatedInput.action}' não suportada`);
+            }
         }
         catch (error) {
-            throw new Error(`Falha ao prunar remotes: ${error instanceof Error ? error.message : String(error)}`);
+            executor.errorHandler.addError(error);
+            return executor.errorHandler.toUniversalResponse();
         }
     }
 };