@andrebuzeli/git-mcp 5.0.4 → 5.0.6

package/dist/tools/git-workflow.js

@@ -1,985 +1,480 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.gitWorkflowTool = void 0;
-const auto_detection_js_1 = require("../utils/auto-detection.js");
-const configuration_validator_js_1 = require("../utils/configuration-validator.js");
-const provider_operation_handler_js_1 = require("../utils/provider-operation-handler.js");
-const operation_error_handler_js_1 = require("../utils/operation-error-handler.js");
-const terminal_controller_js_1 = require("../utils/terminal-controller.js");
 /**
- * Git Workflow Tool - Ferramenta Principal
+ * Git Workflow Tool
  *
- * Implementa o workflow completo de Git com operações integradas:
- * - init: Inicializar projeto completo
- * - commit: Commit + push automático
- * - sync: Pull + commit + push completo
- * - status: Status detalhado do projeto
- * - backup: Backup completo do projeto
+ * Core Git workflow tool providing comprehensive Git operations.
+ * Supports both local Git operations and remote provider operations.
+ *
+ * Local operations: init, status, commit, sync, backup
+ * Remote operations: create, list, get, update, delete, fork, search
  */
-const inputSchema = {
-    type: 'object',
-    properties: {
-        action: {
-            type: 'string',
-            enum: ['init', 'commit', 'sync', 'status', 'backup', 'create', 'list', 'get', 'update', 'delete', 'fork', 'search'],
-            description: 'Ação do workflow a executar'
-        },
-        projectPath: {
-            type: 'string',
-            description: 'Caminho do projeto (obrigatório)'
-        },
-        provider: {
-            type: 'string',
-            enum: ['github', 'gitea', 'both'],
-            description: 'Provider para operações remotas (obrigatório para create, list, get, update, delete, fork, search)'
-        },
-        message: {
-            type: 'string',
-            description: 'Mensagem de commit (para commit/sync)'
-        },
-        branch: {
-            type: 'string',
-            description: 'Branch para operações (padrão: main)'
-        },
-        remote: {
-            type: 'string',
-            description: 'Remote para operações (padrão: origin)'
-        },
-        // Parâmetros para gerenciamento de repositórios
-        repoName: {
-            type: 'string',
-            description: 'Nome do repositório (para create/get/update/delete/fork)'
-        },
-        description: {
-            type: 'string',
-            description: 'Descrição do repositório (para create/update)'
-        },
-        private: {
-            type: 'boolean',
-            description: 'Repositório privado (para create/update)'
-        },
-        sourceRepo: {
-            type: 'string',
-            description: 'Repositório de origem (para fork)'
-        },
-        searchQuery: {
-            type: 'string',
-            description: 'Termo de busca (para search)'
-        },
-        language: {
-            type: 'string',
-            description: 'Filtrar por linguagem (para search)'
-        },
-        sort: {
-            type: 'string',
-            description: 'Ordenar por: stars, updated, created (padrão: stars)'
-        },
-        order: {
-            type: 'string',
-            description: 'Ordem: asc, desc (padrão: desc)'
-        },
-        page: {
-            type: 'number',
-            description: 'Página para paginação (padrão: 1)'
-        },
-        perPage: {
-            type: 'number',
-            description: 'Itens por página (padrão: 30)'
-        }
-    },
-    required: ['action', 'projectPath'],
-    // Provider é obrigatório para operações remotas
-    if: {
-        properties: {
-            action: {
-                enum: ['create', 'list', 'get', 'update', 'delete', 'fork', 'search']
-            }
-        }
-    },
-    then: {
-        required: ['action', 'projectPath', 'provider']
-    }
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-async function handleInit(projectPath, detection) {
-    try {
-        const isRepo = await (0, terminal_controller_js_1.isGitRepository)(projectPath);
-        if (isRepo) {
-            return {
-                success: true,
-                action: 'init',
-                message: 'Projeto já é um repositório Git',
-                data: {
-                    alreadyInitialized: true,
-                    projectPath,
-                    repoName: detection.repoName
-                }
-            };
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitWorkflowTool = 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");
+const path_1 = __importDefault(require("path"));
+class GitWorkflowTool {
+    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);
         }
-        // Inicializar repositório Git
-        const { execSync } = require('child_process');
-        execSync('git init', { cwd: projectPath });
-        execSync('git add .', { cwd: projectPath });
-        execSync('git commit -m "Initial commit"', { cwd: projectPath });
-        return {
-            success: true,
-            action: 'init',
-            message: 'Projeto inicializado com sucesso',
-            data: {
-                initialized: true,
-                projectPath,
-                repoName: detection.repoName,
-                initialCommit: true
-            }
-        };
     }
-    catch (error) {
-        throw new Error(`Falha ao inicializar projeto: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-async function handleCommit(projectPath, message, branch = 'main', remote = 'origin') {
-    try {
-        const isRepo = await (0, terminal_controller_js_1.isGitRepository)(projectPath);
-        if (!isRepo) {
-            throw new Error('Diretório não é um repositório Git');
-        }
-        // Status antes do commit
-        const statusResult = await (0, terminal_controller_js_1.getGitStatus)(projectPath);
-        // Add all changes
-        const addResult = await (0, terminal_controller_js_1.gitAdd)(projectPath, '.');
-        if (addResult.exitCode !== 0) {
-            throw new Error(`Falha ao adicionar arquivos: ${addResult.error}`);
-        }
-        // Commit
-        const commitResult = await (0, terminal_controller_js_1.gitCommit)(projectPath, message);
-        if (commitResult.exitCode !== 0) {
-            throw new Error(`Falha ao fazer commit: ${commitResult.error}`);
-        }
-        // Push
-        const pushResult = await (0, terminal_controller_js_1.gitPush)(projectPath, branch, remote);
-        return {
-            success: true,
-            action: 'commit',
-            message: 'Commit realizado com sucesso',
-            data: {
-                committed: true,
-                message,
-                branch,
-                remote,
-                pushed: pushResult.exitCode === 0,
-                statusBefore: statusResult.output,
-                commitOutput: commitResult.output,
-                pushOutput: pushResult.output
+    /**
+     * Execute git-workflow operation
+     */
+    async execute(params) {
+        const startTime = Date.now();
+        try {
+            // Validate basic parameters
+            const validation = parameter_validator_js_1.ParameterValidator.validateToolParams('git-workflow', 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);
             }
-        };
-    }
-    catch (error) {
-        throw new Error(`Falha no commit: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-async function handleSync(projectPath, message, branch = 'main', remote = 'origin') {
-    try {
-        const isRepo = await (0, terminal_controller_js_1.isGitRepository)(projectPath);
-        if (!isRepo) {
-            throw new Error('Diretório não é um repositório Git');
-        }
-        // Pull primeiro
-        const pullResult = await (0, terminal_controller_js_1.gitPull)(projectPath, branch, remote);
-        // Status após pull
-        const statusResult = await (0, terminal_controller_js_1.getGitStatus)(projectPath);
-        // Se há mudanças, fazer commit
-        if (statusResult.output.includes('Changes') || statusResult.output.includes('modified')) {
-            // Add all changes
-            const addResult = await (0, terminal_controller_js_1.gitAdd)(projectPath, '.');
-            if (addResult.exitCode !== 0) {
-                throw new Error(`Falha ao adicionar arquivos: ${addResult.error}`);
+            // Validate operation-specific parameters
+            const operationValidation = parameter_validator_js_1.ParameterValidator.validateOperationParams('git-workflow', 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);
             }
-            // Commit
-            const commitResult = await (0, terminal_controller_js_1.gitCommit)(projectPath, message);
-            if (commitResult.exitCode !== 0) {
-                throw new Error(`Falha ao fazer commit: ${commitResult.error}`);
+            // Route to appropriate handler
+            const isRemoteOperation = this.isRemoteOperation(params.action);
+            if (isRemoteOperation) {
+                return await this.executeRemoteOperation(params, startTime);
+            }
+            else {
+                return await this.executeLocalOperation(params, startTime);
             }
-            // Push
-            const pushResult = await (0, terminal_controller_js_1.gitPush)(projectPath, branch, remote);
-            return {
-                success: true,
-                action: 'sync',
-                message: 'Sincronização completa realizada',
-                data: {
-                    pulled: pullResult.exitCode === 0,
-                    committed: true,
-                    pushed: pushResult.exitCode === 0,
-                    message,
-                    branch,
-                    remote,
-                    pullOutput: pullResult.output,
-                    commitOutput: commitResult.output,
-                    pushOutput: pushResult.output
-                }
-            };
-        }
-        else {
-            return {
-                success: true,
-                action: 'sync',
-                message: 'Sincronização realizada - nenhuma mudança local',
-                data: {
-                    pulled: pullResult.exitCode === 0,
-                    committed: false,
-                    pushed: false,
-                    message: 'No local changes to commit',
-                    branch,
-                    remote,
-                    pullOutput: pullResult.output
-                }
-            };
-        }
-    }
-    catch (error) {
-        throw new Error(`Falha na sincronização: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-async function handleStatus(projectPath, detection) {
-    try {
-        const isRepo = await (0, terminal_controller_js_1.isGitRepository)(projectPath);
-        if (!isRepo) {
-            return {
-                success: true,
-                action: 'status',
-                message: 'Diretório não é um repositório Git',
-                data: {
-                    isGitRepo: false,
-                    projectPath,
-                    repoName: detection.repoName,
-                    suggestion: 'Use a ação "init" para inicializar o repositório'
-                }
-            };
-        }
-        // Status detalhado
-        const statusResult = await (0, terminal_controller_js_1.getGitStatus)(projectPath);
-        // Informações adicionais via execSync
-        const { execSync } = require('child_process');
-        let branchInfo = '';
-        let remoteInfo = '';
-        let lastCommit = '';
-        try {
-            branchInfo = execSync('git branch --show-current', { cwd: projectPath, encoding: 'utf8' }).trim();
-            remoteInfo = execSync('git remote -v', { cwd: projectPath, encoding: 'utf8' }).trim();
-            lastCommit = execSync('git log -1 --oneline', { cwd: projectPath, encoding: 'utf8' }).trim();
         }
         catch (error) {
-            // Ignorar erros de comandos git adicionais
+            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']);
         }
-        return {
-            success: true,
-            action: 'status',
-            message: 'Status do repositório obtido com sucesso',
-            data: {
-                isGitRepo: true,
-                projectPath,
-                repoName: detection.repoName,
-                owner: detection.owner,
-                providers: detection.providers,
-                currentBranch: branchInfo,
-                remotes: remoteInfo,
-                lastCommit,
-                status: statusResult.output,
-                statusClean: statusResult.exitCode === 0
-            }
-        };
     }
-    catch (error) {
-        throw new Error(`Falha ao obter status: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-async function handleBackup(projectPath, detection) {
-    try {
-        const isRepo = await (0, terminal_controller_js_1.isGitRepository)(projectPath);
-        if (!isRepo) {
-            throw new Error('Diretório não é um repositório Git');
-        }
-        // Criar backup simples via tar/zip
-        const fs = require('fs');
-        const path = require('path');
-        const { execSync } = require('child_process');
-        const backupDir = path.join(projectPath, '..', 'backups');
-        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-        const backupName = `${detection.repoName}-backup-${timestamp}`;
-        // Criar diretório de backup se não existir
-        if (!fs.existsSync(backupDir)) {
-            fs.mkdirSync(backupDir, { recursive: true });
-        }
-        // Criar backup (tar no Linux/Mac, zip no Windows)
-        const isWindows = process.platform === 'win32';
-        let backupFile = '';
-        if (isWindows) {
-            backupFile = path.join(backupDir, `${backupName}.zip`);
-            execSync(`powershell Compress-Archive -Path "${projectPath}\\*" -DestinationPath "${backupFile}"`, { cwd: backupDir });
+    /**
+     * Execute local Git operations
+     */
+    async executeLocalOperation(params, startTime) {
+        switch (params.action) {
+            case 'init':
+                return await this.handleInit(params, startTime);
+            case 'status':
+                return await this.handleStatus(params, startTime);
+            case 'commit':
+                return await this.handleCommit(params, startTime);
+            case 'sync':
+                return await this.handleSync(params, startTime);
+            case 'backup':
+                return await this.handleBackup(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: init, status, commit, sync, backup']);
         }
-        else {
-            backupFile = path.join(backupDir, `${backupName}.tar.gz`);
-            execSync(`tar -czf "${backupFile}" -C "${path.dirname(projectPath)}" "${path.basename(projectPath)}"`, { cwd: backupDir });
-        }
-        const stats = fs.statSync(backupFile);
-        return {
-            success: true,
-            action: 'backup',
-            message: 'Backup criado com sucesso',
-            data: {
-                backupCreated: true,
-                backupFile,
-                backupSize: stats.size,
-                backupSizeHuman: `${(stats.size / 1024 / 1024).toFixed(2)} MB`,
-                timestamp,
-                projectPath,
-                repoName: detection.repoName
-            }
-        };
-    }
-    catch (error) {
-        throw new Error(`Falha ao criar backup: ${error instanceof Error ? error.message : String(error)}`);
     }
-}
-// Funções para gerenciamento de repositórios remotos
-async function handleCreateRepo(repoName, description, isPrivate, detection, projectPath, provider) {
-    try {
-        // Execute both local and remote operations simultaneously
-        const results = await Promise.allSettled([
-            // Local operation: initialize Git repository
-            handleInit(projectPath, detection),
-            // Remote operation: create repository on specified provider(s)
-            provider_operation_handler_js_1.ProviderOperationHandler.executeOperation(provider, (providerInstance) => providerInstance.createRepository(repoName, description || `Repositório ${repoName}`, isPrivate || false))
-        ]);
-        const localResult = results[0];
-        const remoteResult = results[1];
-        // Format results
-        const localData = localResult.status === 'fulfilled' ? localResult.value : null;
-        const localError = localResult.status === 'rejected' ? localResult.reason.message : null;
-        const remoteData = remoteResult.status === 'fulfilled' ? remoteResult.value : null;
-        const remoteError = remoteResult.status === 'rejected' ? remoteResult.reason.message : null;
-        // Determine overall success and message
-        const localSuccess = localResult.status === 'fulfilled';
-        const remoteSuccess = remoteResult.status === 'fulfilled' && remoteData?.success;
-        let message;
-        if (localSuccess && remoteSuccess) {
-            message = `Repositório '${repoName}' criado com sucesso (local e remoto)`;
-        }
-        else if (localSuccess && !remoteSuccess) {
-            message = `Repositório '${repoName}' criado localmente, falha na criação remota`;
-        }
-        else if (!localSuccess && remoteSuccess) {
-            message = `Repositório '${repoName}' criado remotamente, falha na inicialização local`;
-        }
-        else {
-            message = `Falha ao criar repositório '${repoName}' (local e remoto)`;
-        }
-        return {
-            success: localSuccess || remoteSuccess, // Success if at least one operation succeeded
-            action: 'create',
-            message,
-            data: {
-                repoName,
-                description: description || `Repositório ${repoName}`,
-                private: isPrivate || false,
-                local: {
-                    success: localSuccess,
-                    data: localData,
-                    error: localError
-                },
-                remote: remoteData || {
-                    success: false,
-                    error: remoteError || 'Unknown remote operation error'
-                }
-            }
+    /**
+     * 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
         };
-    }
-    catch (error) {
-        throw new Error(`Falha ao criar repositório: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-async function handleListRepos(detection, page = 1, perPage = 30, sort = 'updated', provider) {
-    try {
-        // Execute operation on specified provider(s)
-        const result = await provider_operation_handler_js_1.ProviderOperationHandler.executeOperation(provider, (providerInstance) => providerInstance.listRepositories(detection.owner, page, perPage));
-        if (!result.success) {
-            const errorMessage = 'message' in result
-                ? result.message
-                : ('error' in result ? result.error || 'Failed to list repositories' : 'Unknown error');
-            throw new Error(errorMessage);
-        }
-        // Handle single provider result
-        if ('provider' in result && result.data) {
-            const repositories = result.data;
+        try {
+            const result = await this.providerHandler.executeOperation(operation);
             return {
-                success: true,
-                action: 'list',
-                message: `${repositories.length} repositórios encontrados no ${result.provider}`,
-                data: {
-                    repositories,
-                    total: repositories.length,
-                    page,
-                    perPage,
-                    sort,
-                    owner: detection.owner,
-                    provider: result.provider
+                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
                 }
             };
         }
-        // Handle multi-provider result
-        if ('message' in result && typeof result.data === 'object') {
-            const multiData = result.data;
-            const allRepositories = [];
-            const providerResults = {};
-            // Collect repositories from all successful providers
-            if (multiData.github?.success && multiData.github.data) {
-                allRepositories.push(...multiData.github.data);
-                providerResults.github = {
-                    success: true,
-                    count: multiData.github.data.length,
-                    repositories: multiData.github.data
-                };
-            }
-            else if (multiData.github) {
-                providerResults.github = {
-                    success: false,
-                    error: multiData.github.error
-                };
-            }
-            if (multiData.gitea?.success && multiData.gitea.data) {
-                allRepositories.push(...multiData.gitea.data);
-                providerResults.gitea = {
+        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 git init operation
+     */
+    async handleInit(params, startTime) {
+        try {
+            // Check if already a git repository
+            const isRepo = await this.gitExecutor.isGitRepository(params.projectPath);
+            if (isRepo) {
+                return {
                     success: true,
-                    count: multiData.gitea.data.length,
-                    repositories: multiData.gitea.data
+                    data: {
+                        message: 'Repository already initialized',
+                        path: params.projectPath,
+                        alreadyExists: true
+                    },
+                    metadata: {
+                        operation: 'init',
+                        timestamp: new Date().toISOString(),
+                        executionTime: Date.now() - startTime
+                    }
                 };
             }
-            else if (multiData.gitea) {
-                providerResults.gitea = {
-                    success: false,
-                    error: multiData.gitea.error
-                };
+            const result = await this.gitExecutor.initRepository(params.projectPath, params.bare || false);
+            if (!result.success) {
+                return operation_error_handler_js_1.OperationErrorHandler.handleGitError(result.stderr, 'init', params.projectPath);
             }
             return {
                 success: true,
-                action: 'list',
-                message: result.message,
                 data: {
-                    repositories: allRepositories,
-                    total: allRepositories.length,
-                    page,
-                    perPage,
-                    sort,
-                    owner: detection.owner,
-                    provider: 'both',
-                    providerResults,
-                    warnings: result.warnings
+                    message: 'Git repository initialized successfully',
+                    path: params.projectPath,
+                    bare: params.bare || false,
+                    output: result.stdout
+                },
+                metadata: {
+                    operation: 'init',
+                    timestamp: new Date().toISOString(),
+                    executionTime: Date.now() - startTime
                 }
             };
         }
-        throw new Error('Unexpected result format from provider operation');
-    }
-    catch (error) {
-        throw new Error(`Falha ao listar repositórios: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-async function handleGetRepo(repoName, detection, provider) {
-    try {
-        // Execute operation on specified provider(s)
-        const result = await provider_operation_handler_js_1.ProviderOperationHandler.executeOperation(provider, (providerInstance) => providerInstance.getRepository(detection.owner, repoName));
-        if (!result.success) {
-            const errorMessage = 'message' in result
-                ? result.message
-                : ('error' in result ? result.error || 'Failed to get repository' : 'Unknown error');
-            throw new Error(errorMessage);
-        }
-        // Handle single provider result
-        if ('provider' in result && result.data) {
-            return {
-                success: true,
-                action: 'get',
-                message: `Detalhes do repositório '${repoName}' obtidos do ${result.provider}`,
-                data: {
-                    repository: result.data,
-                    provider: result.provider
-                }
-            };
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return operation_error_handler_js_1.OperationErrorHandler.createToolError('INIT_ERROR', `Failed to initialize repository: ${errorMessage}`, 'init', { error: errorMessage, projectPath: params.projectPath });
         }
-        // Handle multi-provider result
-        if ('message' in result && typeof result.data === 'object') {
-            const multiData = result.data;
-            const repositories = {};
-            if (multiData.github?.success && multiData.github.data) {
-                repositories.github = multiData.github.data;
-            }
-            if (multiData.gitea?.success && multiData.gitea.data) {
-                repositories.gitea = multiData.gitea.data;
+    }
+    /**
+     * Handle git status operation
+     */
+    async handleStatus(params, startTime) {
+        try {
+            const result = await this.gitExecutor.getStatus(params.projectPath);
+            if (!result.success) {
+                return operation_error_handler_js_1.OperationErrorHandler.handleGitError(result.stderr, 'status', params.projectPath);
             }
             return {
                 success: true,
-                action: 'get',
-                message: result.message,
                 data: {
-                    repositories,
-                    provider: 'both',
-                    providerResults: {
-                        github: multiData.github ? {
-                            success: multiData.github.success,
-                            error: multiData.github.error
-                        } : undefined,
-                        gitea: multiData.gitea ? {
-                            success: multiData.gitea.success,
-                            error: multiData.gitea.error
-                        } : undefined
-                    },
-                    warnings: 'warnings' in result ? result.warnings : undefined
+                    status: result.parsedStatus,
+                    raw: result.stdout,
+                    repository: {
+                        path: params.projectPath,
+                        isGitRepository: result.isGitRepository
+                    }
+                },
+                metadata: {
+                    operation: 'status',
+                    timestamp: new Date().toISOString(),
+                    executionTime: Date.now() - startTime
                 }
             };
         }
-        throw new Error('Unexpected result format from provider operation');
-    }
-    catch (error) {
-        throw new Error(`Falha ao obter repositório: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-async function handleSearchRepos(searchQuery, detection, provider, language, sort = 'stars', order = 'desc') {
-    try {
-        // Execute operation on specified provider(s)
-        const result = await provider_operation_handler_js_1.ProviderOperationHandler.executeOperation(provider, (providerInstance) => providerInstance.searchRepositories(searchQuery));
-        if (!result.success) {
-            const errorMessage = 'message' in result
-                ? result.message
-                : ('error' in result ? result.error || 'Failed to search repositories' : 'Unknown error');
-            throw new Error(errorMessage);
-        }
-        // Handle single provider result
-        if ('provider' in result && result.data) {
-            const searchResults = result.data;
-            return {
-                success: true,
-                action: 'search',
-                message: `${searchResults.length} repositórios encontrados para '${searchQuery}' no ${result.provider}`,
-                data: {
-                    query: searchQuery,
-                    language,
-                    sort,
-                    order,
-                    results: searchResults,
-                    total: searchResults.length,
-                    provider: result.provider
-                }
-            };
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return operation_error_handler_js_1.OperationErrorHandler.createToolError('STATUS_ERROR', `Failed to get repository status: ${errorMessage}`, 'status', { error: errorMessage, projectPath: params.projectPath });
         }
-        // Handle multi-provider result
-        if ('message' in result && typeof result.data === 'object') {
-            const multiData = result.data;
-            const allResults = [];
-            const providerResults = {};
-            // Collect results from all successful providers
-            if (multiData.github?.success && multiData.github.data) {
-                const githubResults = multiData.github.data.map((repo) => ({
-                    ...repo,
-                    source: 'github'
-                }));
-                allResults.push(...githubResults);
-                providerResults.github = {
-                    success: true,
-                    count: multiData.github.data.length,
-                    results: multiData.github.data
-                };
-            }
-            else if (multiData.github) {
-                providerResults.github = {
-                    success: false,
-                    error: multiData.github.error
-                };
+    }
+    /**
+     * Handle git commit operation
+     */
+    async handleCommit(params, startTime) {
+        try {
+            if (!params.message) {
+                return operation_error_handler_js_1.OperationErrorHandler.createToolError('MISSING_PARAMETER', 'Commit message is required', 'commit', {}, ['Provide a commit message using the message parameter']);
             }
-            if (multiData.gitea?.success && multiData.gitea.data) {
-                const giteaResults = multiData.gitea.data.map((repo) => ({
-                    ...repo,
-                    source: 'gitea'
-                }));
-                allResults.push(...giteaResults);
-                providerResults.gitea = {
-                    success: true,
-                    count: multiData.gitea.data.length,
-                    results: multiData.gitea.data
-                };
+            // Add files to staging area
+            const filesToAdd = params.files || ['.'];
+            const addResult = await this.gitExecutor.addFiles(params.projectPath, filesToAdd);
+            if (!addResult.success) {
+                return operation_error_handler_js_1.OperationErrorHandler.handleGitError(addResult.stderr, 'commit (add)', params.projectPath);
             }
-            else if (multiData.gitea) {
-                providerResults.gitea = {
-                    success: false,
-                    error: multiData.gitea.error
-                };
+            // Commit changes
+            const commitResult = await this.gitExecutor.commit(params.projectPath, params.message);
+            if (!commitResult.success) {
+                return operation_error_handler_js_1.OperationErrorHandler.handleGitError(commitResult.stderr, 'commit', params.projectPath);
             }
             return {
                 success: true,
-                action: 'search',
-                message: result.message,
                 data: {
-                    query: searchQuery,
-                    language,
-                    sort,
-                    order,
-                    results: allResults,
-                    total: allResults.length,
-                    provider: 'both',
-                    providerResults,
-                    warnings: 'warnings' in result ? result.warnings : undefined
+                    message: 'Changes committed successfully',
+                    commitMessage: params.message,
+                    files: filesToAdd,
+                    output: commitResult.stdout,
+                    addOutput: addResult.stdout
+                },
+                metadata: {
+                    operation: 'commit',
+                    timestamp: new Date().toISOString(),
+                    executionTime: Date.now() - startTime
                 }
             };
         }
-        throw new Error('Unexpected result format from provider operation');
-    }
-    catch (error) {
-        throw new Error(`Falha na busca: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-async function handleUpdateRepo(repoName, detection, provider, description, isPrivate) {
-    try {
-        // Prepare update data
-        const updateData = {};
-        if (description !== undefined)
-            updateData.description = description;
-        if (isPrivate !== undefined)
-            updateData.private = isPrivate;
-        // Execute operation on specified provider(s)
-        const result = await provider_operation_handler_js_1.ProviderOperationHandler.executeOperation(provider, (providerInstance) => providerInstance.updateRepository(detection.owner, repoName, updateData));
-        if (!result.success) {
-            const errorMessage = 'message' in result
-                ? result.message
-                : ('error' in result ? result.error || 'Failed to update repository' : 'Unknown error');
-            throw new Error(errorMessage);
-        }
-        // Handle single provider result
-        if ('provider' in result && result.data) {
-            return {
-                success: true,
-                action: 'update',
-                message: `Repositório '${repoName}' atualizado com sucesso no ${result.provider}`,
-                data: {
-                    repoUpdated: true,
-                    repository: result.data,
-                    provider: result.provider
-                }
-            };
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return operation_error_handler_js_1.OperationErrorHandler.createToolError('COMMIT_ERROR', `Failed to commit changes: ${errorMessage}`, 'commit', { error: errorMessage, projectPath: params.projectPath });
         }
-        // Handle multi-provider result
-        if ('message' in result && typeof result.data === 'object') {
-            const multiData = result.data;
-            const updatedRepositories = {};
-            if (multiData.github?.success && multiData.github.data) {
-                updatedRepositories.github = multiData.github.data;
-            }
-            if (multiData.gitea?.success && multiData.gitea.data) {
-                updatedRepositories.gitea = multiData.gitea.data;
+    }
+    /**
+     * Handle git sync operation (fetch + pull + push)
+     */
+    async handleSync(params, startTime) {
+        try {
+            const remote = params.remote || 'origin';
+            const results = [];
+            // Fetch from remote
+            const fetchResult = await this.gitExecutor.fetch(params.projectPath, remote, { all: true, prune: true });
+            results.push({ operation: 'fetch', success: fetchResult.success, output: fetchResult.stdout, error: fetchResult.stderr });
+            // Pull changes
+            const pullResult = await this.gitExecutor.pull(params.projectPath, remote, params.branch, { force: params.force });
+            results.push({ operation: 'pull', success: pullResult.success, output: pullResult.stdout, error: pullResult.stderr });
+            // Push changes (only if pull was successful)
+            let pushResult = null;
+            if (pullResult.success) {
+                pushResult = await this.gitExecutor.push(params.projectPath, remote, params.branch, { force: params.force });
+                results.push({ operation: 'push', success: pushResult.success, output: pushResult.stdout, error: pushResult.stderr });
             }
+            const allSuccessful = results.every(r => r.success);
+            const hasErrors = results.some(r => !r.success);
             return {
-                success: true,
-                action: 'update',
-                message: result.message,
+                success: allSuccessful,
                 data: {
-                    repoUpdated: true,
-                    repositories: updatedRepositories,
-                    provider: 'both',
-                    providerResults: {
-                        github: multiData.github ? {
-                            success: multiData.github.success,
-                            error: multiData.github.error
-                        } : undefined,
-                        gitea: multiData.gitea ? {
-                            success: multiData.gitea.success,
-                            error: multiData.gitea.error
-                        } : undefined
-                    },
-                    warnings: 'warnings' in result ? result.warnings : undefined
+                    message: allSuccessful ? 'Repository synchronized successfully' : 'Synchronization completed with some errors',
+                    remote,
+                    branch: params.branch,
+                    operations: results,
+                    summary: {
+                        fetch: fetchResult.success,
+                        pull: pullResult.success,
+                        push: pushResult?.success || false
+                    }
+                },
+                error: hasErrors ? {
+                    code: 'SYNC_PARTIAL_ERROR',
+                    message: 'Some synchronization operations failed',
+                    details: results.filter(r => !r.success),
+                    suggestions: ['Check the individual operation errors and resolve them']
+                } : undefined,
+                metadata: {
+                    operation: 'sync',
+                    timestamp: new Date().toISOString(),
+                    executionTime: Date.now() - startTime
                 }
             };
         }
-        throw new Error('Unexpected result format from provider operation');
-    }
-    catch (error) {
-        throw new Error(`Falha ao atualizar repositório: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-async function handleDeleteRepo(repoName, detection, provider) {
-    try {
-        // Execute operation on specified provider(s)
-        const result = await provider_operation_handler_js_1.ProviderOperationHandler.executeOperation(provider, (providerInstance) => providerInstance.deleteRepository(detection.owner, repoName));
-        if (!result.success) {
-            const errorMessage = 'message' in result
-                ? result.message
-                : ('error' in result ? result.error || 'Failed to delete repository' : 'Unknown error');
-            throw new Error(errorMessage);
-        }
-        const deletedAt = new Date().toISOString();
-        // Handle single provider result
-        if ('provider' in result) {
-            return {
-                success: true,
-                action: 'delete',
-                message: `Repositório '${repoName}' removido com sucesso do ${result.provider}`,
-                data: {
-                    repoDeleted: true,
-                    repoName,
-                    owner: detection.owner,
-                    provider: result.provider,
-                    deletedAt,
-                    warning: 'Esta ação é irreversível'
-                }
-            };
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return operation_error_handler_js_1.OperationErrorHandler.createToolError('SYNC_ERROR', `Failed to synchronize repository: ${errorMessage}`, 'sync', { error: errorMessage, projectPath: params.projectPath });
         }
-        // Handle multi-provider result
-        if ('data' in result && typeof result.data === 'object') {
-            const multiData = result.data;
-            const deletionResults = {};
-            if (multiData.github) {
-                deletionResults.github = {
-                    success: multiData.github.success,
-                    error: multiData.github.error
-                };
+    }
+    /**
+     * Handle git backup operation
+     */
+    async handleBackup(params, startTime) {
+        try {
+            if (!params.backupPath) {
+                // Generate default backup path
+                const projectName = path_1.default.basename(params.projectPath);
+                const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+                params.backupPath = path_1.default.join(params.projectPath, '..', `${projectName}-backup-${timestamp}`);
             }
-            if (multiData.gitea) {
-                deletionResults.gitea = {
-                    success: multiData.gitea.success,
-                    error: multiData.gitea.error
-                };
+            const result = await this.gitExecutor.createBackup(params.projectPath, params.backupPath, 'tar');
+            if (!result.success) {
+                return operation_error_handler_js_1.OperationErrorHandler.handleGitError(result.stderr, 'backup', params.projectPath);
             }
             return {
                 success: true,
-                action: 'delete',
-                message: result.message,
                 data: {
-                    repoDeleted: true,
-                    repoName,
-                    owner: detection.owner,
-                    provider: 'both',
-                    deletionResults,
-                    deletedAt,
-                    warning: 'Esta ação é irreversível',
-                    warnings: 'warnings' in result ? result.warnings : undefined
+                    message: 'Repository backup created successfully',
+                    backupPath: `${params.backupPath}.tar.gz`,
+                    originalPath: params.projectPath,
+                    format: 'tar.gz',
+                    output: result.stdout
+                },
+                metadata: {
+                    operation: 'backup',
+                    timestamp: new Date().toISOString(),
+                    executionTime: Date.now() - startTime
                 }
             };
         }
-        throw new Error('Unexpected result format from provider operation');
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return operation_error_handler_js_1.OperationErrorHandler.createToolError('BACKUP_ERROR', `Failed to create repository backup: ${errorMessage}`, 'backup', { error: errorMessage, projectPath: params.projectPath });
+        }
     }
-    catch (error) {
-        throw new Error(`Falha ao remover repositório: ${error instanceof Error ? error.message : String(error)}`);
+    /**
+     * Check if operation is a remote operation
+     */
+    isRemoteOperation(action) {
+        const remoteOperations = ['create', 'list', 'get', 'update', 'delete', 'fork', 'search'];
+        return remoteOperations.includes(action);
     }
-}
-async function handleForkRepo(sourceRepo, newRepoName, detection, provider) {
-    try {
-        // Parse sourceRepo (format: owner/repo)
-        const [sourceOwner, sourceRepoName] = sourceRepo.split('/');
-        if (!sourceOwner || !sourceRepoName) {
-            throw new Error('sourceRepo deve estar no formato "owner/repo"');
-        }
-        const forkName = newRepoName || sourceRepoName;
-        // Execute operation on specified provider(s)
-        const result = await provider_operation_handler_js_1.ProviderOperationHandler.executeOperation(provider, (providerInstance) => providerInstance.forkRepository(sourceOwner, sourceRepoName));
-        if (!result.success) {
-            const errorMessage = 'message' in result
-                ? result.message
-                : ('error' in result ? result.error || 'Failed to fork repository' : 'Unknown error');
-            throw new Error(errorMessage);
-        }
-        // Handle single provider result
-        if ('provider' in result && result.data) {
-            return {
-                success: true,
-                action: 'fork',
-                message: `Fork '${forkName}' criado com sucesso de '${sourceRepo}' no ${result.provider}`,
-                data: {
-                    repoForked: true,
-                    originalRepo: sourceRepo,
-                    forkName,
-                    repository: result.data,
-                    provider: result.provider
-                }
-            };
-        }
-        // Handle multi-provider result
-        if ('message' in result && typeof result.data === 'object') {
-            const multiData = result.data;
-            const forkedRepositories = {};
-            if (multiData.github?.success && multiData.github.data) {
-                forkedRepositories.github = multiData.github.data;
-            }
-            if (multiData.gitea?.success && multiData.gitea.data) {
-                forkedRepositories.gitea = multiData.gitea.data;
-            }
-            return {
-                success: true,
-                action: 'fork',
-                message: result.message,
-                data: {
-                    repoForked: true,
-                    originalRepo: sourceRepo,
-                    forkName,
-                    repositories: forkedRepositories,
-                    provider: 'both',
-                    providerResults: {
-                        github: multiData.github ? {
-                            success: multiData.github.success,
-                            error: multiData.github.error
-                        } : undefined,
-                        gitea: multiData.gitea ? {
-                            success: multiData.gitea.success,
-                            error: multiData.gitea.error
-                        } : undefined
-                    },
-                    warnings: 'warnings' in result ? result.warnings : undefined
-                }
-            };
-        }
-        throw new Error('Unexpected result format from provider operation');
+    /**
+     * Extract parameters for remote operations
+     */
+    extractRemoteParameters(params) {
+        const remoteParams = {
+            projectPath: params.projectPath
+        };
+        // Common parameters
+        if (params.owner)
+            remoteParams.owner = params.owner;
+        if (params.repo)
+            remoteParams.repo = params.repo;
+        // Operation-specific parameters
+        switch (params.action) {
+            case 'create':
+                if (params.name)
+                    remoteParams.name = params.name;
+                if (params.description)
+                    remoteParams.description = params.description;
+                if (params.private !== undefined)
+                    remoteParams.private = params.private;
+                break;
+            case 'list':
+                // List operations may have type, sort, order parameters
+                break;
+            case 'get':
+                // Get operations need owner and repo (already handled above)
+                break;
+            case 'update':
+                if (params.name)
+                    remoteParams.name = params.name;
+                if (params.description)
+                    remoteParams.description = params.description;
+                if (params.private !== undefined)
+                    remoteParams.private = params.private;
+                break;
+            case 'delete':
+                // Delete operations need owner and repo (already handled above)
+                break;
+            case 'fork':
+                // Fork operations may have organization parameter
+                break;
+            case 'search':
+                if (params.query)
+                    remoteParams.query = params.query;
+                break;
+        }
+        return remoteParams;
     }
-    catch (error) {
-        throw new Error(`Falha ao criar fork: ${error instanceof Error ? error.message : String(error)}`);
+    /**
+     * Map git-workflow actions to provider operations
+     */
+    mapActionToProviderOperation(action) {
+        const actionMap = {
+            'create': 'repo-create',
+            'list': 'repo-list',
+            'get': 'repo-get',
+            'update': 'repo-update',
+            'delete': 'repo-delete',
+            'fork': 'repo-fork',
+            'search': 'repo-search'
+        };
+        return actionMap[action] || action;
     }
-}
-exports.gitWorkflowTool = {
-    name: 'git-workflow',
-    description: '🔄 WORKFLOW COMPLETO - Operações Git locais + gerenciamento completo de repositórios remotos: init, commit, sync, status, backup, create, list, get, update, delete, fork, search',
-    inputSchema,
-    async handler(input) {
-        try {
-            const { action, projectPath, provider, message, branch, remote, repoName, description, private: isPrivate, sourceRepo, searchQuery, language, sort, order, page, perPage } = input;
-            if (!projectPath) {
-                throw new Error('projectPath é obrigatório');
-            }
-            // Define remote operations that require provider parameter
-            const remoteOperations = ['create', 'list', 'get', 'update', 'delete', 'fork', 'search'];
-            // Validate provider parameter for remote operations
-            if (remoteOperations.includes(action)) {
-                if (!provider) {
-                    const detection = (0, auto_detection_js_1.autoDetect)(projectPath);
-                    return (0, auto_detection_js_1.createUniversalResponse)(false, action, 'Provider parameter is required for remote operations', detection, 'git-workflow', undefined, {
-                        code: 'MISSING_PROVIDER_PARAMETER',
-                        message: 'Provider parameter is required for remote operations',
-                        cause: 'Provider parameter not provided for remote operation',
-                        suggestion: 'Add provider parameter with one of: github, gitea, both'
-                    });
-                }
-                // Validate provider parameter value
-                const providerValidation = configuration_validator_js_1.ConfigurationValidator.validateProvider(provider);
-                if (!providerValidation.valid) {
-                    const detection = (0, auto_detection_js_1.autoDetect)(projectPath);
-                    return (0, auto_detection_js_1.createUniversalResponse)(false, action, providerValidation.error.message, detection, 'git-workflow', undefined, {
-                        code: providerValidation.error.code,
-                        message: providerValidation.error.message,
-                        cause: 'Invalid provider parameter value',
-                        suggestion: providerValidation.error.suggestion
-                    });
-                }
-                // Validate provider configuration
-                const configValidation = configuration_validator_js_1.ConfigurationValidator.validateProviderConfiguration(provider);
-                if (!configValidation.valid) {
-                    const detection = (0, auto_detection_js_1.autoDetect)(projectPath);
-                    const errorMessage = configuration_validator_js_1.ConfigurationValidator.formatValidationError(configValidation);
-                    // Create comprehensive error response for configuration issues
-                    const configError = configValidation.error.configuration;
-                    const enhancedMessage = configError
-                        ? `${configValidation.error.message}\n\n${configuration_validator_js_1.ConfigurationValidator.formatValidationError(configValidation)}`
-                        : configValidation.error.message;
-                    return (0, auto_detection_js_1.createUniversalResponse)(false, action, enhancedMessage, detection, 'git-workflow', undefined, {
-                        code: configValidation.error.code,
-                        message: errorMessage,
-                        cause: 'Provider configuration validation failed',
-                        suggestion: configValidation.error.suggestion
-                    });
-                }
-            }
-            const detection = (0, auto_detection_js_1.autoDetect)(projectPath);
-            let result;
-            switch (action) {
-                // Operações Git locais
-                case 'init':
-                    result = await handleInit(projectPath, detection);
-                    break;
-                case 'commit':
-                    if (!message) {
-                        throw new Error('message é obrigatória para commit');
-                    }
-                    result = await handleCommit(projectPath, message, branch, remote);
-                    break;
-                case 'sync':
-                    if (!message) {
-                        throw new Error('message é obrigatória para sync');
-                    }
-                    result = await handleSync(projectPath, message, branch, remote);
-                    break;
-                case 'status':
-                    result = await handleStatus(projectPath, detection);
-                    break;
-                case 'backup':
-                    result = await handleBackup(projectPath, detection);
-                    break;
-                // Gerenciamento de repositórios remotos
-                case 'create':
-                    if (!repoName) {
-                        throw new Error('repoName é obrigatório para create');
-                    }
-                    result = await handleCreateRepo(repoName, description || '', isPrivate || false, detection, projectPath, provider);
-                    break;
-                case 'list':
-                    result = await handleListRepos(detection, page, perPage, sort, provider);
-                    break;
-                case 'get':
-                    if (!repoName) {
-                        throw new Error('repoName é obrigatório para get');
-                    }
-                    result = await handleGetRepo(repoName, detection, provider);
-                    break;
-                case 'search':
-                    if (!searchQuery) {
-                        throw new Error('searchQuery é obrigatório para search');
-                    }
-                    result = await handleSearchRepos(searchQuery, detection, provider, language, sort, order);
-                    break;
-                case 'update':
-                    if (!repoName) {
-                        throw new Error('repoName é obrigatório para update');
-                    }
-                    result = await handleUpdateRepo(repoName, detection, provider, description, isPrivate);
-                    break;
-                case 'delete':
-                    if (!repoName) {
-                        throw new Error('repoName é obrigatório para delete');
-                    }
-                    result = await handleDeleteRepo(repoName, detection, provider);
-                    break;
-                case 'fork':
-                    if (!sourceRepo) {
-                        throw new Error('sourceRepo é obrigatório para fork');
+    /**
+     * Get tool schema for MCP registration
+     */
+    static getToolSchema() {
+        return {
+            name: 'git-workflow',
+            description: 'Core Git workflow tool for local and remote Git operations. Supports init, status, commit, sync, backup, create, list, get, update, delete, fork, and search operations.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    action: {
+                        type: 'string',
+                        enum: ['init', 'status', 'commit', 'sync', 'backup', 'create', 'list', 'get', 'update', 'delete', 'fork', 'search'],
+                        description: 'The Git 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 (required for remote operations)'
+                    },
+                    message: {
+                        type: 'string',
+                        description: 'Commit message (required for commit action)'
+                    },
+                    files: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'Specific files to commit (default: all changes)'
+                    },
+                    bare: {
+                        type: 'boolean',
+                        description: 'Initialize as bare repository (for init action)'
+                    },
+                    backupPath: {
+                        type: 'string',
+                        description: 'Path for backup file (for backup action)'
+                    },
+                    name: {
+                        type: 'string',
+                        description: 'Repository name (for create action)'
+                    },
+                    description: {
+                        type: 'string',
+                        description: 'Repository description (for create/update actions)'
+                    },
+                    private: {
+                        type: 'boolean',
+                        description: 'Create private repository (for create action)'
+                    },
+                    query: {
+                        type: 'string',
+                        description: 'Search query (for search action)'
+                    },
+                    owner: {
+                        type: 'string',
+                        description: 'Repository owner (for get/update/delete/fork actions)'
+                    },
+                    repo: {
+                        type: 'string',
+                        description: 'Repository name (for get/update/delete/fork actions)'
+                    },
+                    remote: {
+                        type: 'string',
+                        description: 'Remote name for sync (default: origin)'
+                    },
+                    branch: {
+                        type: 'string',
+                        description: 'Branch name for sync'
+                    },
+                    force: {
+                        type: 'boolean',
+                        description: 'Force operation (for sync action)'
                     }
-                    result = await handleForkRepo(sourceRepo, repoName, detection, provider);
-                    break;
-                default:
-                    throw new Error(`Ação '${action}' não suportada. Use: init, commit, sync, status, backup, create, list, get, update, delete, fork, search`);
-            }
-            return (0, auto_detection_js_1.createUniversalResponse)(result.success, action, result.message, detection, 'git-workflow', result.data);
-        }
-        catch (error) {
-            const detection = (0, auto_detection_js_1.autoDetect)(input.projectPath || '');
-            const errorInstance = error instanceof Error ? error : new Error(String(error));
-            // For remote operations, provide comprehensive error handling
-            const remoteOperations = ['create', 'list', 'get', 'update', 'delete', 'fork', 'search'];
-            if (remoteOperations.includes(input.action) && input.provider) {
-                const operationError = operation_error_handler_js_1.OperationErrorHandler.analyzeAndHandleError(errorInstance, input.provider, input.action);
-                return (0, auto_detection_js_1.createUniversalResponse)(false, input.action || 'unknown', operationError.message, detection, 'git-workflow', undefined, {
-                    code: operationError.code,
-                    message: operation_error_handler_js_1.OperationErrorHandler.formatErrorMessage(operationError),
-                    cause: operationError.cause,
-                    suggestion: operationError.solution
-                });
+                },
+                required: ['action', 'projectPath']
             }
-            // For local operations, provide generic error handling
-            return (0, auto_detection_js_1.createUniversalResponse)(false, input.action || 'unknown', errorInstance.message, detection, 'git-workflow', undefined, {
-                code: 'WORKFLOW_ERROR',
-                message: errorInstance.message,
-                cause: 'Erro na execução do workflow Git',
-                suggestion: 'Verifique os parâmetros e tente novamente'
-            });
-        }
+        };
     }
-};
+}
+exports.GitWorkflowTool = GitWorkflowTool;
 //# sourceMappingURL=git-workflow.js.map