@andrebuzeli/git-mcp 4.0.20 → 4.0.21

package/dist/tools/git-workflow.js

@@ -1,358 +1,331 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.gitWorkflowTool = void 0;
-const zod_1 = require("zod");
-const index_js_1 = require("../providers/index.js");
-const git_operations_js_1 = require("../utils/git-operations.js");
 const auto_detection_js_1 = require("../utils/auto-detection.js");
-const error_handler_js_1 = require("../utils/error-handler.js");
+const terminal_controller_js_1 = require("../utils/terminal-controller.js");
 /**
- * Tool: git-workflow
+ * Git Workflow Tool - Ferramenta Principal
  *
- * FERRAMENTA UNIFICADA PARA WORKFLOW PRINCIPAL - v2.0 AI-First
- *
- * Conforme especificado no design.md, esta tool:
- * - Requer apenas action + projectPath como obrigatórios
- * - Auto-detecta repo name, owner e providers
- * - Fornece respostas universais para todos os AI agents
- * - Suporta apenas 5 ações principais otimizadas
- *
- * DESIGNED FOR: Programadores individuais usando AI agents (Cursor, VSCode, etc.)
- * PHILOSOPHY: Simplicidade máxima com automação total
+ * 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
  */
-const GitWorkflowInputSchema = zod_1.z.discriminatedUnion('action', [
-    // INIT: Inicialização completa com auto-setup
-    zod_1.z.object({
-        action: zod_1.z.literal('init'),
-        projectPath: zod_1.z.string(),
-        message: zod_1.z.string().optional().default('Initial commit'),
-        provider: zod_1.z.enum(['gitea', 'github']).optional() // Se omitido, usa todos disponíveis
-    }),
-    // COMMIT: Commit rápido com backup automático
-    zod_1.z.object({
-        action: zod_1.z.literal('commit'),
-        projectPath: zod_1.z.string(),
-        message: zod_1.z.string().min(1, 'Commit message is required'),
-        provider: zod_1.z.enum(['gitea', 'github']).optional() // Se omitido, usa todos disponíveis
-    }),
-    // SYNC: Sincronização completa (pull+commit+push)
-    zod_1.z.object({
-        action: zod_1.z.literal('sync'),
-        projectPath: zod_1.z.string(),
-        message: zod_1.z.string().optional(),
-        provider: zod_1.z.enum(['gitea', 'github']).optional() // Se omitido, usa todos disponíveis
-    }),
-    // STATUS: Status essencial com métricas
-    zod_1.z.object({
-        action: zod_1.z.literal('status'),
-        projectPath: zod_1.z.string(),
-        detailed: zod_1.z.boolean().optional().default(false)
-    }),
-    // BACKUP: Backup imediato do estado atual
-    zod_1.z.object({
-        action: zod_1.z.literal('backup'),
-        projectPath: zod_1.z.string(),
-        description: zod_1.z.string().optional()
-    })
-]);
-/**
- * Classe principal para executar operações Git workflow
- */
-class GitWorkflowExecutor {
-    errorHandler = new error_handler_js_1.UniversalErrorHandler();
-    /**
-     * Executa operação init com auto-detecção completa
-     */
-    async executeInit(detection, input) {
-        try {
-            const gitOps = new git_operations_js_1.GitOperations(detection.projectPath);
-            // Inicializa repositório Git se necessário
-            if (!detection.isValidRepo) {
-                await gitOps.initRepository();
-            }
-            // Cria commit inicial
-            await gitOps.addFiles(['.']);
-            await gitOps.commit(input.message || 'Initial commit');
-            // Configura remotes para providers disponíveis
-            const configuredProviders = [];
-            for (const provider of detection.providers) {
-                try {
-                    const providerInstance = index_js_1.globalProviderFactory.createProvider(provider);
-                    const remoteUrl = providerInstance.getRepositoryUrl(detection.owner, detection.repoName);
-                    await gitOps.remote('add', provider, remoteUrl);
-                    await gitOps.push('main', provider);
-                    configuredProviders.push(provider);
-                }
-                catch (error) {
-                    this.errorHandler.addError(error, provider, { action: 'init', projectPath: detection.projectPath });
-                }
-            }
-            return (0, auto_detection_js_1.createUniversalResponse)(true, 'init', `Projeto inicializado com sucesso. ${configuredProviders.length} providers configurados.`, detection, 'git-workflow', {
-                gitInitialized: true,
-                initialCommit: true,
-                providersConfigured: configuredProviders,
-                remoteUrl: detection.providers.length > 0 ?
-                    `${detection.providers[0]}:${detection.owner}/${detection.repoName}` : null
-            });
-        }
-        catch (error) {
-            this.errorHandler.addError(error, undefined, { action: 'init', projectPath: detection.projectPath });
-            return (0, auto_detection_js_1.createUniversalResponse)(false, 'init', 'Falha ao inicializar projeto', detection, 'git-workflow', undefined, this.errorHandler.toUniversalResponse());
+const inputSchema = {
+    type: 'object',
+    properties: {
+        action: {
+            type: 'string',
+            enum: ['init', 'commit', 'sync', 'status', 'backup'],
+            description: 'Ação do workflow a executar'
+        },
+        projectPath: {
+            type: 'string',
+            description: 'Caminho do projeto (obrigatório)'
+        },
+        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)'
         }
-    }
-    /**
-     * Executa operação commit com auto-detecção
-     */
-    async executeCommit(detection, input) {
-        try {
-            const gitOps = new git_operations_js_1.GitOperations(detection.projectPath);
-            // Adiciona arquivos e commita
-            await gitOps.addFiles(['.']);
-            await gitOps.commit(input.message);
-            // Push para providers disponíveis
-            const pushedProviders = [];
-            const providersToUse = input.provider ? [input.provider] : detection.providers;
-            for (const provider of providersToUse) {
-                try {
-                    await gitOps.push('main', provider);
-                    pushedProviders.push(provider);
-                }
-                catch (error) {
-                    this.errorHandler.addError(error, provider, { action: 'commit', projectPath: detection.projectPath });
+    },
+    required: ['action', 'projectPath']
+};
+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
                 }
+            };
+        }
+        // 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
             }
-            return (0, auto_detection_js_1.createUniversalResponse)(true, 'commit', `Commit realizado com sucesso. Enviado para ${pushedProviders.length} providers.`, detection, 'git-workflow', {
-                committed: true,
-                pushedTo: pushedProviders,
-                commitMessage: input.message
-            });
+        };
+    }
+    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');
         }
-        catch (error) {
-            this.errorHandler.addError(error, input.provider, { action: 'commit', projectPath: detection.projectPath });
-            return (0, auto_detection_js_1.createUniversalResponse)(false, 'commit', 'Falha ao realizar commit', detection, 'git-workflow', undefined, this.errorHandler.toUniversalResponse());
+        // 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}`);
         }
-    }
-    /**
-     * Executa operação sync (pull + commit + push)
-     */
-    async executeSync(detection, input) {
-        try {
-            const gitOps = new git_operations_js_1.GitOperations(detection.projectPath);
-            // Pull de todos os providers
-            const pulledProviders = [];
-            const providersToUse = input.provider ? [input.provider] : detection.providers;
-            for (const provider of providersToUse) {
-                try {
-                    await gitOps.pull('main', provider);
-                    pulledProviders.push(provider);
-                }
-                catch (error) {
-                    this.errorHandler.addError(error, provider, { action: 'sync', projectPath: detection.projectPath });
-                }
+        // 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
             }
-            // Commit se houver mudanças
-            let committed = false;
-            try {
-                await gitOps.addFiles(['.']);
-                if (input.message) {
-                    await gitOps.commit(input.message);
-                    committed = true;
-                }
+        };
+    }
+    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}`);
             }
-            catch (error) {
-                // Não é erro crítico se não houver mudanças para commitar
-                if (!(error instanceof Error) || !error.message?.includes('nothing to commit')) {
-                    this.errorHandler.addError(error, undefined, { action: 'sync', projectPath: detection.projectPath });
-                }
+            // 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 para todos os providers
-            const pushedProviders = [];
-            for (const provider of providersToUse) {
-                try {
-                    await gitOps.push('main', provider);
-                    pushedProviders.push(provider);
-                }
-                catch (error) {
-                    this.errorHandler.addError(error, provider, { action: 'sync', projectPath: detection.projectPath });
+            // 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
                 }
-            }
-            return (0, auto_detection_js_1.createUniversalResponse)(true, 'sync', `Sincronização completa: ${pulledProviders.length} pulls, ${committed ? 1 : 0} commits, ${pushedProviders.length} pushes`, detection, 'git-workflow', {
-                pulledFrom: pulledProviders,
-                committed,
-                pushedTo: pushedProviders,
-                commitMessage: input.message
-            });
+            };
         }
-        catch (error) {
-            this.errorHandler.addError(error, input.provider, { action: 'sync', projectPath: detection.projectPath });
-            return (0, auto_detection_js_1.createUniversalResponse)(false, 'sync', 'Falha na sincronização', detection, 'git-workflow', undefined, this.errorHandler.toUniversalResponse());
+        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
+                }
+            };
         }
     }
-    /**
-     * Executa operação status
-     */
-    async executeStatus(detection, input) {
+    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 {
-            const gitOps = new git_operations_js_1.GitOperations(detection.projectPath);
-            const status = await gitOps.status(input.detailed ? {} : { short: true });
-            return (0, auto_detection_js_1.createUniversalResponse)(true, 'status', 'Status obtido com sucesso', detection, 'git-workflow', {
-                gitStatus: status,
-                isValidRepo: detection.isValidRepo,
-                providersConfigured: detection.providers.length,
-                currentBranch: 'main' // Simplificado por enquanto
-            });
+            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) {
-            this.errorHandler.addError(error, undefined, { action: 'status', projectPath: detection.projectPath });
-            return (0, auto_detection_js_1.createUniversalResponse)(false, 'status', 'Falha ao obter status', detection, 'git-workflow', undefined, this.errorHandler.toUniversalResponse());
+            // Ignorar erros de comandos git adicionais
         }
-    }
-    /**
-     * Executa operação backup
-     */
-    async executeBackup(detection, input) {
-        try {
-            const gitOps = new git_operations_js_1.GitOperations(detection.projectPath);
-            // Cria commit de backup
-            const backupMessage = input.description ?
-                `Backup: ${input.description}` :
-                `Backup automático - ${new Date().toISOString()}`;
-            await gitOps.addFiles(['.']);
-            await gitOps.commit(backupMessage);
-            // Push para todos os providers
-            const backedUpTo = [];
-            for (const provider of detection.providers) {
-                try {
-                    await gitOps.push('main', provider);
-                    backedUpTo.push(provider);
-                }
-                catch (error) {
-                    this.errorHandler.addError(error, provider, { action: 'backup', projectPath: detection.projectPath });
-                }
+        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
             }
-            return (0, auto_detection_js_1.createUniversalResponse)(true, 'backup', `Backup realizado com sucesso em ${backedUpTo.length} providers`, detection, 'git-workflow', {
-                backupCreated: true,
-                backedUpTo,
-                backupMessage,
-                timestamp: new Date().toISOString()
-            });
+        };
+    }
+    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');
         }
-        catch (error) {
-            this.errorHandler.addError(error, undefined, { action: 'backup', projectPath: detection.projectPath });
-            return (0, auto_detection_js_1.createUniversalResponse)(false, 'backup', 'Falha ao criar backup', detection, 'git-workflow', undefined, this.errorHandler.toUniversalResponse());
+        // 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 });
         }
+        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)}`);
     }
 }
-// Instância global do executor
-const workflowExecutor = new GitWorkflowExecutor();
 exports.gitWorkflowTool = {
     name: 'git-workflow',
-    description: `🛠️ WORKFLOW PRINCIPAL v2.0 - AI-First Design
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-🎯 APENAS 5 AÇÕES OTIMIZADAS (conforme design.md):
-
-INIT: Inicialização completa com auto-detecção
-• Requer apenas: action + projectPath
-• Auto-detecta: repo name, owner, providers
-• Configura Git + remotes + commit inicial
-
-COMMIT: Commit inteligente com push automático
-• Requer apenas: action + projectPath + message
-• Auto-detecta providers e faz push para todos
-
-SYNC: Sincronização completa (pull+commit+push)
-• Requer apenas: action + projectPath
-• Pull de todos + commit opcional + push para todos
-
-STATUS: Status essencial com métricas
-• Requer apenas: action + projectPath
-• Informações críticas para desenvolvimento
-
-BACKUP: Backup imediato do estado atual
-• Requer apenas: action + projectPath
-• Commit + push para todos os providers
-
-✨ DIFERENCIAIS v2.0:
-• Zero-config: Apenas action + projectPath obrigatórios
-• Auto-detecção universal: repo/owner/providers do projectPath
-• Respostas universais: Funciona com qualquer AI agent/IDE
-• Multi-provider automático: Usa todos os providers configurados
-• Error handling inteligente: Causas detalhadas + sugestões de recovery`,
-    inputSchema: {
-        type: 'object',
-        properties: {
-            action: {
-                type: 'string',
-                enum: ['init', 'commit', 'sync', 'status', 'backup'],
-                description: 'Workflow action (apenas 5 ações otimizadas)'
-            },
-            projectPath: {
-                type: 'string',
-                description: 'Caminho absoluto do projeto (OBRIGATÓRIO - único parâmetro sempre necessário)'
-            },
-            message: {
-                type: 'string',
-                description: 'Mensagem para commit/init (obrigatório apenas para commit)'
-            },
-            provider: {
-                type: 'string',
-                enum: ['gitea', 'github'],
-                description: 'Provider específico (opcional - se omitido, usa todos os configurados)'
-            },
-            detailed: {
-                type: 'boolean',
-                description: 'Output detalhado para status (opcional)',
-                default: false
-            },
-            description: {
-                type: 'string',
-                description: 'Descrição para backup (opcional)'
-            }
-        },
-        required: ['action', 'projectPath']
-    },
+    description: '🔄 WORKFLOW PRINCIPAL - Operações Git integradas: init, commit, sync, status, backup',
+    inputSchema,
     async handler(input) {
         try {
-            // Valida input
-            const validatedInput = GitWorkflowInputSchema.parse(input);
-            // Auto-detecta contexto do projeto
-            const detection = (0, auto_detection_js_1.autoDetect)(validatedInput.projectPath);
-            // Valida se a auto-detecção foi bem-sucedida
-            const validation = (0, auto_detection_js_1.validateAutoDetection)(detection);
-            if (!validation.isValid) {
-                return (0, auto_detection_js_1.createUniversalResponse)(false, validatedInput.action, 'Falha na auto-detecção do projeto', detection, 'git-workflow', { validation }, {
-                    code: 'AUTO_DETECTION_FAILED',
-                    message: 'Não foi possível detectar automaticamente as configurações do projeto',
-                    cause: validation.errors.join('; '),
-                    suggestion: 'Verifique se as variáveis de ambiente estão configuradas: GITEA_USERNAME/GITEA_TOKEN/GITEA_URL ou GITHUB_USERNAME/GITHUB_TOKEN'
-                });
+            const { action, projectPath, message, branch, remote } = input;
+            if (!projectPath) {
+                throw new Error('projectPath é obrigatório');
             }
-            // Executa ação específica
-            switch (validatedInput.action) {
+            const detection = (0, auto_detection_js_1.autoDetect)(projectPath);
+            let result;
+            switch (action) {
                 case 'init':
-                    return await workflowExecutor['executeInit'](detection, validatedInput);
+                    result = await handleInit(projectPath, detection);
+                    break;
                 case 'commit':
-                    return await workflowExecutor['executeCommit'](detection, validatedInput);
+                    if (!message) {
+                        throw new Error('message é obrigatória para commit');
+                    }
+                    result = await handleCommit(projectPath, message, branch, remote);
+                    break;
                 case 'sync':
-                    return await workflowExecutor['executeSync'](detection, validatedInput);
+                    if (!message) {
+                        throw new Error('message é obrigatória para sync');
+                    }
+                    result = await handleSync(projectPath, message, branch, remote);
+                    break;
                 case 'status':
-                    return await workflowExecutor['executeStatus'](detection, validatedInput);
+                    result = await handleStatus(projectPath, detection);
+                    break;
                 case 'backup':
-                    return await workflowExecutor['executeBackup'](detection, validatedInput);
+                    result = await handleBackup(projectPath, detection);
+                    break;
+                default:
+                    throw new Error(`Ação '${action}' não suportada. Use: init, commit, sync, status, backup`);
             }
+            return (0, auto_detection_js_1.createUniversalResponse)(result.success, action, result.message, detection, 'git-workflow', result.data);
         }
         catch (error) {
-            // Cria resposta de erro universal
-            const detection = input.projectPath ? (0, auto_detection_js_1.autoDetect)(input.projectPath) : {
-                projectPath: input.projectPath || 'unknown',
-                repoName: 'unknown',
-                owner: 'unknown',
-                providers: [],
-                isValidRepo: false
-            };
-            const errorHandler = new error_handler_js_1.UniversalErrorHandler();
-            errorHandler.addError(error, undefined, { action: input.action, projectPath: input.projectPath });
-            return (0, auto_detection_js_1.createUniversalResponse)(false, input.action, `Erro na operação ${input.action}`, detection, 'git-workflow', undefined, errorHandler.toUniversalResponse());
+            const detection = (0, auto_detection_js_1.autoDetect)(input.projectPath || '');
+            return (0, auto_detection_js_1.createUniversalResponse)(false, input.action || 'unknown', error instanceof Error ? error.message : String(error), detection, 'git-workflow', undefined, {
+                code: 'WORKFLOW_ERROR',
+                message: error instanceof Error ? error.message : String(error),
+                cause: 'Erro na execução do workflow Git',
+                suggestion: 'Verifique os parâmetros e tente novamente'
+            });
         }
     }
 };