@andrebuzeli/git-mcp 2.48.0 → 3.0.1

package/dist/tools/git-workflow.js

@@ -2,86 +2,96 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.gitWorkflowTool = void 0;
 const zod_1 = require("zod");
+const index_js_1 = require("../providers/index.js");
+const user_detection_js_1 = require("../utils/user-detection.js");
+const git_operations_js_1 = require("../utils/git-operations.js");
 /**
  * Tool: git-workflow
  *
- * DESCRIÇÃO:
- * Automação completa de workflows de desenvolvimento para programadores individuais autônomos
+ * FERRAMENTA UNIFICADA PARA WORKFLOW PRINCIPAL
+ * Combina as funcionalidades essenciais de:
+ * - git-update-project (init, update, sync)
+ * - git-commits (create, push, pull)
+ * - git-repositories (create, clone)
  *
- * FUNCIONALIDADES:
- * - Setup inicial automatizado de projetos
- * - Workflows diários de desenvolvimento
- * - Gerenciamento de features automatizado
- * - Processos de release completos
- * - Limpeza automática de repositórios
- * - Templates para diferentes tipos de projeto
- *
- * USO:
- * - Automação de todo o ciclo de desenvolvimento
- * - Setup consistente de novos projetos
- * - Workflows padronizados
- * - Eliminação de tarefas manuais repetitivas
- *
- * OTIMIZADO PARA AI AGENTS:
- * - Interface simples e intuitiva
- * - Auto-detecção de contexto
- * - Validação automática
- * - Error handling robusto
- * - Workflows em uma única chamada
+ * DESIGNED FOR: Programador individual autônomo
+ * PHILOSOPHY: Workflow principal completo em uma única ferramenta
  */
 const GitWorkflowInputSchema = zod_1.z.discriminatedUnion('action', [
-    // Action: setup-project - Setup inicial completo
+    // WORKFLOW PRINCIPAL - Substitui git-update-project
+    zod_1.z.object({
+        action: zod_1.z.literal('init'),
+        repo: zod_1.z.string(),
+        projectPath: zod_1.z.string(),
+        provider: zod_1.z.enum(['gitea', 'github']),
+        message: zod_1.z.string().min(1, 'Commit message is required'),
+        createRemote: zod_1.z.boolean().optional().default(false),
+        branch: zod_1.z.string().optional().default('main')
+    }),
+    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'),
+        addAll: zod_1.z.boolean().optional().default(true),
+        push: zod_1.z.boolean().optional().default(false),
+        branch: zod_1.z.string().optional().default('main'),
+        provider: zod_1.z.enum(['gitea', 'github']).optional()
+    }),
     zod_1.z.object({
-        action: zod_1.z.literal('setup-project'),
+        action: zod_1.z.literal('sync'),
         repo: zod_1.z.string(),
+        projectPath: zod_1.z.string(),
         provider: zod_1.z.enum(['gitea', 'github']),
+        message: zod_1.z.string().min(1, 'Commit message is required'),
+        branch: zod_1.z.string().optional().default('main'),
+        forcePush: zod_1.z.boolean().optional().default(false)
+    }),
+    // STATUS E MONITORAMENTO
+    zod_1.z.object({
+        action: zod_1.z.literal('status'),
+        projectPath: zod_1.z.string(),
+        detailed: zod_1.z.boolean().optional().default(false)
+    }),
+    zod_1.z.object({
+        action: zod_1.z.literal('diff'),
         projectPath: zod_1.z.string(),
-        template: zod_1.z.enum(['node-api', 'react-app', 'python-package', 'go-service', 'rust-binary']).optional().default('node-api'),
-        platforms: zod_1.z.array(zod_1.z.enum(['npm', 'github', 'docker', 'pypi'])).optional().default(['github']),
-        autoConfigure: zod_1.z.boolean().optional().default(true),
-        createRemote: zod_1.z.boolean().optional().default(true),
-        initGit: zod_1.z.boolean().optional().default(true)
+        staged: zod_1.z.boolean().optional().default(false),
+        file: zod_1.z.string().optional()
     }),
-    // Action: daily-dev - Workflow diário completo
     zod_1.z.object({
-        action: zod_1.z.literal('daily-dev'),
+        action: zod_1.z.literal('log'),
         projectPath: zod_1.z.string(),
-        autoCommit: zod_1.z.boolean().optional().default(true),
-        autoPush: zod_1.z.boolean().optional().default(true),
-        createBackup: zod_1.z.boolean().optional().default(true),
-        runTests: zod_1.z.boolean().optional().default(false),
-        checkLint: zod_1.z.boolean().optional().default(false)
+        limit: zod_1.z.number().optional().default(10),
+        oneline: zod_1.z.boolean().optional().default(true)
+    }),
+    // REPOSITORIES - Substitui parte do git-repositories
+    zod_1.z.object({
+        action: zod_1.z.literal('create-repo'),
+        name: zod_1.z.string(),
+        description: zod_1.z.string().optional(),
+        private: zod_1.z.boolean().optional().default(false),
+        provider: zod_1.z.enum(['gitea', 'github'])
     }),
-    // Action: feature-dev - Desenvolvimento de features
     zod_1.z.object({
-        action: zod_1.z.literal('feature-dev'),
+        action: zod_1.z.literal('clone-repo'),
+        name: zod_1.z.string(),
+        provider: zod_1.z.enum(['gitea', 'github']),
         projectPath: zod_1.z.string(),
-        featureName: zod_1.z.string(),
-        createBranch: zod_1.z.boolean().optional().default(true),
-        baseBranch: zod_1.z.string().optional().default('main'),
-        mergeWhenReady: zod_1.z.boolean().optional().default(true),
-        runTests: zod_1.z.boolean().optional().default(true),
-        createPR: zod_1.z.boolean().optional().default(false)
+        branch: zod_1.z.string().optional().default('main')
     }),
-    // Action: release-workflow - Processo completo de release
+    // QUICK ACTIONS
     zod_1.z.object({
-        action: zod_1.z.literal('release-workflow'),
+        action: zod_1.z.literal('pull'),
         projectPath: zod_1.z.string(),
-        version: zod_1.z.string().optional(),
-        platforms: zod_1.z.array(zod_1.z.enum(['npm', 'github', 'docker', 'pypi'])).optional().default(['npm', 'github']),
-        createTag: zod_1.z.boolean().optional().default(true),
-        createRelease: zod_1.z.boolean().optional().default(true),
-        updateChangelog: zod_1.z.boolean().optional().default(true),
-        runTests: zod_1.z.boolean().optional().default(true)
+        branch: zod_1.z.string().optional().default('main'),
+        provider: zod_1.z.enum(['gitea', 'github']).optional()
     }),
-    // Action: cleanup-workflow - Limpeza de repositório
     zod_1.z.object({
-        action: zod_1.z.literal('cleanup-workflow'),
+        action: zod_1.z.literal('push'),
         projectPath: zod_1.z.string(),
-        removeMergedBranches: zod_1.z.boolean().optional().default(true),
-        removeOldBackups: zod_1.z.boolean().optional().default(true),
-        optimizeRepository: zod_1.z.boolean().optional().default(true),
-        daysOld: zod_1.z.number().optional().default(30)
+        branch: zod_1.z.string().optional().default('main'),
+        provider: zod_1.z.enum(['gitea', 'github']).optional(),
+        force: zod_1.z.boolean().optional().default(false)
     })
 ]);
 const GitWorkflowResultSchema = zod_1.z.object({
@@ -89,555 +99,471 @@ const GitWorkflowResultSchema = zod_1.z.object({
     action: zod_1.z.string(),
     message: zod_1.z.string(),
     data: zod_1.z.any().optional(),
-    error: zod_1.z.string().optional()
+    error: zod_1.z.string().optional(),
+    recoverable: zod_1.z.boolean().optional(),
+    suggestion: zod_1.z.string().optional()
 });
+/**
+ * Enhanced Error Handler with Recovery Suggestions
+ */
+class WorkflowErrorHandler {
+    static handleError(error, context) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        // Error patterns and recovery suggestions
+        const errorPatterns = [
+            {
+                pattern: /not a git repository/i,
+                suggestion: "Run 'git init' first or check the project path",
+                recoverable: true
+            },
+            {
+                pattern: /no commits/i,
+                suggestion: "Make initial commit first",
+                recoverable: true
+            },
+            {
+                pattern: /repository.*already exists/i,
+                suggestion: "Choose a different repository name",
+                recoverable: true
+            },
+            {
+                pattern: /authentication failed/i,
+                suggestion: "Check your token configuration",
+                recoverable: true
+            },
+            {
+                pattern: /permission denied/i,
+                suggestion: "Check repository permissions and token scope",
+                recoverable: true
+            },
+            {
+                pattern: /network error/i,
+                suggestion: "Check internet connection and try again",
+                recoverable: true
+            }
+        ];
+        const matchedPattern = errorPatterns.find(p => p.pattern.test(errorMessage));
+        return {
+            success: false,
+            action: context,
+            message: `Error in ${context}: ${errorMessage}`,
+            error: errorMessage,
+            recoverable: matchedPattern?.recoverable || false,
+            suggestion: matchedPattern?.suggestion
+        };
+    }
+}
 exports.gitWorkflowTool = {
     name: 'git-workflow',
-    description: 'tool: ⚡ WORKFLOW AUTOMATION - Sistema completo de automação para programadores individuais\\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\\nAÇÕES DISPONÍVEIS (5 workflows automatizados):\\n\\n🚀 SETUP COMPLETO:\\n• setup-project: Setup inicial automatizado com templates\\n\\n📅 WORKFLOWS DIÁRIOS:\\n• daily-dev: Workflow diário completo (backup+commit+push)\\n• feature-dev: Desenvolvimento de features automatizado\\n\\n🎯 RELEASE COMPLETO:\\n• release-workflow: Processo completo de release\\n\\n🧹 MANUTENÇÃO:\\n• cleanup-workflow: Limpeza automática de repositório\\n\\n🤖 OTIMIZADO PARA AI AGENTS:\\n• Workflows em 1 chamada\\n• Auto-configuração inteligente\\n• Templates padronizados\\n• Validação automática\\n• Error recovery automático\\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\\n💡 USO TÍPICO:\\n1. setup-project (novo projeto)\\n2. daily-dev (desenvolvimento diário)\\n3. feature-dev (nova feature)\\n4. release-workflow (publicação)\\n5. cleanup-workflow (manutenção)\\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━',
+    description: `🛠️ WORKFLOW PRINCIPAL - Tudo que você precisa para trabalhar
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+🎯 WORKFLOW PRINCIPAL:
+• init: Inicializar projeto completo
+• commit: Commit + push automático
+• sync: Pull + commit + push completo
+
+📊 STATUS & MONITORAMENTO:
+• status: Status detalhado do projeto
+• diff: Ver diferenças nos arquivos
+• log: Histórico de commits
+
+🏗️ REPOSITÓRIOS:
+• create-repo: Criar repositório remoto
+• clone-repo: Clonar repositório localmente
+
+⚡ QUICK ACTIONS:
+• pull: Baixar mudanças
+• push: Enviar mudanças
+
+✨ DIFERENCIAIS:
+• Error handling inteligente com sugestões
+• Workflow completo em uma ferramenta
+• Auto-detecção de providers
+• Operações seguras com validação`,
     inputSchema: {
         type: 'object',
         properties: {
             action: {
                 type: 'string',
-                enum: ['setup-project', 'daily-dev', 'feature-dev', 'release-workflow', 'cleanup-workflow'],
+                enum: ['init', 'commit', 'sync', 'status', 'diff', 'log', 'create-repo', 'clone-repo', 'pull', 'push'],
                 description: 'Workflow action to perform'
             },
             repo: { type: 'string', description: 'Repository name' },
-            provider: { type: 'string', enum: ['gitea', 'github'], description: 'Provider to use' },
             projectPath: { type: 'string', description: 'Local project path' },
-            template: {
-                type: 'string',
-                enum: ['node-api', 'react-app', 'python-package', 'go-service', 'rust-binary'],
-                description: 'Project template to use',
-                default: 'node-api'
-            },
-            platforms: {
-                type: 'array',
-                items: { type: 'string', enum: ['npm', 'github', 'docker', 'pypi'] },
-                description: 'Platforms for setup/publishing',
-                default: ['github']
-            },
-            autoConfigure: { type: 'boolean', description: 'Auto-configure project', default: true },
-            createRemote: { type: 'boolean', description: 'Create remote repository', default: true },
-            initGit: { type: 'boolean', description: 'Initialize Git repository', default: true },
-            autoCommit: { type: 'boolean', description: 'Auto-commit changes', default: true },
-            autoPush: { type: 'boolean', description: 'Auto-push after commit', default: true },
-            createBackup: { type: 'boolean', description: 'Create backup before operations', default: true },
-            runTests: { type: 'boolean', description: 'Run tests before operations', default: true },
-            checkLint: { type: 'boolean', description: 'Check linting', default: false },
-            featureName: { type: 'string', description: 'Name of the feature to develop' },
-            createBranch: { type: 'boolean', description: 'Create feature branch', default: true },
-            baseBranch: { type: 'string', description: 'Base branch for feature', default: 'main' },
-            mergeWhenReady: { type: 'boolean', description: 'Merge when feature is ready', default: true },
-            createPR: { type: 'boolean', description: 'Create pull request', default: false },
-            version: { type: 'string', description: 'Release version' },
-            createTag: { type: 'boolean', description: 'Create release tag', default: true },
-            createRelease: { type: 'boolean', description: 'Create GitHub release', default: true },
-            updateChangelog: { type: 'boolean', description: 'Update changelog', default: true },
-            removeMergedBranches: { type: 'boolean', description: 'Remove merged branches', default: true },
-            removeOldBackups: { type: 'boolean', description: 'Remove old backup stashes', default: true },
-            optimizeRepository: { type: 'boolean', description: 'Optimize repository', default: true },
-            daysOld: { type: 'number', description: 'Days threshold for cleanup', default: 30 }
+            provider: { type: 'string', enum: ['gitea', 'github'], description: 'Git provider' },
+            message: { type: 'string', description: 'Commit message' },
+            createRemote: { type: 'boolean', description: 'Create remote repository', default: false },
+            branch: { type: 'string', description: 'Branch name', default: 'main' },
+            addAll: { type: 'boolean', description: 'Add all files before commit', default: true },
+            push: { type: 'boolean', description: 'Push after commit', default: false },
+            forcePush: { type: 'boolean', description: 'Force push', default: false },
+            detailed: { type: 'boolean', description: 'Detailed output', default: false },
+            staged: { type: 'boolean', description: 'Show staged changes', default: false },
+            file: { type: 'string', description: 'Specific file for diff' },
+            limit: { type: 'number', description: 'Limit for log', default: 10 },
+            oneline: { type: 'boolean', description: 'One line log format', default: true },
+            name: { type: 'string', description: 'Repository name' },
+            description: { type: 'string', description: 'Repository description' },
+            private: { type: 'boolean', description: 'Private repository', default: false },
+            force: { type: 'boolean', description: 'Force push', default: false }
         },
-        required: ['action', 'projectPath']
+        required: ['action']
     },
     async handler(input) {
         try {
             const validatedInput = GitWorkflowInputSchema.parse(input);
             switch (validatedInput.action) {
-                case 'setup-project':
-                    return await this.handleSetupProject(validatedInput);
-                case 'daily-dev':
-                    return await this.handleDailyDev(validatedInput);
-                case 'feature-dev':
-                    return await this.handleFeatureDev(validatedInput);
-                case 'release-workflow':
-                    return await this.handleReleaseWorkflow(validatedInput);
-                case 'cleanup-workflow':
-                    return await this.handleCleanupWorkflow(validatedInput);
+                case 'init':
+                    return await this.handleInit(validatedInput);
+                case 'commit':
+                    return await this.handleCommit(validatedInput);
+                case 'sync':
+                    return await this.handleSync(validatedInput);
+                case 'status':
+                    return await this.handleStatus(validatedInput);
+                case 'diff':
+                    return await this.handleDiff(validatedInput);
+                case 'log':
+                    return await this.handleLog(validatedInput);
+                case 'create-repo':
+                    return await this.handleCreateRepo(validatedInput);
+                case 'clone-repo':
+                    return await this.handleCloneRepo(validatedInput);
+                case 'pull':
+                    return await this.handlePull(validatedInput);
+                case 'push':
+                    return await this.handlePush(validatedInput);
                 default:
-                    throw new Error(`Action '${validatedInput.action}' não suportada`);
+                    throw new Error(`Action '${validatedInput.action}' not supported`);
             }
         }
         catch (error) {
-            return {
-                success: false,
-                action: input.action,
-                message: `Erro na operação ${input.action}`,
-                error: error instanceof Error ? error.message : String(error)
-            };
+            return WorkflowErrorHandler.handleError(error, `workflow.${input.action}`);
         }
     },
-    // Handler para setup-project
-    async handleSetupProject(params) {
-        try {
-            const { repo, provider, projectPath, template = 'node-api', platforms = ['github'], autoConfigure = true, createRemote = true, initGit = true } = params;
-            const results = {
-                gitInit: false,
-                remoteCreated: false,
-                templateApplied: false,
-                configured: false
-            };
-            // 1. Initialize Git if requested
-            if (initGit) {
-                const initResult = await this.initializeGit(projectPath);
-                results.gitInit = initResult.success;
-            }
-            // 2. Create remote repository if requested
-            if (createRemote) {
-                const remoteResult = await this.createRemoteRepository(repo, provider, projectPath);
-                results.remoteCreated = remoteResult.success;
-            }
-            // 3. Apply template
-            const templateResult = await this.applyTemplate(projectPath, template);
-            results.templateApplied = templateResult.success;
-            // 4. Auto-configure if requested
-            if (autoConfigure) {
-                const configResult = await this.autoConfigureProject(projectPath, template, platforms);
-                results.configured = configResult.success;
-            }
-            const allSuccessful = Object.values(results).every(r => r);
-            return {
-                success: allSuccessful,
-                action: 'setup-project',
-                message: `Setup de projeto ${allSuccessful ? 'concluído' : 'com problemas'}`,
-                data: {
-                    repo,
-                    template,
-                    platforms,
-                    results,
-                    implementation: 'SETUP_PROJECT_v2.39.0'
-                }
-            };
-        }
-        catch (error) {
+    async handleInit(params) {
+        const { repo, projectPath, message, createRemote, branch, provider } = params;
+        const gitOps = new git_operations_js_1.GitOperations(projectPath);
+        // Check if already a git repo
+        const isGit = await gitOps.isGitRepository();
+        if (isGit) {
             return {
                 success: false,
-                action: 'setup-project',
-                message: 'Erro no setup de projeto',
-                error: error instanceof Error ? error.message : String(error)
+                action: 'init',
+                message: 'Project is already a Git repository',
+                suggestion: 'Use commit or sync instead'
             };
         }
-    },
-    // Handler para daily-dev
-    async handleDailyDev(params) {
         try {
-            const { projectPath, autoCommit = true, autoPush = true, createBackup = true, runTests = false, checkLint = false } = params;
-            const results = {
-                backup: false,
-                tests: false,
-                lint: false,
-                commit: false,
-                push: false
-            };
-            // 1. Create backup if requested
-            if (createBackup) {
-                const backupResult = await this.createBackup(projectPath);
-                results.backup = backupResult.success;
+            // Initialize git repo
+            const initResult = await gitOps.initRepository();
+            if (!initResult.success) {
+                throw new Error(`Failed to initialize Git repository: ${initResult.error}`);
             }
-            // 2. Run tests if requested
-            if (runTests) {
-                const testResult = await this.runTests(projectPath);
-                results.tests = testResult.success;
+            // Add all files
+            const addResult = await gitOps.addFiles();
+            if (!addResult.success) {
+                throw new Error(`Failed to add files: ${addResult.error}`);
             }
-            // 3. Check lint if requested
-            if (checkLint) {
-                const lintResult = await this.checkLinting(projectPath);
-                results.lint = lintResult.success;
+            // Create initial commit
+            const commitResult = await gitOps.commit(message);
+            if (!commitResult.success) {
+                throw new Error(`Failed to create initial commit: ${commitResult.error}`);
             }
-            // 4. Commit changes if requested
-            if (autoCommit) {
-                const commitResult = await this.smartCommit(projectPath);
-                results.commit = commitResult.success;
-            }
-            // 5. Push if requested
-            if (autoPush && results.commit) {
-                const pushResult = await this.pushChanges(projectPath);
-                results.push = pushResult.success;
+            // Create remote if requested
+            if (createRemote) {
+                const processedInput = await (0, user_detection_js_1.applyAutoUserDetection)({ provider }, provider);
+                if (processedInput.owner) {
+                    const providerInstance = index_js_1.globalProviderFactory.getProvider(provider);
+                    if (providerInstance) {
+                        try {
+                            const remoteResult = await providerInstance.createRepository(repo, `Project initialized via MCP`, false);
+                            const remoteUrl = await providerInstance.getRepositoryUrl(processedInput.owner, repo);
+                            // Add remote
+                            const remoteAddResult = await gitOps.remote('add', 'origin', remoteUrl);
+                            if (remoteAddResult.success) {
+                                // Push to remote
+                                const pushResult = await gitOps.push('origin', branch);
+                                if (pushResult.success) {
+                                    return {
+                                        success: true,
+                                        action: 'init',
+                                        message: `Project initialized with remote repository`,
+                                        data: { remoteUrl, branch, commit: commitResult.output }
+                                    };
+                                }
+                            }
+                        }
+                        catch (remoteError) {
+                            // Remote creation failed, but local repo is ready
+                            console.warn('Remote creation failed:', remoteError);
+                        }
+                    }
+                }
             }
-            const allSuccessful = Object.values(results).filter(r => r !== false).every(r => r);
             return {
-                success: allSuccessful,
-                action: 'daily-dev',
-                message: `Workflow diário ${allSuccessful ? 'concluído' : 'com problemas'}`,
-                data: {
-                    results,
-                    implementation: 'DAILY_DEV_v2.39.0'
-                }
+                success: true,
+                action: 'init',
+                message: 'Project initialized successfully',
+                data: { branch, commit: commitResult.output }
             };
         }
         catch (error) {
-            return {
-                success: false,
-                action: 'daily-dev',
-                message: 'Erro no workflow diário',
-                error: error instanceof Error ? error.message : String(error)
-            };
+            return WorkflowErrorHandler.handleError(error, 'init');
         }
     },
-    // Handler para feature-dev
-    async handleFeatureDev(params) {
+    async handleCommit(params) {
+        const { projectPath, message, addAll, push, branch, provider } = params;
+        const gitOps = new git_operations_js_1.GitOperations(projectPath);
+        // Verify git repo
+        if (!(await gitOps.isGitRepository())) {
+            return WorkflowErrorHandler.handleError(new Error('Not a Git repository'), 'commit');
+        }
         try {
-            const { projectPath, featureName, createBranch = true, baseBranch = 'main', mergeWhenReady = true, runTests = true, createPR = false } = params;
-            const results = {
-                branch: false,
-                tests: false,
-                merge: false,
-                pr: false
-            };
-            // 1. Create feature branch if requested
-            if (createBranch) {
-                const branchResult = await this.createFeatureBranch(projectPath, featureName, baseBranch);
-                results.branch = branchResult.success;
+            // Add files if requested
+            if (addAll) {
+                const addResult = await gitOps.addFiles();
+                if (!addResult.success) {
+                    throw new Error(`Failed to add files: ${addResult.error}`);
+                }
             }
-            // 2. Run tests if requested
-            if (runTests) {
-                const testResult = await this.runTests(projectPath);
-                results.tests = testResult.success;
+            // Check if there are changes to commit
+            const statusResult = await gitOps.status({ porcelain: true });
+            if (!statusResult.output.trim()) {
+                return {
+                    success: false,
+                    action: 'commit',
+                    message: 'No changes to commit',
+                    suggestion: 'Make some changes first'
+                };
             }
-            // 3. Merge when ready if requested
-            if (mergeWhenReady && results.tests) {
-                const mergeResult = await this.mergeFeature(projectPath, featureName, baseBranch);
-                results.merge = mergeResult.success;
+            // Commit
+            const commitResult = await gitOps.commit(message);
+            if (!commitResult.success) {
+                throw new Error(`Commit failed: ${commitResult.error}`);
             }
-            // 4. Create PR if requested
-            if (createPR && results.merge) {
-                const prResult = await this.createPullRequest(projectPath, featureName);
-                results.pr = prResult.success;
+            // Push if requested
+            if (push && provider) {
+                const pushResult = await gitOps.push('origin', branch);
+                if (!pushResult.success) {
+                    return {
+                        success: true,
+                        action: 'commit',
+                        message: 'Commit successful, but push failed',
+                        data: { commit: commitResult.output },
+                        error: pushResult.error,
+                        suggestion: 'Check remote configuration or network connection'
+                    };
+                }
             }
-            const allSuccessful = Object.values(results).filter(r => r !== false).every(r => r);
             return {
-                success: allSuccessful,
-                action: 'feature-dev',
-                message: `Desenvolvimento de feature ${allSuccessful ? 'concluído' : 'com problemas'}`,
-                data: {
-                    featureName,
-                    results,
-                    implementation: 'FEATURE_DEV_v2.39.0'
-                }
+                success: true,
+                action: 'commit',
+                message: push ? 'Commit and push successful' : 'Commit successful',
+                data: { commit: commitResult.output, pushed: push || false }
             };
         }
         catch (error) {
-            return {
-                success: false,
-                action: 'feature-dev',
-                message: 'Erro no desenvolvimento de feature',
-                error: error instanceof Error ? error.message : String(error)
-            };
+            return WorkflowErrorHandler.handleError(error, 'commit');
         }
     },
-    // Handler para release-workflow
-    async handleReleaseWorkflow(params) {
+    async handleSync(params) {
+        const { repo, projectPath, message, branch, forcePush, provider } = params;
+        const gitOps = new git_operations_js_1.GitOperations(projectPath);
         try {
-            const { projectPath, version, platforms = ['npm', 'github'], createTag = true, createRelease = true, updateChangelog = true, runTests = true } = params;
-            const results = {
-                tests: false,
-                changelog: false,
-                tag: false,
-                release: false
-            };
-            // 1. Run tests if requested
-            if (runTests) {
-                const testResult = await this.runTests(projectPath);
-                results.tests = testResult.success;
+            // Pull first
+            const pullResult = await gitOps.pull('origin', branch);
+            if (!pullResult.success && !pullResult.error?.includes('up-to-date')) {
+                console.warn('Pull failed:', pullResult.error);
             }
-            // 2. Update changelog if requested
-            if (updateChangelog) {
-                const changelogResult = await this.updateChangelog(projectPath, version || '1.0.0');
-                results.changelog = changelogResult.success;
+            // Add and commit
+            const addResult = await gitOps.addFiles();
+            if (!addResult.success) {
+                throw new Error(`Failed to add files: ${addResult.error}`);
             }
-            // 3. Create tag if requested
-            if (createTag && results.tests) {
-                const tagResult = await this.createReleaseTag(projectPath, version || '1.0.0');
-                results.tag = tagResult.success;
-            }
-            // 4. Create release if requested
-            if (createRelease && results.tag) {
-                const releaseResult = await this.createRelease(projectPath, version || '1.0.0', platforms);
-                results.release = releaseResult.success;
-            }
-            const allSuccessful = Object.values(results).filter(r => r !== false).every(r => r);
-            return {
-                success: allSuccessful,
-                action: 'release-workflow',
-                message: `Workflow de release ${allSuccessful ? 'concluído' : 'com problemas'}`,
-                data: {
-                    version,
-                    platforms,
-                    results,
-                    implementation: 'RELEASE_WORKFLOW_v2.39.0'
+            const statusResult = await gitOps.status({ porcelain: true });
+            if (statusResult.output.trim()) {
+                const commitResult = await gitOps.commit(message);
+                if (!commitResult.success) {
+                    throw new Error(`Commit failed: ${commitResult.error}`);
                 }
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                action: 'release-workflow',
-                message: 'Erro no workflow de release',
-                error: error instanceof Error ? error.message : String(error)
-            };
-        }
-    },
-    // Handler para cleanup-workflow
-    async handleCleanupWorkflow(params) {
-        try {
-            const { projectPath, removeMergedBranches = true, removeOldBackups = true, optimizeRepository = true, daysOld = 30 } = params;
-            const results = {
-                mergedBranches: false,
-                oldBackups: false,
-                optimization: false
-            };
-            // 1. Remove merged branches if requested
-            if (removeMergedBranches) {
-                const branchResult = await this.removeMergedBranches(projectPath);
-                results.mergedBranches = branchResult.success;
-            }
-            // 2. Remove old backup stashes if requested
-            if (removeOldBackups) {
-                const backupResult = await this.removeOldBackups(projectPath, daysOld);
-                results.oldBackups = backupResult.success;
             }
-            // 3. Optimize repository if requested
-            if (optimizeRepository) {
-                const optimizeResult = await this.optimizeRepository(projectPath);
-                results.optimization = optimizeResult.success;
+            // Push
+            const pushOptions = {};
+            if (forcePush)
+                pushOptions.force = true;
+            const pushResult = await gitOps.push('origin', branch, pushOptions);
+            if (!pushResult.success) {
+                throw new Error(`Push failed: ${pushResult.error}`);
             }
-            const allSuccessful = Object.values(results).filter(r => r !== false).every(r => r);
-            return {
-                success: allSuccessful,
-                action: 'cleanup-workflow',
-                message: `Limpeza de repositório ${allSuccessful ? 'concluída' : 'com problemas'}`,
-                data: {
-                    results,
-                    daysOld,
-                    implementation: 'CLEANUP_WORKFLOW_v2.39.0'
-                }
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                action: 'cleanup-workflow',
-                message: 'Erro na limpeza de repositório',
-                error: error instanceof Error ? error.message : String(error)
-            };
-        }
-    },
-    // Helper methods
-    async initializeGit(projectPath) {
-        try {
-            // TODO: Initialize Git repository
-            return { success: true };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : String(error)
-            };
-        }
-    },
-    async createRemoteRepository(repo, provider, projectPath) {
-        try {
-            // TODO: Create remote repository
-            return { success: true };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : String(error)
-            };
-        }
-    },
-    async applyTemplate(projectPath, template) {
-        try {
-            // TODO: Apply project template
-            return { success: true };
-        }
-        catch (error) {
             return {
-                success: false,
-                error: error instanceof Error ? error.message : String(error)
+                success: true,
+                action: 'sync',
+                message: 'Sync completed successfully',
+                data: { pulled: pullResult.success, pushed: true, branch }
             };
         }
-    },
-    async autoConfigureProject(projectPath, template, platforms) {
-        try {
-            // TODO: Auto-configure project
-            return { success: true };
-        }
         catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : String(error)
-            };
+            return WorkflowErrorHandler.handleError(error, 'sync');
         }
     },
-    async createBackup(projectPath) {
+    async handleStatus(params) {
+        const { projectPath, detailed } = params;
+        const gitOps = new git_operations_js_1.GitOperations(projectPath);
         try {
-            // TODO: Create backup
-            return { success: true };
-        }
-        catch (error) {
+            const statusResult = await gitOps.status(detailed ? {} : { short: true });
+            if (!statusResult.success) {
+                throw new Error(`Status check failed: ${statusResult.error}`);
+            }
             return {
-                success: false,
-                error: error instanceof Error ? error.message : String(error)
+                success: true,
+                action: 'status',
+                message: 'Status retrieved successfully',
+                data: { status: statusResult.output, detailed }
             };
         }
-    },
-    async runTests(projectPath) {
-        try {
-            // TODO: Run test suite
-            return { success: true };
-        }
         catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : String(error)
-            };
+            return WorkflowErrorHandler.handleError(error, 'status');
         }
     },
-    async checkLinting(projectPath) {
+    async handleDiff(params) {
+        const { projectPath, staged, file } = params;
+        const gitOps = new git_operations_js_1.GitOperations(projectPath);
         try {
-            // TODO: Check linting
-            return { success: true };
-        }
-        catch (error) {
+            const diffOptions = { patch: true };
+            if (staged)
+                diffOptions.cached = true;
+            if (file)
+                diffOptions.path = file;
+            const diffResult = await gitOps.diff(diffOptions);
             return {
-                success: false,
-                error: error instanceof Error ? error.message : String(error)
+                success: true,
+                action: 'diff',
+                message: 'Diff retrieved successfully',
+                data: { diff: diffResult.output, staged, file }
             };
         }
-    },
-    async smartCommit(projectPath) {
-        try {
-            // TODO: Smart commit
-            return { success: true };
-        }
         catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : String(error)
-            };
+            return WorkflowErrorHandler.handleError(error, 'diff');
         }
     },
-    async pushChanges(projectPath) {
+    async handleLog(params) {
+        const { projectPath, limit, oneline } = params;
+        const gitOps = new git_operations_js_1.GitOperations(projectPath);
         try {
-            // TODO: Push changes
-            return { success: true };
-        }
-        catch (error) {
+            const logOptions = { maxCount: limit };
+            if (oneline)
+                logOptions.oneline = true;
+            const logResult = await gitOps.log(logOptions);
+            if (!logResult.success) {
+                throw new Error(`Log retrieval failed: ${logResult.error}`);
+            }
             return {
-                success: false,
-                error: error instanceof Error ? error.message : String(error)
+                success: true,
+                action: 'log',
+                message: 'Log retrieved successfully',
+                data: { log: logResult.output, limit, oneline }
             };
         }
-    },
-    async createFeatureBranch(projectPath, featureName, baseBranch) {
-        try {
-            // TODO: Create feature branch
-            return { success: true };
-        }
         catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : String(error)
-            };
+            return WorkflowErrorHandler.handleError(error, 'log');
         }
     },
-    async mergeFeature(projectPath, featureName, baseBranch) {
+    async handleCreateRepo(params) {
+        const { name, description, private: isPrivate, provider } = params;
         try {
-            // TODO: Merge feature
-            return { success: true };
-        }
-        catch (error) {
+            const processedInput = await (0, user_detection_js_1.applyAutoUserDetection)({ provider }, provider);
+            const providerInstance = index_js_1.globalProviderFactory.getProvider(provider);
+            if (!providerInstance) {
+                throw new Error(`Provider ${provider} not configured`);
+            }
+            const repo = await providerInstance.createRepository(name, description || `Repository created via MCP`, isPrivate);
             return {
-                success: false,
-                error: error instanceof Error ? error.message : String(error)
+                success: true,
+                action: 'create-repo',
+                message: 'Repository created successfully',
+                data: {
+                    name,
+                    url: repo.html_url,
+                    clone_url: repo.clone_url,
+                    private: repo.private
+                }
             };
         }
-    },
-    async createPullRequest(projectPath, featureName) {
-        try {
-            // TODO: Create pull request
-            return { success: true };
-        }
         catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : String(error)
-            };
+            return WorkflowErrorHandler.handleError(error, 'create-repo');
         }
     },
-    async updateChangelog(projectPath, version) {
+    async handleCloneRepo(params) {
+        const { name, provider, projectPath, branch } = params;
         try {
-            // TODO: Update changelog
-            return { success: true };
-        }
-        catch (error) {
+            const processedInput = await (0, user_detection_js_1.applyAutoUserDetection)({ provider }, provider);
+            const providerInstance = index_js_1.globalProviderFactory.getProvider(provider);
+            if (!providerInstance) {
+                throw new Error(`Provider ${provider} not configured`);
+            }
+            const repo = await providerInstance.getRepository(processedInput.owner, name);
+            const gitOps = new git_operations_js_1.GitOperations(projectPath);
+            // Clone repository
+            const cloneResult = await gitOps.cloneRepository(repo.clone_url, undefined, { branch });
+            if (!cloneResult.success) {
+                throw new Error(`Clone failed: ${cloneResult.error}`);
+            }
             return {
-                success: false,
-                error: error instanceof Error ? error.message : String(error)
+                success: true,
+                action: 'clone-repo',
+                message: 'Repository cloned successfully',
+                data: {
+                    path: projectPath,
+                    url: repo.clone_url,
+                    branch,
+                    name: repo.name
+                }
             };
         }
-    },
-    async createReleaseTag(projectPath, version) {
-        try {
-            // TODO: Create release tag
-            return { success: true };
-        }
         catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : String(error)
-            };
+            return WorkflowErrorHandler.handleError(error, 'clone-repo');
         }
     },
-    async createRelease(projectPath, version, platforms) {
+    async handlePull(params) {
+        const { projectPath, branch } = params;
+        const gitOps = new git_operations_js_1.GitOperations(projectPath);
         try {
-            // TODO: Create release
-            return { success: true };
-        }
-        catch (error) {
+            const pullResult = await gitOps.pull('origin', branch);
+            if (!pullResult.success && !pullResult.error?.includes('up-to-date')) {
+                throw new Error(`Pull failed: ${pullResult.error}`);
+            }
             return {
-                success: false,
-                error: error instanceof Error ? error.message : String(error)
+                success: true,
+                action: 'pull',
+                message: pullResult.error?.includes('up-to-date') ? 'Already up-to-date' : 'Pull completed successfully',
+                data: { branch, upToDate: pullResult.error?.includes('up-to-date') || false }
             };
         }
-    },
-    async removeMergedBranches(projectPath) {
-        try {
-            // TODO: Remove merged branches
-            return { success: true };
-        }
         catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : String(error)
-            };
+            return WorkflowErrorHandler.handleError(error, 'pull');
         }
     },
-    async removeOldBackups(projectPath, daysOld) {
+    async handlePush(params) {
+        const { projectPath, branch, force } = params;
+        const gitOps = new git_operations_js_1.GitOperations(projectPath);
         try {
-            // TODO: Remove old backup stashes
-            return { success: true };
-        }
-        catch (error) {
+            const pushOptions = {};
+            if (force)
+                pushOptions.force = true;
+            const pushResult = await gitOps.push('origin', branch, pushOptions);
+            if (!pushResult.success) {
+                throw new Error(`Push failed: ${pushResult.error}`);
+            }
             return {
-                success: false,
-                error: error instanceof Error ? error.message : String(error)
+                success: true,
+                action: 'push',
+                message: 'Push completed successfully',
+                data: { branch, force }
             };
         }
-    },
-    async optimizeRepository(projectPath) {
-        try {
-            // TODO: Optimize repository
-            return { success: true };
-        }
         catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : String(error)
-            };
+            return WorkflowErrorHandler.handleError(error, 'push');
         }
     }
 };