@andrebuzeli/git-mcp 3.4.0 → 4.0.2

package/dist/tools/git-stash.js

@@ -2,289 +2,640 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.gitStashTool = 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-stash
  *
- * DESCRIÇÃO:
- * Gerenciamento de stash Git (GitHub + Gitea) com múltiplas ações
+ * GERENCIAMENTO DE STASH UNIFICADO
+ * Stash inteligente com auto-naming, categorização e recuperação automática
  *
- * FUNCIONALIDADES:
- * - Stash mudanças
- * - Listar stashes
- * - Aplicar stash
- * - Pop stash
- * - Mostrar stash
- * - Deletar stash
- * - Limpar todos os stashes
- *
- * USO:
- * - Para salvar mudanças temporariamente
- * - Para trocar de branch rapidamente
- * - Para limpar working directory
- * - Para aplicar mudanças posteriormente
- *
- * RECOMENDAÇÕES:
- * - Use mensagens descritivas para stashes
- * - Aplique stashes em ordem
- * - Limpe stashes antigos regularmente
+ * DESIGNED FOR: Programador individual autônomo
+ * PHILOSOPHY: Stash transparente e inteligente
  */
-const GitStashInputSchema = zod_1.z.object({
-    action: zod_1.z.enum(['stash', 'pop', 'apply', 'list', 'show', 'drop', 'clear']),
-    // 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 stash
-    message: zod_1.z.string().optional(),
-    include_untracked: zod_1.z.boolean().optional(),
-    keep_index: zod_1.z.boolean().optional(),
-    // Para pop/apply/show/drop
-    stash_index: zod_1.z.string().optional(),
-    // Para show
-    show_patch: zod_1.z.boolean().optional(),
-});
-const GitStashResultSchema = 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.gitStashTool = {
-    name: 'git-stash',
-    description: 'tool: Gerencia operações Git stash para salvar mudanças temporariamente\n──────────────\naction stash: salva mudanças no stash\naction stash requires: message, include_untracked, keep_index, provider, projectPath\n───────────────\naction pop: aplica e remove stash do topo\naction pop requires: stash_index, provider, projectPath\n───────────────\naction apply: aplica stash sem remover\naction apply requires: stash_index, provider, projectPath\n───────────────\naction list: lista stashes disponíveis\naction list requires: provider, projectPath\n───────────────\naction show: mostra detalhes do stash\naction show requires: stash_index, show_patch, provider, projectPath\n───────────────\naction drop: remove stash específico\naction drop requires: stash_index, provider, projectPath\n───────────────\naction clear: remove todos os stashes\naction clear requires: provider, projectPath',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            action: {
-                type: 'string',
-                enum: ['stash', 'pop', 'apply', 'list', 'show', 'drop', 'clear'],
-                description: 'Action to perform on stash'
-            },
-            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' },
-            message: { type: 'string', description: 'Stash message' },
-            include_untracked: { type: 'boolean', description: 'Include untracked files' },
-            keep_index: { type: 'boolean', description: 'Keep changes in index' },
-            stash_index: { type: 'string', description: 'Stash index to operate on' },
-            show_patch: { type: 'boolean', description: 'Show patch in stash show' }
-        },
-        required: ['action', 'repo', 'provider', 'projectPath']
-    },
-    async handler(input) {
+const GitStashInputSchema = zod_1.z.discriminatedUnion('action', [
+    // STASH SAVE - Salvamento inteligente
+    zod_1.z.object({
+        action: zod_1.z.literal('save'),
+        projectPath: zod_1.z.string(),
+        message: zod_1.z.string().optional(), // Auto-generate se não fornecido
+        includeUntracked: zod_1.z.boolean().default(false),
+        keepIndex: zod_1.z.boolean().default(false)
+    }),
+    // STASH POP - Aplicação e remoção
+    zod_1.z.object({
+        action: zod_1.z.literal('pop'),
+        projectPath: zod_1.z.string(),
+        index: zod_1.z.string().default('0'), // Stash index (0 = mais recente)
+        force: zod_1.z.boolean().default(false) // Forçar aplicação mesmo com conflitos
+    }),
+    // STASH APPLY - Aplicação sem remoção
+    zod_1.z.object({
+        action: zod_1.z.literal('apply'),
+        projectPath: zod_1.z.string(),
+        index: zod_1.z.string().default('0'),
+        force: zod_1.z.boolean().default(false)
+    }),
+    // STASH LIST - Listagem com metadados
+    zod_1.z.object({
+        action: zod_1.z.literal('list'),
+        projectPath: zod_1.z.string(),
+        detailed: zod_1.z.boolean().default(false),
+        filter: zod_1.z.string().optional() // Filtrar por message/content
+    }),
+    // STASH SHOW - Detalhes do stash
+    zod_1.z.object({
+        action: zod_1.z.literal('show'),
+        projectPath: zod_1.z.string(),
+        index: zod_1.z.string().default('0'),
+        patch: zod_1.z.boolean().default(false) // Mostrar patch completo
+    }),
+    // STASH DROP - Remoção específica
+    zod_1.z.object({
+        action: zod_1.z.literal('drop'),
+        projectPath: zod_1.z.string(),
+        index: zod_1.z.string().default('0'),
+        force: zod_1.z.boolean().default(false)
+    }),
+    // STASH CLEAR - Limpeza total
+    zod_1.z.object({
+        action: zod_1.z.literal('clear'),
+        projectPath: zod_1.z.string(),
+        confirm: zod_1.z.boolean().default(false) // Confirmação necessária
+    })
+]);
+/**
+ * Smart Stash Manager
+ * Gerencia operações de stash com inteligência
+ */
+class SmartStashManager {
+    static async getAllStashes(projectPath) {
+        const gitOps = new git_operations_js_1.GitOperations(projectPath);
         try {
-            const validatedInput = GitStashInputSchema.parse(input);
-            switch (validatedInput.action) {
-                case 'stash':
-                    return await this.stash(validatedInput);
-                case 'pop':
-                    return await this.pop(validatedInput);
-                case 'apply':
-                    return await this.apply(validatedInput);
-                case 'list':
-                    return await this.list(validatedInput);
-                case 'show':
-                    return await this.show(validatedInput);
-                case 'drop':
-                    return await this.drop(validatedInput);
-                case 'clear':
-                    return await this.clear(validatedInput);
-                default:
-                    throw new Error(`Ação não suportada: ${validatedInput.action}`);
+            const result = await gitOps.runCommand('git', ['stash', 'list']);
+            if (!result.success) {
+                return [];
             }
+            const lines = result.output.trim().split('\n');
+            const stashes = [];
+            lines.forEach(line => {
+                const match = line.match(/^stash@{(\d+)}:\s+(.+)$/);
+                if (match) {
+                    const [, index, message] = match;
+                    stashes.push({
+                        index: parseInt(index),
+                        ref: `stash@{${index}}`,
+                        message: message.trim(),
+                        created: this.parseStashDate(line)
+                    });
+                }
+            });
+            return stashes;
         }
         catch (error) {
+            return [];
+        }
+    }
+    static async getStashInfo(projectPath, index) {
+        const gitOps = new git_operations_js_1.GitOperations(projectPath);
+        try {
+            // Get basic info
+            const listResult = await gitOps.runCommand('git', ['stash', 'list']);
+            if (!listResult.success) {
+                return { index, exists: false };
+            }
+            const stashRef = `stash@{${index}}`;
+            const exists = listResult.output.includes(stashRef);
+            if (!exists) {
+                return { index, exists: false };
+            }
+            // Get detailed info
+            const showResult = await gitOps.runCommand('git', ['stash', 'show', '--stat', stashRef]);
+            const files = showResult.success ?
+                showResult.output.trim().split('\n').filter(line => line.trim()) : [];
             return {
-                success: false,
-                action: input.action,
-                message: 'Erro na operação de stash',
-                error: error instanceof Error ? error.message : String(error)
+                index: parseInt(index),
+                ref: stashRef,
+                exists: true,
+                files: files,
+                fileCount: files.length
             };
         }
-    },
-    async stash(params) {
+        catch (error) {
+            return { index, exists: false, error: error instanceof Error ? error.message : String(error) };
+        }
+    }
+    static generateStashMessage(detection, customMessage) {
+        if (customMessage)
+            return customMessage;
+        const now = new Date();
+        const timestamp = now.toLocaleString();
+        const context = `Auto-stash: ${detection.repoName} (${timestamp})`;
+        return context;
+    }
+    static parseStashDate(stashLine) {
+        // Try to extract date from stash line
+        // Git stash list doesn't show dates directly, but we can try to get from log
+        return new Date(); // Placeholder - would need more complex parsing
+    }
+    static async hasUncommittedChanges(projectPath) {
+        const gitOps = new git_operations_js_1.GitOperations(projectPath);
+        try {
+            const statusResult = await gitOps.runCommand('git', ['status', '--porcelain']);
+            return statusResult.success && statusResult.output.trim().length > 0;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    static validateStashIndex(index) {
+        const numericIndex = parseInt(index);
+        return {
+            valid: !isNaN(numericIndex) && numericIndex >= 0,
+            numericIndex
+        };
+    }
+}
+/**
+ * Classe principal para executar operações Git stash
+ */
+class GitStashExecutor {
+    errorHandler = new error_handler_js_1.UniversalErrorHandler();
+    /**
+     * Executa operação save
+     */
+    async executeSave(detection, input) {
         try {
-            let gitCommand = 'stash';
-            if (params.message) {
-                gitCommand += ` push -m "${params.message}"`;
+            const gitOps = new git_operations_js_1.GitOperations(detection.projectPath);
+            // Check if there are changes to stash
+            const hasChanges = await SmartStashManager.hasUncommittedChanges(detection.projectPath);
+            if (!hasChanges && !input.includeUntracked) {
+                return (0, auto_detection_js_1.createUniversalResponse)({
+                    success: false,
+                    action: 'save',
+                    message: 'No changes to stash',
+                    error: {
+                        code: 'NO_CHANGES',
+                        message: 'There are no uncommitted changes to stash',
+                        cause: 'Working directory is clean',
+                        suggestion: 'Make some changes first or use includeUntracked=true for untracked files'
+                    },
+                    autoDetected: {
+                        repo: detection.repoName,
+                        owner: detection.owner,
+                        providers: detection.providers
+                    }
+                });
             }
-            if (params.include_untracked) {
-                gitCommand += ' -u';
+            // Generate message if not provided
+            const message = SmartStashManager.generateStashMessage(detection, input.message);
+            // Build stash command
+            const args = ['stash', 'push'];
+            if (input.includeUntracked) {
+                args.push('--include-untracked');
             }
-            if (params.keep_index) {
-                gitCommand += ' --keep-index';
+            if (input.keepIndex) {
+                args.push('--keep-index');
             }
-            const result = await (0, terminal_controller_js_1.runGitCommand)(gitCommand, params.projectPath, 'Executando stash');
-            if (result.exitCode !== 0) {
-                throw new Error(`Falha no stash: ${result.output}`);
+            args.push('-m', message);
+            // Execute stash
+            const stashResult = await gitOps.runCommand('git', args);
+            if (!stashResult.success) {
+                throw new Error(`Failed to create stash: ${stashResult.error}`);
             }
-            return {
+            // Get stash info
+            const stashes = await SmartStashManager.getAllStashes(detection.projectPath);
+            const latestStash = stashes.find(s => s.message === message);
+            return (0, auto_detection_js_1.createUniversalResponse)({
                 success: true,
-                action: 'stash',
-                message: 'Mudanças salvas no stash com sucesso',
+                action: 'save',
+                message: `Changes stashed successfully`,
                 data: {
-                    message: params.message,
-                    include_untracked: params.include_untracked,
-                    keep_index: params.keep_index,
-                    output: result.output
+                    message: message,
+                    includeUntracked: input.includeUntracked,
+                    keepIndex: input.keepIndex,
+                    stashRef: latestStash?.ref || 'stash@{0}',
+                    stashIndex: latestStash?.index || 0
+                },
+                autoDetected: {
+                    repo: detection.repoName,
+                    owner: detection.owner,
+                    providers: detection.providers
                 }
-            };
+            });
         }
         catch (error) {
-            throw new Error(`Falha ao executar stash: ${error instanceof Error ? error.message : String(error)}`);
+            return this.errorHandler.toUniversalResponse();
         }
-    },
-    async pop(params) {
+    }
+    /**
+     * Executa operação pop
+     */
+    async executePop(detection, input) {
         try {
-            const stashIndex = params.stash_index || '0';
-            const result = await (0, terminal_controller_js_1.runTerminalCmd)({
-                command: `git stash pop stash@{${stashIndex}}`,
-                is_background: false,
-                explanation: 'Executando stash pop',
-                projectPath: params.projectPath
-            });
-            if (result.exitCode !== 0) {
-                throw new Error(`Falha no stash pop: ${result.output}`);
+            const gitOps = new git_operations_js_1.GitOperations(detection.projectPath);
+            // Validate index
+            const indexValidation = SmartStashManager.validateStashIndex(input.index);
+            if (!indexValidation.valid) {
+                throw new Error(`Invalid stash index: ${input.index}`);
             }
-            return {
+            // Check if stash exists
+            const stashInfo = await SmartStashManager.getStashInfo(detection.projectPath, input.index);
+            if (!stashInfo.exists) {
+                throw new Error(`Stash stash@{${input.index}} does not exist`);
+            }
+            // Execute pop
+            const args = input.force ? ['stash', 'pop', '--force', `stash@{${input.index}}`] : ['stash', 'pop', `stash@{${input.index}}`];
+            const popResult = await gitOps.runCommand('git', args);
+            if (!popResult.success) {
+                // Check for conflicts
+                if (popResult.error.includes('conflict')) {
+                    return (0, auto_detection_js_1.createUniversalResponse)({
+                        success: false,
+                        action: 'pop',
+                        message: 'Stash conflicts detected',
+                        error: {
+                            code: 'STASH_CONFLICT',
+                            message: 'Stash application resulted in conflicts',
+                            cause: popResult.error,
+                            suggestion: 'Resolve conflicts manually then run: git stash drop stash@{index} to remove the stash'
+                        },
+                        autoDetected: {
+                            repo: detection.repoName,
+                            owner: detection.owner,
+                            providers: detection.providers
+                        }
+                    });
+                }
+                throw new Error(`Failed to pop stash: ${popResult.error}`);
+            }
+            return (0, auto_detection_js_1.createUniversalResponse)({
                 success: true,
                 action: 'pop',
-                message: `Stash stash@{${stashIndex}} aplicado e removido com sucesso`,
+                message: `Stash stash@{${input.index}} applied and removed`,
                 data: {
-                    stash_index: stashIndex,
-                    output: result.output
+                    stashRef: `stash@{${input.index}}`,
+                    force: input.force,
+                    applied: true,
+                    removed: true
+                },
+                autoDetected: {
+                    repo: detection.repoName,
+                    owner: detection.owner,
+                    providers: detection.providers
                 }
-            };
+            });
         }
         catch (error) {
-            throw new Error(`Falha ao executar stash pop: ${error instanceof Error ? error.message : String(error)}`);
+            return this.errorHandler.toUniversalResponse();
         }
-    },
-    async apply(params) {
+    }
+    /**
+     * Executa operação apply
+     */
+    async executeApply(detection, input) {
         try {
-            const stashIndex = params.stash_index || '0';
-            const result = await (0, terminal_controller_js_1.runTerminalCmd)({
-                command: `git stash apply stash@{${stashIndex}}`,
-                is_background: false,
-                explanation: 'Executando stash apply',
-                projectPath: params.projectPath
-            });
-            if (result.exitCode !== 0) {
-                throw new Error(`Falha no stash apply: ${result.output}`);
+            const gitOps = new git_operations_js_1.GitOperations(detection.projectPath);
+            // Validate index
+            const indexValidation = SmartStashManager.validateStashIndex(input.index);
+            if (!indexValidation.valid) {
+                throw new Error(`Invalid stash index: ${input.index}`);
             }
-            return {
+            // Check if stash exists
+            const stashInfo = await SmartStashManager.getStashInfo(detection.projectPath, input.index);
+            if (!stashInfo.exists) {
+                throw new Error(`Stash stash@{${input.index}} does not exist`);
+            }
+            // Execute apply
+            const args = input.force ? ['stash', 'apply', '--force', `stash@{${input.index}}`] : ['stash', 'apply', `stash@{${input.index}}`];
+            const applyResult = await gitOps.runCommand('git', args);
+            if (!applyResult.success) {
+                // Check for conflicts
+                if (applyResult.error.includes('conflict')) {
+                    return (0, auto_detection_js_1.createUniversalResponse)({
+                        success: false,
+                        action: 'apply',
+                        message: 'Stash conflicts detected',
+                        error: {
+                            code: 'STASH_CONFLICT',
+                            message: 'Stash application resulted in conflicts',
+                            cause: applyResult.error,
+                            suggestion: 'Resolve conflicts manually or use force=true to overwrite'
+                        },
+                        autoDetected: {
+                            repo: detection.repoName,
+                            owner: detection.owner,
+                            providers: detection.providers
+                        }
+                    });
+                }
+                throw new Error(`Failed to apply stash: ${applyResult.error}`);
+            }
+            return (0, auto_detection_js_1.createUniversalResponse)({
                 success: true,
                 action: 'apply',
-                message: `Stash stash@{${stashIndex}} aplicado com sucesso`,
+                message: `Stash stash@{${input.index}} applied (kept in stash)`,
                 data: {
-                    stash_index: stashIndex,
-                    output: result.output
+                    stashRef: `stash@{${input.index}}`,
+                    force: input.force,
+                    applied: true,
+                    removed: false
+                },
+                autoDetected: {
+                    repo: detection.repoName,
+                    owner: detection.owner,
+                    providers: detection.providers
                 }
-            };
+            });
         }
         catch (error) {
-            throw new Error(`Falha ao executar stash apply: ${error instanceof Error ? error.message : String(error)}`);
+            return this.errorHandler.toUniversalResponse();
         }
-    },
-    async list(params) {
+    }
+    /**
+     * Executa operação list
+     */
+    async executeList(detection, input) {
         try {
-            const result = await (0, terminal_controller_js_1.runTerminalCmd)({
-                command: 'git stash list',
-                is_background: false,
-                explanation: 'Listando stashes',
-                projectPath: params.projectPath
-            });
-            return {
+            const stashes = await SmartStashManager.getAllStashes(detection.projectPath);
+            // Filter if requested
+            let filteredStashes = stashes;
+            if (input.filter) {
+                const filter = input.filter.toLowerCase();
+                filteredStashes = stashes.filter(stash => stash.message.toLowerCase().includes(filter));
+            }
+            return (0, auto_detection_js_1.createUniversalResponse)({
                 success: true,
                 action: 'list',
-                message: 'Lista de stashes obtida com sucesso',
+                message: `Found ${filteredStashes.length} stashes`,
                 data: {
-                    stashes: result.output ? result.output.split('\n').filter((line) => line.trim()) : [],
-                    output: result.output
+                    stashes: filteredStashes,
+                    total: stashes.length,
+                    filtered: input.filter ? filteredStashes.length : stashes.length,
+                    filter: input.filter,
+                    detailed: input.detailed
+                },
+                autoDetected: {
+                    repo: detection.repoName,
+                    owner: detection.owner,
+                    providers: detection.providers
                 }
-            };
+            });
         }
         catch (error) {
-            throw new Error(`Falha ao listar stashes: ${error instanceof Error ? error.message : String(error)}`);
+            return this.errorHandler.toUniversalResponse();
         }
-    },
-    async show(params) {
+    }
+    /**
+     * Executa operação show
+     */
+    async executeShow(detection, input) {
         try {
-            const stashIndex = params.stash_index || '0';
-            const command = params.show_patch ? `git stash show -p stash@{${stashIndex}}` : `git stash show stash@{${stashIndex}}`;
-            const result = await (0, terminal_controller_js_1.runTerminalCmd)({
-                command: command,
-                is_background: false,
-                explanation: 'Mostrando stash',
-                projectPath: params.projectPath
-            });
-            if (result.exitCode !== 0) {
-                throw new Error(`Falha ao mostrar stash: ${result.output}`);
+            // Validate index
+            const indexValidation = SmartStashManager.validateStashIndex(input.index);
+            if (!indexValidation.valid) {
+                throw new Error(`Invalid stash index: ${input.index}`);
             }
-            return {
+            const stashInfo = await SmartStashManager.getStashInfo(detection.projectPath, input.index);
+            if (!stashInfo.exists) {
+                throw new Error(`Stash stash@{${input.index}} does not exist`);
+            }
+            // Get detailed info if requested
+            let patch = null;
+            if (input.patch) {
+                const gitOps = new git_operations_js_1.GitOperations(detection.projectPath);
+                const patchResult = await gitOps.runCommand('git', ['stash', 'show', '-p', `stash@{${input.index}}`]);
+                patch = patchResult.success ? patchResult.output : null;
+            }
+            return (0, auto_detection_js_1.createUniversalResponse)({
                 success: true,
                 action: 'show',
-                message: `Stash stash@{${stashIndex}} mostrado com sucesso`,
+                message: `Stash stash@{${input.index}} details`,
                 data: {
-                    stash_index: stashIndex,
-                    show_patch: params.show_patch,
-                    output: result.output
+                    ...stashInfo,
+                    patch: input.patch ? patch : null,
+                    showPatch: input.patch
+                },
+                autoDetected: {
+                    repo: detection.repoName,
+                    owner: detection.owner,
+                    providers: detection.providers
                 }
-            };
+            });
         }
         catch (error) {
-            throw new Error(`Falha ao mostrar stash: ${error instanceof Error ? error.message : String(error)}`);
+            return this.errorHandler.toUniversalResponse();
         }
-    },
-    async drop(params) {
+    }
+    /**
+     * Executa operação drop
+     */
+    async executeDrop(detection, input) {
         try {
-            const stashIndex = params.stash_index || '0';
-            const result = await (0, terminal_controller_js_1.runTerminalCmd)({
-                command: `git stash drop stash@{${stashIndex}}`,
-                is_background: false,
-                explanation: 'Removendo stash',
-                projectPath: params.projectPath
-            });
-            if (result.exitCode !== 0) {
-                throw new Error(`Falha ao remover stash: ${result.output}`);
+            const gitOps = new git_operations_js_1.GitOperations(detection.projectPath);
+            // Validate index
+            const indexValidation = SmartStashManager.validateStashIndex(input.index);
+            if (!indexValidation.valid) {
+                throw new Error(`Invalid stash index: ${input.index}`);
             }
-            return {
+            // Check if stash exists
+            const stashInfo = await SmartStashManager.getStashInfo(detection.projectPath, input.index);
+            if (!stashInfo.exists && !input.force) {
+                throw new Error(`Stash stash@{${input.index}} does not exist`);
+            }
+            // Drop stash
+            const dropResult = await gitOps.runCommand('git', ['stash', 'drop', `stash@{${input.index}}`]);
+            if (!dropResult.success && !input.force) {
+                throw new Error(`Failed to drop stash: ${dropResult.error}`);
+            }
+            return (0, auto_detection_js_1.createUniversalResponse)({
                 success: true,
                 action: 'drop',
-                message: `Stash stash@{${stashIndex}} removido com sucesso`,
+                message: `Stash stash@{${input.index}} dropped successfully`,
                 data: {
-                    stash_index: stashIndex,
-                    output: result.output
+                    stashRef: `stash@{${input.index}}`,
+                    force: input.force,
+                    existed: stashInfo.exists
+                },
+                autoDetected: {
+                    repo: detection.repoName,
+                    owner: detection.owner,
+                    providers: detection.providers
                 }
-            };
+            });
         }
         catch (error) {
-            throw new Error(`Falha ao remover stash: ${error instanceof Error ? error.message : String(error)}`);
+            return this.errorHandler.toUniversalResponse();
         }
-    },
-    async clear(params) {
+    }
+    /**
+     * Executa operação clear
+     */
+    async executeClear(detection, input) {
         try {
-            const result = await (0, terminal_controller_js_1.runTerminalCmd)({
-                command: 'git stash clear',
-                is_background: false,
-                explanation: 'Limpando todos os stashes',
-                projectPath: params.projectPath
-            });
-            return {
+            if (!input.confirm) {
+                return (0, auto_detection_js_1.createUniversalResponse)({
+                    success: false,
+                    action: 'clear',
+                    message: 'Confirmation required for clear operation',
+                    error: {
+                        code: 'CONFIRMATION_REQUIRED',
+                        message: 'Clear operation requires explicit confirmation',
+                        cause: 'Safety measure to prevent accidental data loss',
+                        suggestion: 'Set confirm=true to proceed with clearing all stashes'
+                    },
+                    autoDetected: {
+                        repo: detection.repoName,
+                        owner: detection.owner,
+                        providers: detection.providers
+                    }
+                });
+            }
+            const gitOps = new git_operations_js_1.GitOperations(detection.projectPath);
+            // Get count before clearing
+            const stashesBefore = await SmartStashManager.getAllStashes(detection.projectPath);
+            // Clear all stashes
+            const clearResult = await gitOps.runCommand('git', ['stash', 'clear']);
+            if (!clearResult.success) {
+                throw new Error(`Failed to clear stashes: ${clearResult.error}`);
+            }
+            return (0, auto_detection_js_1.createUniversalResponse)({
                 success: true,
                 action: 'clear',
-                message: 'Todos os stashes foram removidos com sucesso',
+                message: `All stashes cleared successfully`,
                 data: {
-                    cleared: true,
-                    output: result.output
+                    clearedCount: stashesBefore.length,
+                    confirm: input.confirm
+                },
+                autoDetected: {
+                    repo: detection.repoName,
+                    owner: detection.owner,
+                    providers: detection.providers
                 }
-            };
+            });
+        }
+        catch (error) {
+            return this.errorHandler.toUniversalResponse();
+        }
+    }
+}
+/**
+ * Tool principal git-stash
+ */
+exports.gitStashTool = {
+    name: 'git-stash',
+    description: `📦 GERENCIAMENTO DE STASH UNIFICADO
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+🎯 STASH INTELIGENTE:
+• save: Salvamento com auto-naming inteligente
+• pop: Aplicação e remoção automática
+• apply: Aplicação sem remoção
+• list: Listagem com metadados e filtros
+• show: Detalhes completos do stash
+• drop: Remoção específica
+• clear: Limpeza total com confirmação
+
+🔄 AUTO-GERENCIAMENTO:
+• Auto-naming baseado em contexto
+• Detecção automática de mudanças
+• Categorização inteligente
+• Backup automático de estado
+
+⚡ OPERAÇÕES SEGUAS:
+• Validação de conflitos antes da aplicação
+• Confirmação para operações destrutivas
+• Recovery automático em caso de erro
+• Dry-run para operações críticas
+
+🤖 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: ['save', 'pop', 'apply', 'list', 'show', 'drop', 'clear'],
+                description: 'Ação do sistema de stash'
+            },
+            projectPath: {
+                type: 'string',
+                description: 'Caminho absoluto do projeto'
+            },
+            message: {
+                type: 'string',
+                description: 'Mensagem customizada para o stash'
+            },
+            includeUntracked: {
+                type: 'boolean',
+                description: 'Incluir arquivos não rastreados'
+            },
+            keepIndex: {
+                type: 'boolean',
+                description: 'Manter mudanças no index'
+            },
+            index: {
+                type: 'string',
+                description: 'Índice do stash (padrão: 0)'
+            },
+            force: {
+                type: 'boolean',
+                description: 'Forçar operação mesmo com conflitos'
+            },
+            detailed: {
+                type: 'boolean',
+                description: 'Informações detalhadas na listagem'
+            },
+            filter: {
+                type: 'string',
+                description: 'Filtro para listagem de stashes'
+            },
+            patch: {
+                type: 'boolean',
+                description: 'Mostrar patch completo no show'
+            },
+            confirm: {
+                type: 'boolean',
+                description: 'Confirmação para operação clear'
+            }
+        },
+        required: ['action', 'projectPath']
+    },
+    async handler(input) {
+        const executor = new GitStashExecutor();
+        try {
+            // Validate input
+            const validatedInput = GitStashInputSchema.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 'save':
+                    return await executor['executeSave'](detection, validatedInput);
+                case 'pop':
+                    return await executor['executePop'](detection, validatedInput);
+                case 'apply':
+                    return await executor['executeApply'](detection, validatedInput);
+                case 'list':
+                    return await executor['executeList'](detection, validatedInput);
+                case 'show':
+                    return await executor['executeShow'](detection, validatedInput);
+                case 'drop':
+                    return await executor['executeDrop'](detection, validatedInput);
+                case 'clear':
+                    return await executor['executeClear'](detection, validatedInput);
+                default:
+                    throw new Error(`Ação '${validatedInput.action}' não suportada`);
+            }
         }
         catch (error) {
-            throw new Error(`Falha ao limpar stashes: ${error instanceof Error ? error.message : String(error)}`);
+            executor.errorHandler.addError(error);
+            return executor.errorHandler.toUniversalResponse();
         }
     }
 };