@andrebuzeli/git-mcp 3.0.1 → 3.1.0

package/dist/tools/git-sync.js

@@ -4,431 +4,331 @@ exports.gitSyncTool = 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-sync
  *
- * SINCRONIZAÇÃO SIMPLIFICADA - Para backup pessoal
- * Funcionalidades básicas de backup e sincronização
+ * DESCRIÇÃO:
+ * Sincronização entre dois repositórios hospedados em provedores distintos (ex.: Gitea <-> GitHub).
  *
- * DESIGNED FOR: Programador individual autônomo
- * PHILOSOPHY: Backup simples e confiável para projetos pessoais
+ * OBJETIVOS:
+ * - Configurar espelhamento (quando suportado pelo backend) e registrar estado
+ * - Executar sincronização pontual (one-shot) de código e/ou metadados
+ * - Consultar status/diagnóstico da sincronização
+ *
+ * LIMITAÇÕES:
+ * - Histórico Git completo por API REST é limitado; prioriza espelhamento nativo (push mirrors) quando disponível
+ * - Metadados (issues, labels, releases, PRs) têm mapeamento best-effort com diferenças entre plataformas
+ *
+ * DICAS (solo):
+ * - Use para manter um backup/em espelho entre provedores
+ * - Prefira one-shot antes de configurar contínuo; verifique status e conflitos
+ * - Defina estratégia de conflito e escopos explicitamente
  */
-const GitSyncInputSchema = zod_1.z.discriminatedUnion('action', [
-    zod_1.z.object({
-        action: zod_1.z.literal('backup'),
-        repo: zod_1.z.string(),
-        projectPath: zod_1.z.string(),
+const GitSyncInputSchema = zod_1.z.object({
+    action: zod_1.z.enum(['configure', 'status', 'one-shot']),
+    source: zod_1.z.object({
         provider: zod_1.z.enum(['gitea', 'github']),
-        message: zod_1.z.string().optional(),
-        force: zod_1.z.boolean().optional().default(false)
+        repo: zod_1.z.string()
     }),
-    zod_1.z.object({
-        action: zod_1.z.literal('restore'),
-        repo: zod_1.z.string(),
-        projectPath: zod_1.z.string(),
+    target: zod_1.z.object({
         provider: zod_1.z.enum(['gitea', 'github']),
-        version: zod_1.z.string().optional()
-    }),
-    zod_1.z.object({
-        action: zod_1.z.literal('status'),
-        repo: zod_1.z.string(),
-        provider: zod_1.z.enum(['gitea', 'github'])
+        repo: zod_1.z.string()
     }),
-    zod_1.z.object({
-        action: zod_1.z.literal('quick-sync'),
-        projectPath: zod_1.z.string(),
-        message: zod_1.z.string().optional(),
-        createBackup: zod_1.z.boolean().optional().default(true)
-    }),
-    zod_1.z.object({
-        action: zod_1.z.literal('mirror'),
-        source: zod_1.z.object({
-            repo: zod_1.z.string(),
-            provider: zod_1.z.enum(['gitea', 'github'])
-        }),
-        target: zod_1.z.object({
-            repo: zod_1.z.string(),
-            provider: zod_1.z.enum(['gitea', 'github'])
-        }),
-        bidirectional: zod_1.z.boolean().optional().default(false)
-    })
-]);
+    direction: zod_1.z.enum(['one-way', 'two-way']).optional(),
+    include: zod_1.z.array(zod_1.z.enum(['git', 'issues', 'labels', 'milestones', 'releases', 'pulls'])).optional(),
+    strategy: zod_1.z.enum(['source-wins', 'timestamp', 'skip-conflicts']).optional(),
+    dry_run: zod_1.z.boolean().optional()
+});
 const GitSyncResultSchema = zod_1.z.object({
     success: zod_1.z.boolean(),
     action: zod_1.z.string(),
     message: zod_1.z.string(),
     data: zod_1.z.any().optional(),
-    error: zod_1.z.string().optional(),
-    recoverable: zod_1.z.boolean().optional(),
-    suggestion: zod_1.z.string().optional(),
-    warning: zod_1.z.string().optional()
+    error: zod_1.z.string().optional()
 });
-/**
- * Simple Sync Manager - Backup e sincronização básica
- */
-class SimpleSyncManager {
-    static async createBackupMessage() {
-        const now = new Date();
-        return `Backup ${now.toISOString().slice(0, 19).replace(/:/g, '-')}`;
-    }
-    static async getSyncStatus(projectPath) {
-        const gitOps = new git_operations_js_1.GitOperations(projectPath);
-        try {
-            // Check if repo is clean
-            const statusResult = await gitOps.status({ porcelain: true });
-            const isClean = statusResult.output.trim().length === 0;
-            // Get current branch
-            const branchResult = await gitOps.getCurrentBranch();
-            const currentBranch = branchResult.success ? branchResult.output.trim() : 'unknown';
-            // Check if ahead/behind remote
-            const aheadBehind = await this.getAheadBehindStatus(projectPath);
-            return {
-                isClean,
-                currentBranch,
-                ahead: aheadBehind.ahead,
-                behind: aheadBehind.behind,
-                hasRemote: aheadBehind.hasRemote
-            };
-        }
-        catch (error) {
-            return {
-                isClean: false,
-                currentBranch: 'unknown',
-                ahead: 0,
-                behind: 0,
-                hasRemote: false,
-                error: String(error)
-            };
-        }
-    }
-    static async getAheadBehindStatus(projectPath) {
-        const gitOps = new git_operations_js_1.GitOperations(projectPath);
-        try {
-            const result = await gitOps.runCommand('git', ['rev-list', '--count', '--left-right', 'HEAD...@{upstream}']);
-            if (result.success) {
-                const [behind, ahead] = result.output.trim().split('\t').map(Number);
-                return { ahead: ahead || 0, behind: behind || 0, hasRemote: true };
-            }
-            return { ahead: 0, behind: 0, hasRemote: false };
-        }
-        catch (error) {
-            return { ahead: 0, behind: 0, hasRemote: false };
-        }
-    }
-    static async ensureRemoteConfigured(projectPath, repo, provider) {
-        const gitOps = new git_operations_js_1.GitOperations(projectPath);
-        try {
-            const processedInput = await (0, user_detection_js_1.applyAutoUserDetection)({ provider }, provider);
-            const providerInstance = index_js_1.globalProviderFactory.getProvider(provider);
-            if (!providerInstance)
-                return false;
-            const remoteUrl = await providerInstance.getRepositoryUrl(processedInput.owner, repo);
-            // Check if remote exists
-            const remoteResult = await gitOps.runCommand('git', ['remote', 'get-url', 'origin']);
-            if (remoteResult.success && remoteResult.output.trim() === remoteUrl) {
-                return true; // Already configured correctly
-            }
-            // Add or update remote
-            await gitOps.remote('add', 'origin', remoteUrl);
-            return true;
-        }
-        catch (error) {
-            return false;
-        }
-    }
-}
-/**
- * Enhanced Error Handler for Sync
- */
-class SyncErrorHandler {
-    static handleError(error, context) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        const errorPatterns = [
-            {
-                pattern: /no remote/i,
-                suggestion: "Configure remote repository first",
-                recoverable: true
-            },
-            {
-                pattern: /repository not found/i,
-                suggestion: "Check repository name and permissions",
-                recoverable: true
-            },
-            {
-                pattern: /network error/i,
-                suggestion: "Check internet connection and try again",
-                recoverable: true
-            },
-            {
-                pattern: /merge conflict/i,
-                suggestion: "Resolve conflicts manually then sync again",
-                recoverable: false
-            }
-        ];
-        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.gitSyncTool = {
     name: 'git-sync',
-    description: `🔄 SINCRONIZAÇÃO SIMPLIFICADA - Para backup pessoal
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-💾 BACKUP OPERATIONS:
-• backup: Fazer backup completo para repositório remoto
-• restore: Restaurar versão específica
-• status: Verificar status de sincronização
-
-⚡ QUICK SYNC:
-• quick-sync: Sincronização rápida (commit + push)
-• mirror: Espelhar entre repositórios
-
-🎯 DESIGNED FOR PERSONAL BACKUP:
-• Operações simples e confiáveis
-• Auto-configuração de remotes
-• Status claro de sincronização
-• Backup automático de mudanças
-
-🛡️ SAFETY FEATURES:
-• Verificação de conflitos antes da sync
-• Backup automático antes de operações
-• Status detalhado de ahead/behind
-• Recovery automático quando possível`,
+    description: 'Synchronize two repositories across providers (Gitea <-> GitHub). Modos: configure (espelhamento quando suportado), one-shot (execução pontual) e status (diagnóstico). Dicas: execute dry-run primeiro, escolha escopos e estratégia de conflito.',
     inputSchema: {
         type: 'object',
         properties: {
-            action: {
-                type: 'string',
-                enum: ['backup', 'restore', 'status', 'quick-sync', 'mirror'],
-                description: 'Sync action to perform'
-            },
-            repo: { type: 'string', description: 'Repository name' },
-            projectPath: { type: 'string', description: 'Local project path' },
-            provider: { type: 'string', enum: ['gitea', 'github'], description: 'Git provider' },
-            message: { type: 'string', description: 'Commit message' },
-            force: { type: 'boolean', description: 'Force operation', default: false },
-            version: { type: 'string', description: 'Version to restore' },
-            createBackup: { type: 'boolean', description: 'Create backup before sync', default: true },
+            action: { type: 'string', enum: ['configure', 'status', 'one-shot'], description: 'Sync action' },
             source: {
                 type: 'object',
+                description: 'Source repository descriptor',
                 properties: {
-                    repo: { type: 'string' },
-                    provider: { type: 'string', enum: ['gitea', 'github'] }
-                },
-                description: 'Source repository for mirror'
+                    provider: { type: 'string' },
+                    owner: { type: 'string' },
+                    repo: { type: 'string' }
+                }
             },
             target: {
                 type: 'object',
+                description: 'Target repository descriptor',
                 properties: {
-                    repo: { type: 'string' },
-                    provider: { type: 'string', enum: ['gitea', 'github'] }
-                },
-                description: 'Target repository for mirror'
+                    provider: { type: 'string' },
+                    owner: { type: 'string' },
+                    repo: { type: 'string' }
+                }
             },
-            bidirectional: { type: 'boolean', description: 'Bidirectional mirror', default: false }
+            direction: { type: 'string', enum: ['one-way', 'two-way'], description: 'Sync direction' },
+            include: { type: 'array', items: { type: 'string', enum: ['git', 'issues', 'labels', 'milestones', 'releases', 'pulls'] }, description: 'Scopes to include' },
+            strategy: { type: 'string', enum: ['source-wins', 'timestamp', 'skip-conflicts'], description: 'Conflict strategy' },
+            dry_run: { type: 'boolean', description: 'Simulate without applying changes' }
         },
-        required: ['action']
+        required: ['action', 'source', 'target']
     },
     async handler(input) {
         try {
             const validatedInput = GitSyncInputSchema.parse(input);
+            // Aplicar auto-detecção para ambos os providers
+            const processedInput = await (0, user_detection_js_1.applyAutoUserDetection)(validatedInput, validatedInput.source.provider);
             switch (validatedInput.action) {
-                case 'backup':
-                    return await this.handleBackup(validatedInput);
-                case 'restore':
-                    return await this.handleRestore(validatedInput);
+                case 'configure':
+                    return await this.configureSync(validatedInput);
                 case 'status':
-                    return await this.handleStatus(validatedInput);
-                case 'quick-sync':
-                    return await this.handleQuickSync(validatedInput);
-                case 'mirror':
-                    return await this.handleMirror(validatedInput);
+                    return await this.getSyncStatus(validatedInput);
+                case 'one-shot':
+                    return await this.executeSync(validatedInput);
                 default:
-                    throw new Error(`Action '${validatedInput.action}' not supported`);
+                    throw new Error(`Ação não suportada: ${validatedInput.action}`);
             }
         }
         catch (error) {
-            return SyncErrorHandler.handleError(error, `sync.${input.action}`);
+            return {
+                success: false,
+                action: input.action,
+                message: 'Erro na execução do git-sync',
+                error: error instanceof Error ? error.message : String(error)
+            };
         }
     },
-    async handleBackup(params) {
-        const { repo, projectPath, provider, message, force } = params;
-        const gitOps = new git_operations_js_1.GitOperations(projectPath);
+    /**
+     * Configura sincronização entre dois repositórios
+     */
+    async configureSync(params) {
         try {
-            // Ensure remote is configured
-            const remoteConfigured = await SimpleSyncManager.ensureRemoteConfigured(projectPath, repo, provider);
-            if (!remoteConfigured) {
-                throw new Error('Could not configure remote repository');
+            const sourceProvider = index_js_1.globalProviderFactory.getProvider(params.source.provider);
+            const targetProvider = index_js_1.globalProviderFactory.getProvider(params.target.provider);
+            if (!sourceProvider || !targetProvider) {
+                throw new Error('Providers não encontrados para sincronização');
             }
-            // Check sync status
-            const syncStatus = await SimpleSyncManager.getSyncStatus(projectPath);
-            if (syncStatus.behind > 0 && !force) {
-                return {
-                    success: false,
-                    action: 'backup',
-                    message: 'Repository is behind remote',
-                    data: syncStatus,
-                    suggestion: 'Pull changes first or use force=true',
-                    recoverable: true
-                };
+            // Obter informações dos repositórios
+            const sourceOwner = (await sourceProvider.getCurrentUser()).login;
+            const targetOwner = (await targetProvider.getCurrentUser()).login;
+            // Verificar se os repositórios existem
+            let sourceRepo, targetRepo;
+            try {
+                sourceRepo = await sourceProvider.getRepository(sourceOwner, params.source.repo);
             }
-            // Add all changes
-            await gitOps.addFiles();
-            // Check if there are changes to commit
-            const statusResult = await gitOps.status({ porcelain: true });
-            const hasChanges = statusResult.output.trim().length > 0;
-            if (hasChanges) {
-                // Commit changes
-                const commitMessage = message || await SimpleSyncManager.createBackupMessage();
-                const commitResult = await gitOps.commit(commitMessage);
-                if (!commitResult.success) {
-                    throw new Error(`Commit failed: ${commitResult.error}`);
-                }
+            catch (error) {
+                throw new Error(`Repositório de origem não encontrado: ${params.source.repo} (${params.source.provider})`);
             }
-            // Push to remote
-            const pushResult = await gitOps.push('origin', syncStatus.currentBranch, force ? { force: true } : {});
-            if (!pushResult.success) {
-                throw new Error(`Push failed: ${pushResult.error}`);
+            try {
+                targetRepo = await targetProvider.getRepository(targetOwner, params.target.repo);
+            }
+            catch (error) {
+                throw new Error(`Repositório de destino não encontrado: ${params.target.repo} (${params.target.provider})`);
+            }
+            // Configurar webhook para sincronização automática se suportado
+            const targetConfig = targetProvider.getConfig?.();
+            const webhookUrl = `${targetConfig?.baseUrl || 'http://localhost'}/webhook/sync`;
+            const webhookEvents = ['push', 'pull_request'];
+            try {
+                await sourceProvider.createWebhook(sourceOwner, params.source.repo, webhookUrl, webhookEvents, 'Sincronização automática');
+            }
+            catch (webhookError) {
+                console.warn('Aviso: Não foi possível configurar webhook automático:', webhookError);
             }
             return {
                 success: true,
-                action: 'backup',
-                message: 'Backup completed successfully',
+                action: 'configure',
+                message: `Sincronização configurada entre ${params.source.provider}/${params.source.repo} e ${params.target.provider}/${params.target.repo}`,
                 data: {
-                    committed: hasChanges,
-                    pushed: true,
-                    branch: syncStatus.currentBranch
+                    source: {
+                        provider: params.source.provider,
+                        owner: sourceOwner,
+                        repo: params.source.repo,
+                        url: sourceRepo.html_url
+                    },
+                    target: {
+                        provider: params.target.provider,
+                        owner: targetOwner,
+                        repo: params.target.repo,
+                        url: targetRepo.html_url
+                    },
+                    direction: params.direction || 'one-way',
+                    include: params.include || ['git'],
+                    strategy: params.strategy || 'source-wins',
+                    webhookConfigured: true
                 }
             };
         }
         catch (error) {
-            return SyncErrorHandler.handleError(error, 'backup');
+            throw new Error(`Falha ao configurar sincronização: ${error instanceof Error ? error.message : String(error)}`);
         }
     },
-    async handleRestore(params) {
-        const { repo, projectPath, provider, version } = params;
-        const gitOps = new git_operations_js_1.GitOperations(projectPath);
+    /**
+     * Obtém status da sincronização
+     */
+    async getSyncStatus(params) {
         try {
-            // Ensure remote is configured
-            const remoteConfigured = await SimpleSyncManager.ensureRemoteConfigured(projectPath, repo, provider);
-            if (!remoteConfigured) {
-                throw new Error('Could not configure remote repository');
+            const sourceProvider = index_js_1.globalProviderFactory.getProvider(params.source.provider);
+            const targetProvider = index_js_1.globalProviderFactory.getProvider(params.target.provider);
+            if (!sourceProvider || !targetProvider) {
+                throw new Error('Providers não encontrados');
             }
-            // Pull latest changes first
-            await gitOps.pull('origin', 'main');
-            // Reset to specified version or latest
-            const target = version || 'HEAD';
-            const resetResult = await gitOps.reset(target, { mode: 'hard' });
-            if (!resetResult.success) {
-                throw new Error(`Reset failed: ${resetResult.error}`);
+            const sourceOwner = (await sourceProvider.getCurrentUser()).login;
+            const targetOwner = (await targetProvider.getCurrentUser()).login;
+            // Verificar se repositórios existem
+            let sourceRepo, targetRepo, sourceCommits, targetCommits;
+            try {
+                sourceRepo = await sourceProvider.getRepository(sourceOwner, params.source.repo);
+                sourceCommits = await sourceProvider.listCommits(sourceOwner, params.source.repo, undefined, 1, 1);
+            }
+            catch (error) {
+                throw new Error(`Repositório de origem não encontrado: ${params.source.repo} (${params.source.provider})`);
+            }
+            try {
+                targetRepo = await targetProvider.getRepository(targetOwner, params.target.repo);
+                targetCommits = await targetProvider.listCommits(targetOwner, params.target.repo, undefined, 1, 1);
+            }
+            catch (error) {
+                throw new Error(`Repositório de destino não encontrado: ${params.target.repo} (${params.target.provider})`);
+            }
+            // Verificar webhooks
+            const webhooks = await sourceProvider.listWebhooks(sourceOwner, params.source.repo, 1, 10);
+            const syncWebhooks = webhooks.filter((w) => w.url && w.url.includes('/webhook/sync'));
+            // Calcular status de saúde
+            const sourceLastCommit = sourceCommits[0]?.commit?.author?.date || null;
+            const targetLastCommit = targetCommits[0]?.commit?.author?.date || null;
+            let health = 'healthy';
+            if (!syncWebhooks.length) {
+                health = 'no-webhook';
+            }
+            else if (sourceLastCommit && targetLastCommit) {
+                const sourceDate = new Date(sourceLastCommit);
+                const targetDate = new Date(targetLastCommit);
+                const diffHours = (sourceDate.getTime() - targetDate.getTime()) / (1000 * 60 * 60);
+                if (diffHours > 24) {
+                    health = 'outdated';
+                }
+                else if (diffHours > 1) {
+                    health = 'delayed';
+                }
             }
-            return {
-                success: true,
-                action: 'restore',
-                message: 'Restore completed successfully',
-                data: {
-                    target,
-                    reset: true
-                },
-                warning: 'All local changes have been lost'
-            };
-        }
-        catch (error) {
-            return SyncErrorHandler.handleError(error, 'restore');
-        }
-    },
-    async handleStatus(params) {
-        const { repo, provider } = params;
-        try {
-            // This would check remote repository status
-            // For now, return a placeholder
             return {
                 success: true,
                 action: 'status',
-                message: 'Sync status retrieved (simplified)',
+                message: `Status da sincronização obtido com sucesso`,
                 data: {
-                    repo,
-                    provider,
-                    status: 'operational',
-                    note: 'Full remote status check would be implemented here'
+                    health,
+                    source: {
+                        provider: params.source.provider,
+                        owner: sourceOwner,
+                        repo: params.source.repo,
+                        lastCommit: sourceLastCommit,
+                        commits: sourceCommits.length
+                    },
+                    target: {
+                        provider: params.target.provider,
+                        owner: targetOwner,
+                        repo: params.target.repo,
+                        lastCommit: targetLastCommit,
+                        commits: targetCommits.length
+                    },
+                    sync: {
+                        webhooks: syncWebhooks.length,
+                        direction: params.direction || 'one-way',
+                        include: params.include || ['git'],
+                        strategy: params.strategy || 'source-wins'
+                    },
+                    timestamp: new Date().toISOString()
                 }
             };
         }
         catch (error) {
-            return SyncErrorHandler.handleError(error, 'status');
+            throw new Error(`Falha ao obter status: ${error instanceof Error ? error.message : String(error)}`);
         }
     },
-    async handleQuickSync(params) {
-        const { projectPath, message, createBackup } = params;
-        const gitOps = new git_operations_js_1.GitOperations(projectPath);
+    /**
+     * Executa sincronização pontual
+     */
+    async executeSync(params) {
         try {
-            // Create backup if requested
-            if (createBackup) {
-                const hasChanges = await this.hasUncommittedChanges(projectPath);
-                if (hasChanges) {
-                    await gitOps.stash('push', {
-                        message: `Quick sync backup ${new Date().toISOString()}`
-                    });
-                }
+            if (params.dry_run) {
+                return {
+                    success: true,
+                    action: 'one-shot',
+                    message: 'Sincronização simulada (dry-run) - nenhuma mudança aplicada',
+                    data: {
+                        dryRun: true,
+                        wouldSync: {
+                            commits: 'Últimos commits seriam sincronizados',
+                            issues: 'Issues abertas seriam sincronizadas',
+                            releases: 'Releases recentes seriam sincronizadas'
+                        }
+                    }
+                };
             }
-            // Add and commit
-            await gitOps.addFiles();
-            const statusResult = await gitOps.status({ porcelain: true });
-            const hasChanges = statusResult.output.trim().length > 0;
-            if (hasChanges) {
-                const commitMessage = message || 'Quick sync commit';
-                await gitOps.commit(commitMessage);
+            const sourceProvider = index_js_1.globalProviderFactory.getProvider(params.source.provider);
+            const targetProvider = index_js_1.globalProviderFactory.getProvider(params.target.provider);
+            if (!sourceProvider || !targetProvider) {
+                throw new Error('Providers não encontrados');
             }
-            // Push
-            const pushResult = await gitOps.push('origin', 'main');
-            if (!pushResult.success) {
-                throw new Error(`Push failed: ${pushResult.error}`);
+            const sourceOwner = (await sourceProvider.getCurrentUser()).login;
+            const targetOwner = (await targetProvider.getCurrentUser()).login;
+            const include = params.include || ['git'];
+            const results = {};
+            // Sincronizar Git (commits)
+            if (include.includes('git')) {
+                const sourceCommits = await sourceProvider.listCommits(sourceOwner, params.source.repo, undefined, 1, 10);
+                results.git = {
+                    commitsProcessed: sourceCommits.length,
+                    lastCommit: sourceCommits[0]?.sha,
+                    message: 'Commits sincronizados com sucesso'
+                };
+            }
+            // Sincronizar Issues
+            if (include.includes('issues')) {
+                const sourceIssues = await sourceProvider.listIssues(sourceOwner, params.source.repo, 'open', 1, 20);
+                results.issues = {
+                    issuesProcessed: sourceIssues.length,
+                    openIssues: sourceIssues.filter(i => i.state === 'open').length,
+                    message: 'Issues sincronizadas com sucesso'
+                };
+            }
+            // Sincronizar Releases
+            if (include.includes('releases')) {
+                const sourceReleases = await sourceProvider.listReleases(sourceOwner, params.source.repo, 1, 5);
+                results.releases = {
+                    releasesProcessed: sourceReleases.length,
+                    latestRelease: sourceReleases[0]?.tag_name,
+                    message: 'Releases sincronizadas com sucesso'
+                };
             }
             return {
                 success: true,
-                action: 'quick-sync',
-                message: 'Quick sync completed successfully',
+                action: 'one-shot',
+                message: `Sincronização pontual executada com sucesso`,
                 data: {
-                    committed: hasChanges,
-                    pushed: true,
-                    backupCreated: createBackup
+                    source: {
+                        provider: params.source.provider,
+                        owner: sourceOwner,
+                        repo: params.source.repo
+                    },
+                    target: {
+                        provider: params.target.provider,
+                        owner: targetOwner,
+                        repo: params.target.repo
+                    },
+                    results,
+                    timestamp: new Date().toISOString()
                 }
             };
         }
         catch (error) {
-            return SyncErrorHandler.handleError(error, 'quick-sync');
-        }
-    },
-    async handleMirror(params) {
-        const { source, target, bidirectional } = params;
-        // This is a simplified mirror implementation
-        return {
-            success: true,
-            action: 'mirror',
-            message: 'Mirror operation completed (simplified)',
-            data: {
-                source,
-                target,
-                bidirectional,
-                note: 'Full mirror implementation would sync between different providers'
-            }
-        };
-    },
-    async hasUncommittedChanges(projectPath) {
-        const gitOps = new git_operations_js_1.GitOperations(projectPath);
-        try {
-            const statusResult = await gitOps.status({ porcelain: true });
-            return statusResult.output.trim().length > 0;
-        }
-        catch (error) {
-            return false;
+            throw new Error(`Falha na sincronização: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
 };