@andrebuzeli/git-mcp 2.42.0 → 2.43.0

package/dist/tools/git-update-project.js

@@ -6,6 +6,18 @@ 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");
 const GitUpdateProjectInputSchema = zod_1.z.discriminatedUnion('action', [
+    // Action: init - upload inicial completo (substitui upload-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'),
+        branch: zod_1.z.string().optional(),
+        createRepo: zod_1.z.boolean().optional(),
+        forcePush: zod_1.z.boolean().optional(),
+        granular: zod_1.z.boolean().optional() // commits granulares por tipo de arquivo
+    }),
     // Action: update - commit incremental
     zod_1.z.object({
         action: zod_1.z.literal('update'),
@@ -38,6 +50,13 @@ const GitUpdateProjectInputSchema = zod_1.z.discriminatedUnion('action', [
         oneline: zod_1.z.boolean().optional(),
         branch: zod_1.z.string().optional()
     }),
+    // Action: reset - desfazer mudanças
+    zod_1.z.object({
+        action: zod_1.z.literal('reset'),
+        projectPath: zod_1.z.string(),
+        mode: zod_1.z.enum(['soft', 'mixed', 'hard']).optional(),
+        commit: zod_1.z.string().optional()
+    }),
     // Action: stash - gerenciar mudanças temporárias
     zod_1.z.object({
         action: zod_1.z.literal('stash'),
@@ -60,18 +79,6 @@ const GitUpdateProjectInputSchema = zod_1.z.discriminatedUnion('action', [
         message: zod_1.z.string().min(1, 'Commit message is required'),
         branch: zod_1.z.string().optional(),
         forcePush: zod_1.z.boolean().optional()
-    }),
-    // Action: init - upload inicial completo (substitui upload-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'),
-        branch: zod_1.z.string().optional(),
-        createRepo: zod_1.z.boolean().optional(),
-        forcePush: zod_1.z.boolean().optional(),
-        granular: zod_1.z.boolean().optional() // commits granulares por tipo de arquivo
     })
 ]);
 const GitUpdateProjectResultSchema = zod_1.z.object({
@@ -83,13 +90,13 @@ const GitUpdateProjectResultSchema = zod_1.z.object({
 });
 exports.gitUpdateProjectTool = {
     name: 'git-update-project',
-    description: 'tool: Gerenciamento COMPLETO de projetos Git (local + remoto)\\n──────────────\\n8 ACTIONS DISPONÍVEIS:\\n• init: UPLOAD INICIAL completo (substitui upload-project)\\n• update: Commit incremental automático\\n• status: Verificar status do repositório\\n• diff: Mostrar diferenças entre versões\\n• log: Histórico de commits\\n• stash: Gerenciar mudanças temporárias\\n• pull: Atualizar do repositório remoto\\n• sync: Sincronização completa (pull+commit+push)\\n───────────────\\nCOMMITS REAIS + RASTREABILIDADE TOTAL\\nFunciona com GitHub, Gitea e qualquer repositório Git',
+    description: 'tool: Gerenciamento COMPLETO de projetos Git (local + remoto)\\n──────────────\\n9 ACTIONS DISPONÍVEIS:\\n• init: UPLOAD INICIAL completo (substitui upload-project)\\n• update: Commit incremental automático\\n• status: Verificar status do repositório\\n• diff: Mostrar diferenças entre versões\\n• log: Histórico de commits\\n• reset: Desfazer mudanças\\n• stash: Gerenciar mudanças temporárias\\n• pull: Atualizar do repositório remoto\\n• sync: Sincronização completa (pull+commit+push)\\n───────────────\\nCOMMITS REAIS + RASTREABILIDADE TOTAL\\nFunciona com GitHub, Gitea e qualquer repositório Git',
     inputSchema: {
         type: 'object',
         properties: {
             action: {
                 type: 'string',
-                enum: ['init', 'update', 'status', 'diff', 'log', 'stash', 'pull', 'sync'],
+                enum: ['init', 'update', 'status', 'diff', 'log', 'reset', 'stash', 'pull', 'sync'],
                 description: 'Action to perform'
             },
             // Parâmetros comuns
@@ -108,6 +115,7 @@ exports.gitUpdateProjectTool = {
             commit: { type: 'string', description: 'Target commit for reset/diff' },
             maxCount: { type: 'number', description: 'Max commits for log', default: 10 },
             oneline: { type: 'boolean', description: 'One line format for log', default: true },
+            mode: { type: 'string', enum: ['soft', 'mixed', 'hard'], description: 'Reset mode', default: 'mixed' },
             operation: { type: 'string', enum: ['save', 'pop', 'apply', 'list', 'drop', 'clear'], description: 'Stash operation', default: 'save' }
         },
         required: ['action', 'projectPath']
@@ -127,6 +135,8 @@ exports.gitUpdateProjectTool = {
                     return await this.handleDiff(validatedInput);
                 case 'log':
                     return await this.handleLog(validatedInput);
+                case 'reset':
+                    return await this.handleReset(validatedInput);
                 case 'stash':
                     return await this.handleStash(validatedInput);
                 case 'pull':
@@ -276,26 +286,194 @@ exports.gitUpdateProjectTool = {
             };
         }
     },
+    // Action: init - upload inicial completo (substitui upload-project)
+    async handleInit(params) {
+        try {
+            const { repo, projectPath, message, branch = 'main', forcePush = false, createRepo = false, granular = false, provider: providerName } = params;
+            const gitOps = new git_operations_js_1.GitOperations(projectPath);
+            // Aplicar auto-detecção de usuário
+            const processedInput = await (0, user_detection_js_1.applyAutoUserDetection)(params, providerName);
+            const provider = index_js_1.globalProviderFactory.getProvider(processedInput.provider);
+            if (!provider) {
+                throw new Error(`Provider '${providerName}' não encontrado`);
+            }
+            const currentUser = await provider.getCurrentUser();
+            const owner = currentUser.login;
+            // 1. Inicializar repositório Git local se necessário
+            const isGitRepo = await gitOps.isGitRepository();
+            if (!isGitRepo) {
+                const initResult = await gitOps.initRepository();
+                if (!initResult.success) {
+                    throw new Error(`Falha ao inicializar repositório Git: ${initResult.error}`);
+                }
+            }
+            // 2. Verificar/criar repositório remoto
+            let repoExists = true;
+            try {
+                await provider.getRepository(owner, repo);
+            }
+            catch (error) {
+                repoExists = false;
+                if (createRepo) {
+                    try {
+                        await provider.createRepository(repo, `Projeto ${repo}`, false);
+                        repoExists = true;
+                    }
+                    catch (createError) {
+                        console.warn(`Aviso: Não foi possível criar repositório: ${createError instanceof Error ? createError.message : String(createError)}`);
+                    }
+                }
+                else {
+                    throw new Error(`Repositório '${repo}' não existe. Use createRepo: true para criar automaticamente.`);
+                }
+            }
+            // 3. Preparar arquivos para commit
+            let filesCommitted = 0;
+            let commitsCreated = 0;
+            if (granular) {
+                // Commits granulares por tipo de arquivo (melhor rastreabilidade)
+                const fileGroups = await this.groupFilesByType(projectPath);
+                for (const [fileType, files] of Object.entries(fileGroups)) {
+                    if (files.length > 0) {
+                        // Adicionar arquivos do tipo específico
+                        const addResult = await gitOps.addFiles(files);
+                        if (addResult.success) {
+                            // Verificar se há mudanças para commitar
+                            const statusResult = await gitOps.status({ porcelain: true });
+                            if (statusResult.success && statusResult.output.trim()) {
+                                const commitResult = await gitOps.commit(`${message} - ${fileType} files`);
+                                if (commitResult.success) {
+                                    commitsCreated++;
+                                    filesCommitted += files.length;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            else {
+                // Commit único de todos os arquivos (como upload-project)
+                const addResult = await gitOps.addFiles(['.']);
+                if (addResult.success) {
+                    const statusResult = await gitOps.status({ porcelain: true });
+                    if (statusResult.success && statusResult.output.trim()) {
+                        const commitResult = await gitOps.commit(message);
+                        if (commitResult.success) {
+                            commitsCreated++;
+                            filesCommitted = statusResult.output.trim().split('\n').length;
+                        }
+                    }
+                }
+            }
+            // 4. Configurar e fazer push para remote
+            let pushSuccessful = false;
+            const remoteUrl = provider.getRepositoryUrl(owner, repo);
+            // Configurar remote origin
+            const remoteResult = await gitOps.remote('show', 'origin');
+            if (!remoteResult.success) {
+                const addRemoteResult = await gitOps.remote('add', 'origin', remoteUrl);
+                if (!addRemoteResult.success && !addRemoteResult.error?.includes('already exists')) {
+                    console.warn(`Aviso: Falha ao adicionar remote: ${addRemoteResult.error}`);
+                }
+            }
+            else {
+                // Atualizar URL se necessário
+                const setUrlResult = await gitOps.remote('set-url', 'origin', remoteUrl);
+                if (!setUrlResult.success) {
+                    console.warn(`Aviso: Falha ao atualizar remote URL: ${setUrlResult.error}`);
+                }
+            }
+            // Fazer push
+            if (commitsCreated > 0) {
+                try {
+                    const pushOptions = { setUpstream: true };
+                    if (forcePush)
+                        pushOptions.force = true;
+                    const pushResult = await gitOps.push('origin', branch, pushOptions);
+                    pushSuccessful = pushResult.success;
+                    if (!pushSuccessful) {
+                        console.warn(`Aviso: Push falhou: ${pushResult.error}`);
+                    }
+                }
+                catch (pushErr) {
+                    console.warn(`Aviso: Erro no push: ${pushErr instanceof Error ? pushErr.message : String(pushErr)}`);
+                }
+            }
+            return {
+                success: true,
+                action: 'init',
+                message: `Upload inicial concluído com ${commitsCreated} commit(s) e ${filesCommitted} arquivo(s)`,
+                data: {
+                    repo,
+                    branch,
+                    provider: providerName,
+                    owner,
+                    remoteUrl,
+                    repositoryCreated: !repoExists && createRepo,
+                    gitInit: !isGitRepo,
+                    commitsCreated,
+                    filesCommitted,
+                    pushSuccessful,
+                    granular,
+                    implementation: 'REAL_GIT_OPERATIONS_v2.40.0',
+                    note: granular ?
+                        'Commits granulares criados por tipo de arquivo para melhor rastreabilidade' :
+                        'Commit único criado (como upload-project original)'
+                }
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                action: 'init',
+                message: 'Erro no upload inicial do projeto',
+                error: error instanceof Error ? error.message : String(error)
+            };
+        }
+    },
     // Action: status - verificar status do repositório
     async handleStatus(params) {
         try {
             const { projectPath, detailed = false } = params;
             const gitOps = new git_operations_js_1.GitOperations(projectPath);
+            // Verificar se é um repositório Git
             const isGitRepo = await gitOps.isGitRepository();
-            if (!isGitRepo)
-                throw new Error(`Diretório não é um repositório Git válido`);
+            if (!isGitRepo) {
+                throw new Error(`Diretório '${projectPath}' não é um repositório Git válido`);
+            }
+            // Obter status detalhado
             const statusResult = await gitOps.status({ porcelain: false });
-            if (!statusResult.success)
+            if (!statusResult.success) {
                 throw new Error(`Falha ao obter status: ${statusResult.error}`);
+            }
+            // Obter branch atual
             const branchResult = await gitOps.getCurrentBranch();
             const currentBranch = branchResult.success ? branchResult.output.trim() : 'unknown';
+            // Contar mudanças
             const porcelainResult = await gitOps.status({ porcelain: true });
             const changes = porcelainResult.success ? porcelainResult.output.trim() : '';
             const filesChanged = changes ? changes.split('\n').filter(line => line.trim().length > 0).length : 0;
-            return { success: true, action: 'status', message: 'Status obtido', data: { currentBranch, filesChanged, hasChanges: filesChanged > 0, statusOutput: detailed ? statusResult.output : statusResult.output.split('\n').slice(0, 10).join('\n'), implementation: 'REAL_GIT_OPERATIONS_v2.38.0', detailed } };
+            return {
+                success: true,
+                action: 'status',
+                message: `Status do repositório obtido com sucesso`,
+                data: {
+                    currentBranch,
+                    filesChanged,
+                    hasChanges: filesChanged > 0,
+                    statusOutput: detailed ? statusResult.output : statusResult.output.split('\n').slice(0, 10).join('\n'),
+                    implementation: 'REAL_GIT_OPERATIONS_v2.38.0',
+                    detailed
+                }
+            };
         }
         catch (error) {
-            return { success: false, action: 'status', message: 'Erro status', error: error instanceof Error ? error.message : String(error) };
+            return {
+                success: false,
+                action: 'status',
+                message: 'Erro ao verificar status do repositório',
+                error: error instanceof Error ? error.message : String(error)
+            };
         }
     },
     // Action: diff - mostrar diferenças
@@ -303,9 +481,11 @@ exports.gitUpdateProjectTool = {
         try {
             const { projectPath, staged = false, nameOnly = false, commit } = params;
             const gitOps = new git_operations_js_1.GitOperations(projectPath);
+            // Verificar se é um repositório Git
             const isGitRepo = await gitOps.isGitRepository();
-            if (!isGitRepo)
-                throw new Error(`Diretório não é um repositório Git válido`);
+            if (!isGitRepo) {
+                throw new Error(`Diretório '${projectPath}' não é um repositório Git válido`);
+            }
             const diffOptions = {};
             if (staged)
                 diffOptions.cached = true;
@@ -314,13 +494,31 @@ exports.gitUpdateProjectTool = {
             if (commit)
                 diffOptions.commit = commit;
             const diffResult = await gitOps.diff(diffOptions);
-            if (!diffResult.success && diffResult.error)
-                throw new Error(`Falha diff: ${diffResult.error}`);
+            if (!diffResult.success && diffResult.error) {
+                throw new Error(`Falha ao obter diferenças: ${diffResult.error}`);
+            }
             const hasDifferences = diffResult.output.trim().length > 0;
-            return { success: true, action: 'diff', message: hasDifferences ? 'Diferenças encontradas' : 'Sem diferenças', data: { hasDifferences, diffOutput: diffResult.output, staged, nameOnly, commit: commit || 'HEAD', implementation: 'REAL_GIT_OPERATIONS_v2.38.0' } };
+            return {
+                success: true,
+                action: 'diff',
+                message: hasDifferences ? 'Diferenças encontradas' : 'Nenhuma diferença encontrada',
+                data: {
+                    hasDifferences,
+                    diffOutput: diffResult.output,
+                    staged,
+                    nameOnly,
+                    commit: commit || 'HEAD',
+                    implementation: 'REAL_GIT_OPERATIONS_v2.38.0'
+                }
+            };
         }
         catch (error) {
-            return { success: false, action: 'diff', message: 'Erro diff', error: error instanceof Error ? error.message : String(error) };
+            return {
+                success: false,
+                action: 'diff',
+                message: 'Erro ao obter diferenças',
+                error: error instanceof Error ? error.message : String(error)
+            };
         }
     },
     // Action: log - histórico de commits
@@ -328,9 +526,12 @@ exports.gitUpdateProjectTool = {
         try {
             const { projectPath, maxCount = 10, oneline = true, branch } = params;
             const gitOps = new git_operations_js_1.GitOperations(projectPath);
+            // Verificar se é um repositório Git
             const isGitRepo = await gitOps.isGitRepository();
-            if (!isGitRepo)
-                throw new Error(`Diretório não é um repositório Git válido`);
+            if (!isGitRepo) {
+                throw new Error(`Diretório '${projectPath}' não é um repositório Git válido`);
+            }
+            // Obter histórico de commits
             const logOptions = {};
             if (maxCount)
                 logOptions.maxCount = maxCount;
@@ -339,14 +540,32 @@ exports.gitUpdateProjectTool = {
             if (branch)
                 logOptions.branches = [branch];
             const logResult = await gitOps.log(logOptions);
-            if (!logResult.success)
-                throw new Error(`Falha log: ${logResult.error}`);
+            if (!logResult.success) {
+                throw new Error(`Falha ao obter histórico: ${logResult.error}`);
+            }
             const commits = logResult.output.trim();
             const commitCount = commits ? commits.split('\n').filter(line => line.trim().length > 0).length : 0;
-            return { success: true, action: 'log', message: `${commitCount} commits`, data: { commits: commits || 'Sem commits', commitCount, maxCount, oneline, branch: branch || 'all', implementation: 'REAL_GIT_OPERATIONS_v2.38.0' } };
+            return {
+                success: true,
+                action: 'log',
+                message: `${commitCount} commits encontrados no histórico`,
+                data: {
+                    commits: commits || 'Nenhum commit encontrado',
+                    commitCount,
+                    maxCount,
+                    oneline,
+                    branch: branch || 'all',
+                    implementation: 'REAL_GIT_OPERATIONS_v2.38.0'
+                }
+            };
         }
         catch (error) {
-            return { success: false, action: 'log', message: 'Erro log', error: error instanceof Error ? error.message : String(error) };
+            return {
+                success: false,
+                action: 'log',
+                message: 'Erro ao obter histórico de commits',
+                error: error instanceof Error ? error.message : String(error)
+            };
         }
     },
     // Action: reset - desfazer mudanças
@@ -354,18 +573,37 @@ exports.gitUpdateProjectTool = {
         try {
             const { projectPath, mode = 'mixed', commit } = params;
             const gitOps = new git_operations_js_1.GitOperations(projectPath);
+            // Verificar se é um repositório Git
             const isGitRepo = await gitOps.isGitRepository();
-            if (!isGitRepo)
-                throw new Error(`Diretório não é um repositório Git válido`);
+            if (!isGitRepo) {
+                throw new Error(`Diretório '${projectPath}' não é um repositório Git válido`);
+            }
+            // Executar reset
             const target = commit || 'HEAD';
             const resetOptions = { mode };
             const resetResult = await gitOps.reset(target, resetOptions);
-            if (!resetResult.success)
-                throw new Error(`Falha reset: ${resetResult.error}`);
-            return { success: true, action: 'reset', message: `Reset ${mode} executado`, data: { mode, targetCommit: target, resetOutput: resetResult.output, implementation: 'REAL_GIT_OPERATIONS_v2.38.0' } };
+            if (!resetResult.success) {
+                throw new Error(`Falha no reset: ${resetResult.error}`);
+            }
+            return {
+                success: true,
+                action: 'reset',
+                message: `Reset ${mode} executado com sucesso`,
+                data: {
+                    mode,
+                    targetCommit: target,
+                    resetOutput: resetResult.output,
+                    implementation: 'REAL_GIT_OPERATIONS_v2.38.0'
+                }
+            };
         }
         catch (error) {
-            return { success: false, action: 'reset', message: 'Erro reset', error: error instanceof Error ? error.message : String(error) };
+            return {
+                success: false,
+                action: 'reset',
+                message: 'Erro ao executar reset',
+                error: error instanceof Error ? error.message : String(error)
+            };
         }
     },
     // Action: stash - gerenciar mudanças temporárias
@@ -373,9 +611,11 @@ exports.gitUpdateProjectTool = {
         try {
             const { projectPath, operation = 'save', message } = params;
             const gitOps = new git_operations_js_1.GitOperations(projectPath);
+            // Verificar se é um repositório Git
             const isGitRepo = await gitOps.isGitRepository();
-            if (!isGitRepo)
-                throw new Error(`Diretório não é um repositório Git válido`);
+            if (!isGitRepo) {
+                throw new Error(`Diretório '${projectPath}' não é um repositório Git válido`);
+            }
             let stashResult;
             switch (operation) {
                 case 'save':
@@ -396,14 +636,31 @@ exports.gitUpdateProjectTool = {
                 case 'clear':
                     stashResult = await gitOps.stash('clear');
                     break;
-                default: throw new Error(`Operação stash '${operation}' não suportada`);
+                default:
+                    throw new Error(`Operação de stash '${operation}' não suportada`);
+            }
+            if (!stashResult.success) {
+                throw new Error(`Falha na operação stash ${operation}: ${stashResult.error}`);
             }
-            if (!stashResult.success)
-                throw new Error(`Falha stash ${operation}: ${stashResult.error}`);
-            return { success: true, action: 'stash', message: `Stash ${operation} executado`, data: { operation, message: message || undefined, stashOutput: stashResult.output, implementation: 'REAL_GIT_OPERATIONS_v2.38.0' } };
+            return {
+                success: true,
+                action: 'stash',
+                message: `Operação stash '${operation}' executada com sucesso`,
+                data: {
+                    operation,
+                    message: message || undefined,
+                    stashOutput: stashResult.output,
+                    implementation: 'REAL_GIT_OPERATIONS_v2.38.0'
+                }
+            };
         }
         catch (error) {
-            return { success: false, action: 'stash', message: 'Erro stash', error: error instanceof Error ? error.message : String(error) };
+            return {
+                success: false,
+                action: 'stash',
+                message: 'Erro na operação de stash',
+                error: error instanceof Error ? error.message : String(error)
+            };
         }
     },
     // Action: pull - atualizar do remoto
@@ -411,173 +668,161 @@ exports.gitUpdateProjectTool = {
         try {
             const { projectPath, branch } = params;
             const gitOps = new git_operations_js_1.GitOperations(projectPath);
+            // Verificar se é um repositório Git
             const isGitRepo = await gitOps.isGitRepository();
-            if (!isGitRepo)
-                throw new Error(`Diretório não é um repositório Git válido`);
+            if (!isGitRepo) {
+                throw new Error(`Diretório '${projectPath}' não é um repositório Git válido`);
+            }
+            // Executar pull
             const pullResult = await gitOps.pull('origin', branch);
-            if (!pullResult.success)
-                throw new Error(`Falha pull: ${pullResult.error}`);
-            return { success: true, action: 'pull', message: 'Pull executado', data: { remote: 'origin', branch: branch || 'current', pullOutput: pullResult.output, implementation: 'REAL_GIT_OPERATIONS_v2.38.0' } };
+            if (!pullResult.success) {
+                throw new Error(`Falha no pull: ${pullResult.error}`);
+            }
+            return {
+                success: true,
+                action: 'pull',
+                message: `Pull do remoto executado com sucesso`,
+                data: {
+                    remote: 'origin',
+                    branch: branch || 'current',
+                    pullOutput: pullResult.output,
+                    implementation: 'REAL_GIT_OPERATIONS_v2.38.0'
+                }
+            };
         }
         catch (error) {
-            return { success: false, action: 'pull', message: 'Erro pull', error: error instanceof Error ? error.message : String(error) };
+            return {
+                success: false,
+                action: 'pull',
+                message: 'Erro ao executar pull',
+                error: error instanceof Error ? error.message : String(error)
+            };
         }
     },
-    // Action: sync - sincronização completa
+    // Action: sync - sincronização completa (pull + commit + push)
     async handleSync(params) {
         try {
             const { repo, projectPath, message, branch = 'main', forcePush = false, provider: providerName } = params;
             const gitOps = new git_operations_js_1.GitOperations(projectPath);
+            // Verificar se é um repositório Git
             const isGitRepo = await gitOps.isGitRepository();
-            if (!isGitRepo)
-                throw new Error(`Diretório não é um repositório Git válido`);
-            const syncResults = { pull: { success: false, output: '', error: '' }, commit: { success: false, output: '', error: '', created: false }, push: { success: false, output: '', error: '' } };
+            if (!isGitRepo) {
+                throw new Error(`Diretório '${projectPath}' não é um repositório Git válido`);
+            }
+            const syncResults = {
+                pull: { success: false, output: '', error: '' },
+                commit: { success: false, output: '', error: '', created: false },
+                push: { success: false, output: '', error: '' }
+            };
+            // 1. Pull do remoto
             try {
                 const pullResult = await gitOps.pull('origin', branch);
-                syncResults.pull = { success: pullResult.success, output: pullResult.output, error: pullResult.error || '' };
+                syncResults.pull = {
+                    success: pullResult.success,
+                    output: pullResult.output,
+                    error: pullResult.error || ''
+                };
             }
             catch (pullErr) {
                 syncResults.pull.error = pullErr instanceof Error ? pullErr.message : String(pullErr);
             }
+            // 2. Verificar se há mudanças após pull
             const statusResult = await gitOps.status({ porcelain: true });
             const hasChanges = statusResult.success && statusResult.output.trim().length > 0;
             if (hasChanges) {
+                // Fazer commit das mudanças
                 const addResult = await gitOps.addFiles(['.']);
                 if (addResult.success) {
                     const commitResult = await gitOps.commit(message);
-                    syncResults.commit = { success: commitResult.success, output: commitResult.output, error: commitResult.error || '', created: commitResult.success };
+                    syncResults.commit = {
+                        success: commitResult.success,
+                        output: commitResult.output,
+                        error: commitResult.error || '',
+                        created: commitResult.success
+                    };
                 }
                 else {
-                    syncResults.commit.error = `Falha add: ${addResult.error}`;
+                    syncResults.commit.error = `Falha ao adicionar arquivos: ${addResult.error}`;
                 }
             }
+            // 3. Push se commit foi criado
             if (syncResults.commit.created) {
                 try {
                     const pushOptions = {};
                     if (forcePush)
                         pushOptions.force = true;
                     const pushResult = await gitOps.push('origin', branch, pushOptions);
-                    syncResults.push = { success: pushResult.success, output: pushResult.output, error: pushResult.error || '' };
+                    syncResults.push = {
+                        success: pushResult.success,
+                        output: pushResult.output,
+                        error: pushResult.error || ''
+                    };
                 }
                 catch (pushErr) {
                     syncResults.push.error = pushErr instanceof Error ? pushErr.message : String(pushErr);
                 }
             }
             const overallSuccess = syncResults.pull.success && (!hasChanges || syncResults.commit.success);
-            return { success: overallSuccess, action: 'sync', message: `Sincronização ${overallSuccess ? 'concluída' : 'problemas'}`, data: { repo, branch, provider: providerName, syncResults, hasChanges, implementation: 'REAL_GIT_OPERATIONS_v2.38.0', summary: { pullSuccessful: syncResults.pull.success, commitCreated: syncResults.commit.created, pushSuccessful: syncResults.push.success } } };
-        }
-        catch (error) {
-            return { success: false, action: 'sync', message: 'Erro sync', error: error instanceof Error ? error.message : String(error) };
-        }
-    },
-    // Action: init - upload inicial completo
-    async handleInit(params) {
-        try {
-            const { repo, projectPath, message, branch = 'main', forcePush = false, createRepo = false, granular = false, provider: providerName } = params;
-            const gitOps = new git_operations_js_1.GitOperations(projectPath);
-            const processedInput = await (0, user_detection_js_1.applyAutoUserDetection)(params, providerName);
-            const provider = index_js_1.globalProviderFactory.getProvider(processedInput.provider);
-            if (!provider)
-                throw new Error(`Provider '${providerName}' não encontrado`);
-            const currentUser = await provider.getCurrentUser();
-            const owner = currentUser.login;
-            const isGitRepo = await gitOps.isGitRepository();
-            if (!isGitRepo) {
-                const initResult = await gitOps.initRepository();
-                if (!initResult.success)
-                    throw new Error(`Falha init: ${initResult.error}`);
-            }
-            let repoExists = true;
-            try {
-                await provider.getRepository(owner, repo);
-            }
-            catch (error) {
-                repoExists = false;
-                if (createRepo) {
-                    try {
-                        await provider.createRepository(repo, `Projeto ${repo}`, false);
-                        repoExists = true;
-                    }
-                    catch (createError) {
-                        console.warn(`Aviso: Falha criar repo: ${createError instanceof Error ? createError.message : String(createError)}`);
-                    }
-                }
-                else {
-                    throw new Error(`Repositório '${repo}' não existe. Use createRepo: true.`);
-                }
-            }
-            let filesCommitted = 0;
-            let commitsCreated = 0;
-            const remoteUrl = provider.getRepositoryUrl(owner, repo);
-            if (granular) {
-                const fileGroups = await this.groupFilesByType(projectPath);
-                for (const [fileType, files] of Object.entries(fileGroups)) {
-                    if (files.length > 0) {
-                        const addResult = await gitOps.addFiles(files);
-                        if (addResult.success) {
-                            const statusResult = await gitOps.status({ porcelain: true });
-                            if (statusResult.success && statusResult.output.trim()) {
-                                const commitResult = await gitOps.commit(`${message} - ${fileType} files`);
-                                if (commitResult.success) {
-                                    commitsCreated++;
-                                    filesCommitted += files.length;
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-            else {
-                const addResult = await gitOps.addFiles(['.']);
-                if (addResult.success) {
-                    const statusResult = await gitOps.status({ porcelain: true });
-                    if (statusResult.success && statusResult.output.trim()) {
-                        const commitResult = await gitOps.commit(message);
-                        if (commitResult.success) {
-                            commitsCreated++;
-                            filesCommitted = statusResult.output.trim().split('\n').length;
-                        }
+            return {
+                success: overallSuccess,
+                action: 'sync',
+                message: `Sincronização ${overallSuccess ? 'concluída' : 'com problemas'}`,
+                data: {
+                    repo,
+                    branch,
+                    provider: providerName,
+                    syncResults,
+                    hasChanges,
+                    implementation: 'REAL_GIT_OPERATIONS_v2.38.0',
+                    summary: {
+                        pullSuccessful: syncResults.pull.success,
+                        commitCreated: syncResults.commit.created,
+                        pushSuccessful: syncResults.push.success
                     }
                 }
-            }
-            let pushSuccessful = false;
-            if (commitsCreated > 0) {
-                try {
-                    const pushOptions = { setUpstream: true };
-                    if (forcePush)
-                        pushOptions.force = true;
-                    const pushResult = await gitOps.push('origin', branch, pushOptions);
-                    pushSuccessful = pushResult.success;
-                }
-                catch (pushErr) {
-                    console.warn(`Aviso push: ${pushErr instanceof Error ? pushErr.message : String(pushErr)}`);
-                }
-            }
-            return { success: true, action: 'init', message: `Upload concluído: ${commitsCreated} commits, ${filesCommitted} arquivos`, data: { repo, branch, provider: providerName, owner, remoteUrl, repositoryCreated: !repoExists && createRepo, gitInit: !isGitRepo, commitsCreated, filesCommitted, pushSuccessful, granular, implementation: 'REAL_GIT_OPERATIONS_v2.40.0', note: granular ? 'Commits granulares por tipo' : 'Commit único' } };
+            };
         }
         catch (error) {
-            return { success: false, action: 'init', message: 'Erro init', error: error instanceof Error ? error.message : String(error) };
+            return {
+                success: false,
+                action: 'sync',
+                message: 'Erro na sincronização completa',
+                error: error instanceof Error ? error.message : String(error)
+            };
         }
     },
+    // Helper method para agrupar arquivos por tipo
     async groupFilesByType(projectPath) {
         const gitOps = new git_operations_js_1.GitOperations(projectPath);
         const statusResult = await gitOps.status({ porcelain: true });
-        if (!statusResult.success)
+        if (!statusResult.success) {
             return {};
+        }
         const lines = statusResult.output.trim().split('\n').filter(line => line.trim());
-        const fileGroups = { 'config': [], 'source': [], 'documentation': [], 'assets': [], 'other': [] };
+        const fileGroups = {
+            'config': [],
+            'source': [],
+            'documentation': [],
+            'assets': [],
+            'other': []
+        };
         for (const line of lines) {
+            // Extrair nome do arquivo (remover status indicators)
             const fileName = line.substring(3).trim();
-            if (fileName.includes('package.json') || fileName.includes('.config.') || fileName.includes('tsconfig') || fileName.includes('.env')) {
+            if (fileName.includes('package.json') || fileName.includes('.config.') ||
+                fileName.includes('tsconfig') || fileName.includes('.env')) {
                 fileGroups.config.push(fileName);
             }
-            else if (fileName.endsWith('.ts') || fileName.endsWith('.js') || fileName.endsWith('.py') || fileName.endsWith('.java')) {
+            else if (fileName.endsWith('.ts') || fileName.endsWith('.js') ||
+                fileName.endsWith('.py') || fileName.endsWith('.java')) {
                 fileGroups.source.push(fileName);
             }
-            else if (fileName.endsWith('.md') || fileName.endsWith('.txt') || fileName.includes('README') || fileName.includes('LICENSE')) {
+            else if (fileName.endsWith('.md') || fileName.endsWith('.txt') ||
+                fileName.includes('README') || fileName.includes('LICENSE')) {
                 fileGroups.documentation.push(fileName);
             }
-            else if (fileName.endsWith('.png') || fileName.endsWith('.jpg') || fileName.endsWith('.svg') || fileName.endsWith('.css')) {
+            else if (fileName.endsWith('.png') || fileName.endsWith('.jpg') ||
+                fileName.endsWith('.svg') || fileName.endsWith('.css')) {
                 fileGroups.assets.push(fileName);
             }
             else {