@andrebuzeli/git-mcp 3.4.0 → 4.0.3

package/dist/tools/git-reset.js

@@ -2,222 +2,603 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.gitResetTool = void 0;
 const zod_1 = require("zod");
-const terminal_controller_js_1 = require("../utils/terminal-controller.js");
+const auto_detection_js_1 = require("../utils/auto-detection.js");
+const error_handler_js_1 = require("../utils/error-handler.js");
+const git_operations_js_1 = require("../utils/git-operations.js");
 /**
  * Tool: git-reset
  *
- * DESCRIÇÃO:
- * Gerenciamento de reset Git (GitHub + Gitea) com múltiplas ações
+ * RESET SEGURO UNIFICADO
+ * Reset inteligente com preview, backup automático e recovery
  *
- * FUNCIONALIDADES:
- * - Reset soft (mantém mudanças no staging)
- * - Reset mixed (padrão, remove do staging)
- * - Reset hard (remove todas as mudanças)
- * - Reset para commit específico
- * - Reset de branch
- *
- * USO:
- * - Para desfazer commits
- * - Para limpar staging area
- * - Para voltar a estado anterior
- * - Para remover mudanças não commitadas
- *
- * RECOMENDAÇÕES:
- * - Use com cuidado, especialmente reset hard
- * - Faça backup antes de resets destrutivos
- * - Teste em branches locais primeiro
+ * DESIGNED FOR: Programador individual autônomo
+ * PHILOSOPHY: Reset seguro e inteligente
  */
-const GitResetInputSchema = zod_1.z.object({
-    action: zod_1.z.enum(['soft', 'mixed', 'hard', 'reset-to-commit', 'reset-branch']),
-    // owner: obtido automaticamente do provider,
-    // repo: extraído automaticamente do projectPath
-    provider: zod_1.z.enum(['gitea', 'github']).describe('Provider to use (gitea or github)'),
-    projectPath: zod_1.z.string().describe('Local project path for git operations'),
-    // Para reset
-    commit_hash: zod_1.z.string().optional(),
-    branch_name: zod_1.z.string().optional(),
-    reset_type: zod_1.z.enum(['soft', 'mixed', 'hard']).optional(),
-    // Para reset-branch
-    target_branch: zod_1.z.string().optional(),
-});
-const GitResetResultSchema = 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()
-});
-exports.gitResetTool = {
-    name: 'git-reset',
-    description: 'tool: Gerencia operações Git reset para desfazer mudanças\n──────────────\naction soft: reset soft mantém mudanças no staging\naction soft requires: commit_hash, provider, projectPath\n───────────────\naction mixed: reset mixed limpa staging area\naction mixed requires: commit_hash, provider, projectPath\n───────────────\naction hard: reset hard remove todas as mudanças\naction hard requires: commit_hash, provider, projectPath\n───────────────\naction reset-to-commit: reseta para commit específico\naction reset-to-commit requires: commit_hash, reset_type, provider, projectPath\n───────────────\naction reset-branch: reseta branch específica\naction reset-branch requires: branch_name, target_branch, provider, projectPath',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            action: {
-                type: 'string',
-                enum: ['soft', 'mixed', 'hard', 'reset-to-commit', 'reset-branch'],
-                description: 'Action to perform on reset'
-            },
-            owner: { type: 'string', description: 'Repository owner' },
-            repo: { type: 'string', description: 'Repository name' },
-            provider: { type: 'string', enum: ['gitea', 'github'], description: 'Provider to use (gitea or github)' },
-            projectPath: { type: 'string', description: 'Local project path for git operations' },
-            commit_hash: { type: 'string', description: 'Commit hash to reset to' },
-            branch_name: { type: 'string', description: 'Branch name for reset' },
-            reset_type: { type: 'string', enum: ['soft', 'mixed', 'hard'], description: 'Type of reset' },
-            target_branch: { type: 'string', description: 'Target branch for reset' }
-        },
-        required: ['action', 'repo', 'provider', 'projectPath']
-    },
-    async handler(input) {
+const GitResetInputSchema = zod_1.z.discriminatedUnion('action', [
+    // RESET SOFT - Mantém mudanças no staging
+    zod_1.z.object({
+        action: zod_1.z.literal('soft'),
+        projectPath: zod_1.z.string(),
+        commit: zod_1.z.string(), // Commit hash, branch, or HEAD~n
+        preview: zod_1.z.boolean().default(true), // Preview antes de executar
+        backup: zod_1.z.boolean().default(true) // Criar backup automático
+    }),
+    // RESET MIXED - Limpa staging area
+    zod_1.z.object({
+        action: zod_1.z.literal('mixed'),
+        projectPath: zod_1.z.string(),
+        commit: zod_1.z.string(),
+        preview: zod_1.z.boolean().default(true),
+        backup: zod_1.z.boolean().default(true)
+    }),
+    // RESET HARD - Remove todas as mudanças
+    zod_1.z.object({
+        action: zod_1.z.literal('hard'),
+        projectPath: zod_1.z.string(),
+        commit: zod_1.z.string(),
+        preview: zod_1.z.boolean().default(true),
+        backup: zod_1.z.boolean().default(true),
+        confirm: zod_1.z.boolean().default(false) // Confirmação extra para hard reset
+    }),
+    // RESET TO COMMIT - Reset para commit específico
+    zod_1.z.object({
+        action: zod_1.z.literal('reset-to-commit'),
+        projectPath: zod_1.z.string(),
+        commit: zod_1.z.string(),
+        type: zod_1.z.enum(['soft', 'mixed', 'hard']).default('mixed'),
+        preview: zod_1.z.boolean().default(true),
+        backup: zod_1.z.boolean().default(true),
+        confirm: zod_1.z.boolean().default(false)
+    }),
+    // RESET BRANCH - Reset de branch específica
+    zod_1.z.object({
+        action: zod_1.z.literal('reset-branch'),
+        projectPath: zod_1.z.string(),
+        branch: zod_1.z.string(),
+        target: zod_1.z.string(), // Commit/branch target
+        type: zod_1.z.enum(['soft', 'mixed', 'hard']).default('mixed'),
+        preview: zod_1.z.boolean().default(true),
+        backup: zod_1.z.boolean().default(true),
+        confirm: zod_1.z.boolean().default(false)
+    })
+]);
+/**
+ * Smart Reset Manager
+ * Gerencia operações de reset com inteligência e segurança
+ */
+class SmartResetManager {
+    static async getResetPreview(projectPath, commit, resetType) {
+        const gitOps = new git_operations_js_1.GitOperations(projectPath);
         try {
-            const validatedInput = GitResetInputSchema.parse(input);
-            switch (validatedInput.action) {
-                case 'soft':
-                    return await this.softReset(validatedInput);
-                case 'mixed':
-                    return await this.mixedReset(validatedInput);
-                case 'hard':
-                    return await this.hardReset(validatedInput);
-                case 'reset-to-commit':
-                    return await this.resetToCommit(validatedInput);
-                case 'reset-branch':
-                    return await this.resetBranch(validatedInput);
-                default:
-                    throw new Error(`Ação não suportada: ${validatedInput.action}`);
+            // Get current HEAD
+            const headResult = await gitOps.runCommand('git', ['rev-parse', 'HEAD']);
+            const currentHead = headResult.success ? headResult.output.trim() : null;
+            // Get target commit
+            const targetResult = await gitOps.runCommand('git', ['rev-parse', commit]);
+            const targetCommit = targetResult.success ? targetResult.output.trim() : null;
+            if (!targetCommit) {
+                throw new Error(`Invalid commit reference: ${commit}`);
+            }
+            // Get commits that will be lost
+            const commitsResult = await gitOps.runCommand('git', ['log', '--oneline', `${targetCommit}..HEAD`]);
+            const commitsToLose = commitsResult.success ?
+                commitsResult.output.trim().split('\n').filter(line => line.trim()) : [];
+            // Get files that will be affected
+            let affectedFiles = {};
+            if (resetType === 'hard') {
+                // For hard reset, get all changed files
+                const statusResult = await gitOps.runCommand('git', ['status', '--porcelain']);
+                const stagedResult = await gitOps.runCommand('git', ['diff', '--cached', '--name-only']);
+                const unstagedResult = await gitOps.runCommand('git', ['diff', '--name-only']);
+                affectedFiles = {
+                    staged: stagedResult.success ? stagedResult.output.trim().split('\n').filter(f => f) : [],
+                    unstaged: unstagedResult.success ? unstagedResult.output.trim().split('\n').filter(f => f) : [],
+                    untracked: statusResult.success ? statusResult.output.trim().split('\n')
+                        .filter(line => line.startsWith('??'))
+                        .map(line => line.substring(3)) : []
+                };
             }
-        }
-        catch (error) {
             return {
-                success: false,
-                action: input.action,
-                message: 'Erro na operação de reset',
-                error: error instanceof Error ? error.message : String(error)
+                currentHead,
+                targetCommit,
+                commitsToLose: commitsToLose.length,
+                commits: commitsToLose,
+                affectedFiles,
+                resetType,
+                safe: commitsToLose.length === 0
             };
         }
-    },
-    async softReset(params) {
+        catch (error) {
+            return { error: error instanceof Error ? error.message : String(error) };
+        }
+    }
+    static async createResetBackup(projectPath, operation) {
+        const gitOps = new git_operations_js_1.GitOperations(projectPath);
         try {
-            const target = params.commit_hash || params.branch_name || 'HEAD~1';
-            const result = await (0, terminal_controller_js_1.runGitCommand)(`reset --soft ${target}`, params.projectPath, 'Executando reset soft');
-            if (result.exitCode !== 0) {
-                throw new Error(`Falha no reset soft: ${result.output}`);
+            const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+            const backupBranch = `backup-reset-${timestamp}`;
+            // Create backup branch
+            const branchResult = await gitOps.runCommand('git', ['checkout', '-b', backupBranch]);
+            if (!branchResult.success) {
+                throw new Error(`Failed to create backup branch: ${branchResult.error}`);
             }
-            return {
+            // Go back to original branch
+            await gitOps.runCommand('git', ['checkout', '-']);
+            return backupBranch;
+        }
+        catch (error) {
+            console.warn('Failed to create reset backup:', error);
+            return '';
+        }
+    }
+    static async validateCommitReference(projectPath, commit) {
+        const gitOps = new git_operations_js_1.GitOperations(projectPath);
+        try {
+            const result = await gitOps.runCommand('git', ['rev-parse', '--verify', commit]);
+            return result.success;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    static async getCurrentBranch(projectPath) {
+        const gitOps = new git_operations_js_1.GitOperations(projectPath);
+        try {
+            const result = await gitOps.runCommand('git', ['branch', '--show-current']);
+            return result.success ? result.output.trim() : 'HEAD';
+        }
+        catch (error) {
+            return 'HEAD';
+        }
+    }
+    static generateResetMessage(resetType, commit, backupCreated) {
+        let message = `${resetType.toUpperCase()} reset to ${commit}`;
+        if (backupCreated) {
+            message += ' (backup created)';
+        }
+        return message;
+    }
+}
+/**
+ * Classe principal para executar operações Git reset
+ */
+class GitResetExecutor {
+    errorHandler = new error_handler_js_1.UniversalErrorHandler();
+    /**
+     * Executa preview para qualquer operação de reset
+     */
+    async executePreview(detection, input) {
+        const commit = input.commit || input.target;
+        const resetType = input.type || input.action;
+        try {
+            const preview = await SmartResetManager.getResetPreview(detection.projectPath, commit, resetType);
+            if (preview.error) {
+                throw new Error(preview.error);
+            }
+            const isDestructive = resetType === 'hard' || (resetType === 'mixed' && preview.commitsToLose > 0);
+            return (0, auto_detection_js_1.createUniversalResponse)({
+                success: true,
+                action: 'preview',
+                message: `Reset preview: ${resetType} to ${commit}`,
+                data: {
+                    ...preview,
+                    destructive: isDestructive,
+                    requiresConfirmation: isDestructive,
+                    recommendedBackup: isDestructive && preview.commitsToLose > 0
+                },
+                autoDetected: {
+                    repo: detection.repoName,
+                    owner: detection.owner,
+                    providers: detection.providers
+                }
+            });
+        }
+        catch (error) {
+            return this.errorHandler.toUniversalResponse();
+        }
+    }
+    /**
+     * Executa operação soft
+     */
+    async executeSoft(detection, input) {
+        try {
+            if (input.preview) {
+                return await this.executePreview(detection, { ...input, type: 'soft' });
+            }
+            const gitOps = new git_operations_js_1.GitOperations(detection.projectPath);
+            // Validate commit
+            const isValid = await SmartResetManager.validateCommitReference(detection.projectPath, input.commit);
+            if (!isValid) {
+                throw new Error(`Invalid commit reference: ${input.commit}`);
+            }
+            // Create backup if requested
+            let backupBranch = '';
+            if (input.backup) {
+                backupBranch = await SmartResetManager.createResetBackup(detection.projectPath, 'soft-reset');
+            }
+            // Execute soft reset
+            const resetResult = await gitOps.runCommand('git', ['reset', '--soft', input.commit]);
+            if (!resetResult.success) {
+                throw new Error(`Failed to execute soft reset: ${resetResult.error}`);
+            }
+            return (0, auto_detection_js_1.createUniversalResponse)({
                 success: true,
                 action: 'soft',
-                message: `Reset soft executado com sucesso para ${target}`,
+                message: SmartResetManager.generateResetMessage('soft', input.commit, !!backupBranch),
                 data: {
-                    target,
+                    commit: input.commit,
                     type: 'soft',
-                    output: result.output
+                    backupCreated: !!backupBranch,
+                    backupBranch: backupBranch,
+                    changesPreserved: true,
+                    indexPreserved: true
+                },
+                autoDetected: {
+                    repo: detection.repoName,
+                    owner: detection.owner,
+                    providers: detection.providers
                 }
-            };
+            });
         }
         catch (error) {
-            throw new Error(`Falha ao executar reset soft: ${error instanceof Error ? error.message : String(error)}`);
+            return this.errorHandler.toUniversalResponse();
         }
-    },
-    async mixedReset(params) {
+    }
+    /**
+     * Executa operação mixed
+     */
+    async executeMixed(detection, input) {
         try {
-            const target = params.commit_hash || params.branch_name || 'HEAD~1';
-            const result = await (0, terminal_controller_js_1.runGitCommand)(`reset --mixed ${target}`, params.projectPath, 'Executando reset mixed');
-            if (result.exitCode !== 0) {
-                throw new Error(`Falha no reset mixed: ${result.output}`);
+            if (input.preview) {
+                return await this.executePreview(detection, { ...input, type: 'mixed' });
             }
-            return {
+            const gitOps = new git_operations_js_1.GitOperations(detection.projectPath);
+            // Validate commit
+            const isValid = await SmartResetManager.validateCommitReference(detection.projectPath, input.commit);
+            if (!isValid) {
+                throw new Error(`Invalid commit reference: ${input.commit}`);
+            }
+            // Create backup if requested
+            let backupBranch = '';
+            if (input.backup) {
+                backupBranch = await SmartResetManager.createResetBackup(detection.projectPath, 'mixed-reset');
+            }
+            // Execute mixed reset
+            const resetResult = await gitOps.runCommand('git', ['reset', '--mixed', input.commit]);
+            if (!resetResult.success) {
+                throw new Error(`Failed to execute mixed reset: ${resetResult.error}`);
+            }
+            return (0, auto_detection_js_1.createUniversalResponse)({
                 success: true,
                 action: 'mixed',
-                message: `Reset mixed executado com sucesso para ${target}`,
+                message: SmartResetManager.generateResetMessage('mixed', input.commit, !!backupBranch),
                 data: {
-                    target,
+                    commit: input.commit,
                     type: 'mixed',
-                    output: result.output
+                    backupCreated: !!backupBranch,
+                    backupBranch: backupBranch,
+                    changesPreserved: true,
+                    indexCleared: true
+                },
+                autoDetected: {
+                    repo: detection.repoName,
+                    owner: detection.owner,
+                    providers: detection.providers
                 }
-            };
+            });
         }
         catch (error) {
-            throw new Error(`Falha ao executar reset mixed: ${error instanceof Error ? error.message : String(error)}`);
+            return this.errorHandler.toUniversalResponse();
         }
-    },
-    async hardReset(params) {
+    }
+    /**
+     * Executa operação hard
+     */
+    async executeHard(detection, input) {
         try {
-            const target = params.commit_hash || params.branch_name || 'HEAD~1';
-            const result = await (0, terminal_controller_js_1.runGitCommand)(`reset --hard ${target}`, params.projectPath, 'Executando reset hard');
-            if (result.exitCode !== 0) {
-                throw new Error(`Falha no reset hard: ${result.output}`);
+            if (input.preview) {
+                return await this.executePreview(detection, { ...input, type: 'hard' });
             }
-            return {
+            if (!input.confirm) {
+                return (0, auto_detection_js_1.createUniversalResponse)({
+                    success: false,
+                    action: 'hard',
+                    message: 'Confirmation required for hard reset',
+                    error: {
+                        code: 'CONFIRMATION_REQUIRED',
+                        message: 'Hard reset requires explicit confirmation',
+                        cause: 'Hard reset permanently removes uncommitted changes',
+                        suggestion: 'Set confirm=true to proceed or use preview=true to see what will be lost'
+                    },
+                    autoDetected: {
+                        repo: detection.repoName,
+                        owner: detection.owner,
+                        providers: detection.providers
+                    }
+                });
+            }
+            const gitOps = new git_operations_js_1.GitOperations(detection.projectPath);
+            // Validate commit
+            const isValid = await SmartResetManager.validateCommitReference(detection.projectPath, input.commit);
+            if (!isValid) {
+                throw new Error(`Invalid commit reference: ${input.commit}`);
+            }
+            // Create backup if requested
+            let backupBranch = '';
+            if (input.backup) {
+                backupBranch = await SmartResetManager.createResetBackup(detection.projectPath, 'hard-reset');
+            }
+            // Execute hard reset
+            const resetResult = await gitOps.runCommand('git', ['reset', '--hard', input.commit]);
+            if (!resetResult.success) {
+                throw new Error(`Failed to execute hard reset: ${resetResult.error}`);
+            }
+            return (0, auto_detection_js_1.createUniversalResponse)({
                 success: true,
                 action: 'hard',
-                message: `Reset hard executado com sucesso para ${target}`,
+                message: SmartResetManager.generateResetMessage('hard', input.commit, !!backupBranch),
                 data: {
-                    target,
+                    commit: input.commit,
                     type: 'hard',
-                    output: result.output
+                    backupCreated: !!backupBranch,
+                    backupBranch: backupBranch,
+                    changesRemoved: true,
+                    indexCleared: true,
+                    workingDirectoryReset: true,
+                    confirm: input.confirm
+                },
+                autoDetected: {
+                    repo: detection.repoName,
+                    owner: detection.owner,
+                    providers: detection.providers
                 }
-            };
+            });
         }
         catch (error) {
-            throw new Error(`Falha ao executar reset hard: ${error instanceof Error ? error.message : String(error)}`);
+            return this.errorHandler.toUniversalResponse();
         }
-    },
-    async resetToCommit(params) {
+    }
+    /**
+     * Executa operação reset-to-commit
+     */
+    async executeResetToCommit(detection, input) {
         try {
-            if (!params.commit_hash) {
-                throw new Error('commit_hash é obrigatório para reset-to-commit');
-            }
-            const resetType = params.reset_type || 'mixed';
-            const result = await (0, terminal_controller_js_1.runTerminalCmd)({
-                command: `cd "${params.projectPath}" && git reset --${resetType} ${params.commit_hash}`,
-                is_background: false,
-                explanation: `Executando reset ${resetType} para commit`
-            });
-            if (result.exitCode !== 0) {
-                throw new Error(`Falha no reset para commit: ${result.output}`);
+            if (input.preview) {
+                return await this.executePreview(detection, input);
             }
-            return {
+            const gitOps = new git_operations_js_1.GitOperations(detection.projectPath);
+            // Validate commit
+            const isValid = await SmartResetManager.validateCommitReference(detection.projectPath, input.commit);
+            if (!isValid) {
+                throw new Error(`Invalid commit reference: ${input.commit}`);
+            }
+            // For hard reset, require confirmation
+            if (input.type === 'hard' && !input.confirm) {
+                return (0, auto_detection_js_1.createUniversalResponse)({
+                    success: false,
+                    action: 'reset-to-commit',
+                    message: 'Confirmation required for hard reset',
+                    error: {
+                        code: 'CONFIRMATION_REQUIRED',
+                        message: 'Hard reset to commit requires explicit confirmation',
+                        cause: 'Hard reset permanently removes uncommitted changes',
+                        suggestion: 'Set confirm=true to proceed'
+                    },
+                    autoDetected: {
+                        repo: detection.repoName,
+                        owner: detection.owner,
+                        providers: detection.providers
+                    }
+                });
+            }
+            // Create backup if requested
+            let backupBranch = '';
+            if (input.backup) {
+                backupBranch = await SmartResetManager.createResetBackup(detection.projectPath, `${input.type}-reset-to-commit`);
+            }
+            // Execute reset
+            const resetResult = await gitOps.runCommand('git', ['reset', `--${input.type}`, input.commit]);
+            if (!resetResult.success) {
+                throw new Error(`Failed to reset to commit: ${resetResult.error}`);
+            }
+            return (0, auto_detection_js_1.createUniversalResponse)({
                 success: true,
                 action: 'reset-to-commit',
-                message: `Reset ${resetType} executado com sucesso para commit ${params.commit_hash}`,
+                message: SmartResetManager.generateResetMessage(input.type, input.commit, !!backupBranch),
                 data: {
-                    commit_hash: params.commit_hash,
-                    type: resetType,
-                    output: result.output
+                    commit: input.commit,
+                    type: input.type,
+                    backupCreated: !!backupBranch,
+                    backupBranch: backupBranch,
+                    confirm: input.confirm
+                },
+                autoDetected: {
+                    repo: detection.repoName,
+                    owner: detection.owner,
+                    providers: detection.providers
                 }
-            };
+            });
         }
         catch (error) {
-            throw new Error(`Falha ao executar reset para commit: ${error instanceof Error ? error.message : String(error)}`);
+            return this.errorHandler.toUniversalResponse();
         }
-    },
-    async resetBranch(params) {
+    }
+    /**
+     * Executa operação reset-branch
+     */
+    async executeResetBranch(detection, input) {
         try {
-            if (!params.target_branch) {
-                throw new Error('target_branch é obrigatório para reset-branch');
-            }
-            const resetType = params.reset_type || 'mixed';
-            const result = await (0, terminal_controller_js_1.runTerminalCmd)({
-                command: `cd "${params.projectPath}" && git reset --${resetType} ${params.target_branch}`,
-                is_background: false,
-                explanation: `Executando reset ${resetType} para branch`
-            });
-            if (result.exitCode !== 0) {
-                throw new Error(`Falha no reset para branch: ${result.output}`);
+            if (input.preview) {
+                return await this.executePreview(detection, { ...input, commit: input.target });
             }
-            return {
+            const gitOps = new git_operations_js_1.GitOperations(detection.projectPath);
+            // Validate target
+            const isValid = await SmartResetManager.validateCommitReference(detection.projectPath, input.target);
+            if (!isValid) {
+                throw new Error(`Invalid target reference: ${input.target}`);
+            }
+            // For hard reset, require confirmation
+            if (input.type === 'hard' && !input.confirm) {
+                return (0, auto_detection_js_1.createUniversalResponse)({
+                    success: false,
+                    action: 'reset-branch',
+                    message: 'Confirmation required for hard reset',
+                    error: {
+                        code: 'CONFIRMATION_REQUIRED',
+                        message: 'Hard reset of branch requires explicit confirmation',
+                        cause: 'Hard reset permanently removes uncommitted changes',
+                        suggestion: 'Set confirm=true to proceed'
+                    },
+                    autoDetected: {
+                        repo: detection.repoName,
+                        owner: detection.owner,
+                        providers: detection.providers
+                    }
+                });
+            }
+            // Switch to branch first
+            const checkoutResult = await gitOps.runCommand('git', ['checkout', input.branch]);
+            if (!checkoutResult.success) {
+                throw new Error(`Failed to switch to branch ${input.branch}: ${checkoutResult.error}`);
+            }
+            // Create backup if requested
+            let backupBranch = '';
+            if (input.backup) {
+                backupBranch = await SmartResetManager.createResetBackup(detection.projectPath, `${input.type}-reset-branch-${input.branch}`);
+            }
+            // Execute reset
+            const resetResult = await gitOps.runCommand('git', ['reset', `--${input.type}`, input.target]);
+            if (!resetResult.success) {
+                throw new Error(`Failed to reset branch: ${resetResult.error}`);
+            }
+            return (0, auto_detection_js_1.createUniversalResponse)({
                 success: true,
                 action: 'reset-branch',
-                message: `Reset ${resetType} executado com sucesso para branch ${params.target_branch}`,
+                message: SmartResetManager.generateResetMessage(input.type, input.target, !!backupBranch),
                 data: {
-                    target_branch: params.target_branch,
-                    type: resetType,
-                    output: result.output
+                    branch: input.branch,
+                    target: input.target,
+                    type: input.type,
+                    backupCreated: !!backupBranch,
+                    backupBranch: backupBranch,
+                    confirm: input.confirm
+                },
+                autoDetected: {
+                    repo: detection.repoName,
+                    owner: detection.owner,
+                    providers: detection.providers
                 }
-            };
+            });
+        }
+        catch (error) {
+            return this.errorHandler.toUniversalResponse();
+        }
+    }
+}
+/**
+ * Tool principal git-reset
+ */
+exports.gitResetTool = {
+    name: 'git-reset',
+    description: `🔄 RESET SEGURO UNIFICADO
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+🎯 RESET INTELIGENTE:
+• soft: Mantém mudanças no staging area
+• mixed: Limpa staging, preserva working directory
+• hard: Remove tudo (requer confirmação)
+• reset-to-commit: Reset para commit específico
+• reset-branch: Reset de branch específica
+
+🔍 PREVIEW E SEGURANÇA:
+• Preview automático antes de executar
+• Detecção de commits/files que serão perdidos
+• Backup automático opcional
+• Confirmação para operações destrutivas
+• Recovery assistido
+
+⚡ OPERAÇÕES CONTROLADAS:
+• Validação de referências de commit
+• Detecção automática de conflitos
+• Rollback automático em caso de erro
+• Backup de estado antes das mudanças
+
+🤖 COMPATÍVEL COM AI AGENTS:
+• Interface universal para qualquer IDE
+• Auto-detecção completa de contexto
+• Respostas estruturadas consistentes
+• Error handling inteligente
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`,
+    inputSchema: {
+        type: 'object',
+        properties: {
+            action: {
+                type: 'string',
+                enum: ['soft', 'mixed', 'hard', 'reset-to-commit', 'reset-branch'],
+                description: 'Ação do sistema de reset'
+            },
+            projectPath: {
+                type: 'string',
+                description: 'Caminho absoluto do projeto'
+            },
+            commit: {
+                type: 'string',
+                description: 'Referência do commit (hash, branch, HEAD~n)'
+            },
+            preview: {
+                type: 'boolean',
+                description: 'Preview antes de executar'
+            },
+            backup: {
+                type: 'boolean',
+                description: 'Criar backup automático'
+            },
+            confirm: {
+                type: 'boolean',
+                description: 'Confirmação para operações destrutivas'
+            },
+            type: {
+                type: 'string',
+                enum: ['soft', 'mixed', 'hard'],
+                description: 'Tipo de reset'
+            },
+            branch: {
+                type: 'string',
+                description: 'Nome da branch para reset-branch'
+            },
+            target: {
+                type: 'string',
+                description: 'Target para reset-branch'
+            }
+        },
+        required: ['action', 'projectPath']
+    },
+    async handler(input) {
+        const executor = new GitResetExecutor();
+        try {
+            // Validate input
+            const validatedInput = GitResetInputSchema.parse(input);
+            // Auto-detect context
+            const detection = await (0, auto_detection_js_1.autoDetect)(validatedInput.projectPath);
+            await (0, auto_detection_js_1.validateAutoDetection)(detection);
+            // Execute specific action
+            switch (validatedInput.action) {
+                case 'soft':
+                    return await executor['executeSoft'](detection, validatedInput);
+                case 'mixed':
+                    return await executor['executeMixed'](detection, validatedInput);
+                case 'hard':
+                    return await executor['executeHard'](detection, validatedInput);
+                case 'reset-to-commit':
+                    return await executor['executeResetToCommit'](detection, validatedInput);
+                case 'reset-branch':
+                    return await executor['executeResetBranch'](detection, validatedInput);
+                default:
+                    throw new Error(`Ação '${validatedInput.action}' não suportada`);
+            }
         }
         catch (error) {
-            throw new Error(`Falha ao executar reset para branch: ${error instanceof Error ? error.message : String(error)}`);
+            executor.errorHandler.addError(error);
+            return executor.errorHandler.toUniversalResponse();
         }
     }
 };