@andrebuzeli/git-mcp 2.40.0 → 2.42.0

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

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.gitUpdateProjectTool = 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");
 const GitUpdateProjectInputSchema = zod_1.z.discriminatedUnion('action', [
     // Action: update - commit incremental
@@ -36,13 +38,6 @@ 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'),
@@ -65,6 +60,18 @@ 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({
@@ -76,30 +83,31 @@ const GitUpdateProjectResultSchema = zod_1.z.object({
 });
 exports.gitUpdateProjectTool = {
     name: 'git-update-project',
-    description: 'tool: Gerenciamento completo de projetos Git locais\\n──────────────\\n8 ACTIONS DISPONÍVEIS:\\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: Todas operações funcionam localmente\\nFunciona com GitHub, Gitea e qualquer repositório Git',
+    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',
     inputSchema: {
         type: 'object',
         properties: {
             action: {
                 type: 'string',
-                enum: ['update', 'status', 'diff', 'log', 'reset', 'stash', 'pull', 'sync'],
+                enum: ['init', 'update', 'status', 'diff', 'log', 'stash', 'pull', 'sync'],
                 description: 'Action to perform'
             },
             // Parâmetros comuns
-            repo: { type: 'string', description: 'Repository name (required for update/sync)' },
+            repo: { type: 'string', description: 'Repository name (required for init/update/sync)' },
             projectPath: { type: 'string', description: 'Local project path (required for all)' },
-            provider: { type: 'string', enum: ['gitea', 'github'], description: 'Provider (required for update/sync)' },
+            provider: { type: 'string', enum: ['gitea', 'github'], description: 'Provider (required for init/update/sync)' },
             // Parâmetros específicos
-            message: { type: 'string', description: 'Commit message (required for update/sync)' },
+            message: { type: 'string', description: 'Commit message (required for init/update/sync)' },
             branch: { type: 'string', description: 'Branch name', default: 'main' },
             forcePush: { type: 'boolean', description: 'Force push', default: false },
+            createRepo: { type: 'boolean', description: 'Create remote repository if not exists', default: false },
+            granular: { type: 'boolean', description: 'Create granular commits by file type for init', default: false },
             detailed: { type: 'boolean', description: 'Detailed output for status', default: false },
             staged: { type: 'boolean', description: 'Show staged changes for diff', default: false },
             nameOnly: { type: 'boolean', description: 'Show only filenames for diff', default: false },
             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']
@@ -109,6 +117,8 @@ exports.gitUpdateProjectTool = {
             const validatedInput = GitUpdateProjectInputSchema.parse(input);
             // Roteamento baseado na action
             switch (validatedInput.action) {
+                case 'init':
+                    return await this.handleInit(validatedInput);
                 case 'update':
                     return await this.handleUpdate(validatedInput);
                 case 'status':
@@ -117,8 +127,6 @@ 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':
@@ -273,44 +281,21 @@ exports.gitUpdateProjectTool = {
         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 '${projectPath}' não é um repositório Git válido`);
-            }
-            // Obter status detalhado
+            if (!isGitRepo)
+                throw new Error(`Diretório não é um repositório Git válido`);
             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 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
-                }
-            };
+            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 } };
         }
         catch (error) {
-            return {
-                success: false,
-                action: 'status',
-                message: 'Erro ao verificar status do repositório',
-                error: error instanceof Error ? error.message : String(error)
-            };
+            return { success: false, action: 'status', message: 'Erro status', error: error instanceof Error ? error.message : String(error) };
         }
     },
     // Action: diff - mostrar diferenças
@@ -318,12 +303,9 @@ 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 '${projectPath}' não é um repositório Git válido`);
-            }
-            // Obter diferenças
+            if (!isGitRepo)
+                throw new Error(`Diretório não é um repositório Git válido`);
             const diffOptions = {};
             if (staged)
                 diffOptions.cached = true;
@@ -332,31 +314,13 @@ exports.gitUpdateProjectTool = {
             if (commit)
                 diffOptions.commit = commit;
             const diffResult = await gitOps.diff(diffOptions);
-            if (!diffResult.success && diffResult.error) {
-                throw new Error(`Falha ao obter diferenças: ${diffResult.error}`);
-            }
+            if (!diffResult.success && diffResult.error)
+                throw new Error(`Falha diff: ${diffResult.error}`);
             const hasDifferences = diffResult.output.trim().length > 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'
-                }
-            };
+            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' } };
         }
         catch (error) {
-            return {
-                success: false,
-                action: 'diff',
-                message: 'Erro ao obter diferenças',
-                error: error instanceof Error ? error.message : String(error)
-            };
+            return { success: false, action: 'diff', message: 'Erro diff', error: error instanceof Error ? error.message : String(error) };
         }
     },
     // Action: log - histórico de commits
@@ -364,12 +328,9 @@ 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 '${projectPath}' não é um repositório Git válido`);
-            }
-            // Obter histórico de commits
+            if (!isGitRepo)
+                throw new Error(`Diretório não é um repositório Git válido`);
             const logOptions = {};
             if (maxCount)
                 logOptions.maxCount = maxCount;
@@ -378,32 +339,14 @@ exports.gitUpdateProjectTool = {
             if (branch)
                 logOptions.branches = [branch];
             const logResult = await gitOps.log(logOptions);
-            if (!logResult.success) {
-                throw new Error(`Falha ao obter histórico: ${logResult.error}`);
-            }
+            if (!logResult.success)
+                throw new Error(`Falha log: ${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 encontrados no histórico`,
-                data: {
-                    commits: commits || 'Nenhum commit encontrado',
-                    commitCount,
-                    maxCount,
-                    oneline,
-                    branch: branch || 'all',
-                    implementation: 'REAL_GIT_OPERATIONS_v2.38.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' } };
         }
         catch (error) {
-            return {
-                success: false,
-                action: 'log',
-                message: 'Erro ao obter histórico de commits',
-                error: error instanceof Error ? error.message : String(error)
-            };
+            return { success: false, action: 'log', message: 'Erro log', error: error instanceof Error ? error.message : String(error) };
         }
     },
     // Action: reset - desfazer mudanças
@@ -411,39 +354,18 @@ 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 '${projectPath}' não é um repositório Git válido`);
-            }
-            // Executar reset
-            const resetOptions = {};
-            if (commit) {
-                resetOptions.target = commit;
-            }
-            const resetResult = await gitOps.reset(mode, resetOptions);
-            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: commit || 'HEAD',
-                    resetOutput: resetResult.output,
-                    implementation: 'REAL_GIT_OPERATIONS_v2.38.0'
-                }
-            };
+            if (!isGitRepo)
+                throw new Error(`Diretório não é um repositório Git válido`);
+            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' } };
         }
         catch (error) {
-            return {
-                success: false,
-                action: 'reset',
-                message: 'Erro ao executar reset',
-                error: error instanceof Error ? error.message : String(error)
-            };
+            return { success: false, action: 'reset', message: 'Erro reset', error: error instanceof Error ? error.message : String(error) };
         }
     },
     // Action: stash - gerenciar mudanças temporárias
@@ -451,11 +373,9 @@ 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 '${projectPath}' não é um repositório Git válido`);
-            }
+            if (!isGitRepo)
+                throw new Error(`Diretório não é um repositório Git válido`);
             let stashResult;
             switch (operation) {
                 case 'save':
@@ -476,31 +396,14 @@ exports.gitUpdateProjectTool = {
                 case 'clear':
                     stashResult = await gitOps.stash('clear');
                     break;
-                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}`);
+                default: throw new Error(`Operação stash '${operation}' não suportada`);
             }
-            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'
-                }
-            };
+            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' } };
         }
         catch (error) {
-            return {
-                success: false,
-                action: 'stash',
-                message: 'Erro na operação de stash',
-                error: error instanceof Error ? error.message : String(error)
-            };
+            return { success: false, action: 'stash', message: 'Erro stash', error: error instanceof Error ? error.message : String(error) };
         }
     },
     // Action: pull - atualizar do remoto
@@ -508,128 +411,180 @@ 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 '${projectPath}' não é um repositório Git válido`);
-            }
-            // Executar pull
+            if (!isGitRepo)
+                throw new Error(`Diretório não é um repositório Git válido`);
             const pullResult = await gitOps.pull('origin', branch);
-            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'
-                }
-            };
+            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' } };
         }
         catch (error) {
-            return {
-                success: false,
-                action: 'pull',
-                message: 'Erro ao executar pull',
-                error: error instanceof Error ? error.message : String(error)
-            };
+            return { success: false, action: 'pull', message: 'Erro pull', error: error instanceof Error ? error.message : String(error) };
         }
     },
-    // Action: sync - sincronização completa (pull + commit + push)
+    // Action: sync - sincronização completa
     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 '${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
+            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: '' } };
             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 ao adicionar arquivos: ${addResult.error}`;
+                    syncResults.commit.error = `Falha add: ${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' : '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
+            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;
+                        }
+                    }
+                }
+            }
+            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: 'sync',
-                message: 'Erro na sincronização completa',
-                error: error instanceof Error ? error.message : String(error)
-            };
+            return { success: false, action: 'init', message: 'Erro init', error: error instanceof Error ? error.message : String(error) };
+        }
+    },
+    async groupFilesByType(projectPath) {
+        const gitOps = new git_operations_js_1.GitOperations(projectPath);
+        const statusResult = await gitOps.status({ porcelain: true });
+        if (!statusResult.success)
+            return {};
+        const lines = statusResult.output.trim().split('\n').filter(line => line.trim());
+        const fileGroups = { 'config': [], 'source': [], 'documentation': [], 'assets': [], 'other': [] };
+        for (const line of lines) {
+            const fileName = line.substring(3).trim();
+            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')) {
+                fileGroups.source.push(fileName);
+            }
+            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')) {
+                fileGroups.assets.push(fileName);
+            }
+            else {
+                fileGroups.other.push(fileName);
+            }
         }
+        return fileGroups;
     }
 };
 //# sourceMappingURL=git-update-project.js.map