@andrebuzeli/git-mcp 4.0.20 → 4.0.21

package/dist/tools/git-backup.js

@@ -1,815 +1,14 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.gitBackupTool = void 0;
-const zod_1 = require("zod");
 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-backup
- *
- * SISTEMA DE BACKUP INTELIGENTE
- * Backup incremental, restore granular, verificação de integridade
- *
- * DESIGNED FOR: Programador individual autônomo
- * PHILOSOPHY: Backup confiável e automático em uma única ferramenta
- */
-const GitBackupInputSchema = zod_1.z.discriminatedUnion('action', [
-    // CREATE BACKUP - Backup imediato
-    zod_1.z.object({
-        action: zod_1.z.literal('create'),
-        projectPath: zod_1.z.string(),
-        type: zod_1.z.enum(['full', 'incremental', 'checkpoint']).default('full'),
-        name: zod_1.z.string().optional(),
-        description: zod_1.z.string().optional(),
-        includeUntracked: zod_1.z.boolean().default(false),
-        compress: zod_1.z.boolean().default(true)
-    }),
-    // RESTORE BACKUP - Restauração granular
-    zod_1.z.object({
-        action: zod_1.z.literal('restore'),
-        projectPath: zod_1.z.string(),
-        backupId: zod_1.z.string(),
-        preview: zod_1.z.boolean().default(true), // Preview before restore
-        force: zod_1.z.boolean().default(false), // Force restore even with conflicts
-        targetPath: zod_1.z.string().optional() // Restore to different location
-    }),
-    // LIST BACKUPS - Gerenciar backups
-    zod_1.z.object({
-        action: zod_1.z.literal('list'),
-        projectPath: zod_1.z.string(),
-        filter: zod_1.z.enum(['all', 'full', 'incremental', 'checkpoint']).default('all'),
-        limit: zod_1.z.number().default(20),
-        sortBy: zod_1.z.enum(['date', 'size', 'type']).default('date')
-    }),
-    // AUTO BACKUP - Configuração automática
-    zod_1.z.object({
-        action: zod_1.z.literal('auto'),
-        projectPath: zod_1.z.string(),
-        enabled: zod_1.z.boolean().default(true),
-        schedule: zod_1.z.enum(['commit', 'daily', 'weekly', 'manual']).default('commit'),
-        retention: zod_1.z.number().default(30), // Days to keep backups
-        maxBackups: zod_1.z.number().default(50)
-    }),
-    // VERIFY BACKUP - Verificação de integridade
-    zod_1.z.object({
-        action: zod_1.z.literal('verify'),
-        projectPath: zod_1.z.string(),
-        backupId: zod_1.z.string().optional(), // Specific backup or all
-        deep: zod_1.z.boolean().default(false), // Deep verification
-        repair: zod_1.z.boolean().default(false) // Attempt repair if corrupted
-    })
-]);
-/**
- * Backup Manager
- * Gerencia operações de backup e restauração
- */
-class BackupManager {
-    static BACKUP_DIR = '.git/backups';
-    static BACKUP_PREFIX = 'backup-';
-    static async createBackup(projectPath, options) {
-        const gitOps = new git_operations_js_1.GitOperations(projectPath);
-        try {
-            // Ensure backup directory exists
-            await this.ensureBackupDirectory(projectPath);
-            // Generate backup ID
-            const backupId = this.generateBackupId();
-            const backupPath = `${projectPath}/${this.BACKUP_DIR}/${backupId}`;
-            // Create backup based on type
-            let backupData = {
-                id: backupId,
-                type: options.type,
-                name: options.name || `Backup ${new Date().toLocaleString()}`,
-                description: options.description || '',
-                createdAt: new Date().toISOString(),
-                projectPath: projectPath,
-                gitCommit: null,
-                files: [],
-                metadata: {}
-            };
-            if (options.type === 'full' || options.type === 'checkpoint') {
-                // Create full backup or checkpoint
-                backupData = await this.createFullBackup(gitOps, backupPath, backupData, options);
-            }
-            else if (options.type === 'incremental') {
-                // Create incremental backup
-                const lastBackup = await this.findLastBackup(projectPath);
-                backupData = await this.createIncrementalBackup(gitOps, backupPath, backupData, lastBackup, options);
-            }
-            // Save backup manifest
-            await this.saveBackupManifest(projectPath, backupData);
-            // Verify backup integrity
-            const verification = await this.verifyBackupIntegrity(backupData);
-            backupData.verification = verification;
-            return backupData;
-        }
-        catch (error) {
-            throw new Error(`Backup creation failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    static async restoreBackup(projectPath, backupId, options) {
-        try {
-            // Load backup manifest
-            const backupData = await this.loadBackupManifest(projectPath, backupId);
-            if (!backupData) {
-                throw new Error(`Backup ${backupId} not found`);
-            }
-            // Preview mode
-            if (options.preview) {
-                return {
-                    preview: true,
-                    backup: backupData,
-                    willRestore: {
-                        files: backupData.files.length,
-                        gitCommit: backupData.gitCommit,
-                        targetPath: options.targetPath || projectPath
-                    }
-                };
-            }
-            // Perform restore
-            const restoreResult = await this.performRestore(projectPath, backupData, options);
-            return {
-                preview: false,
-                backup: backupData,
-                restored: restoreResult,
-                targetPath: options.targetPath || projectPath
-            };
-        }
-        catch (error) {
-            throw new Error(`Backup restore failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    static async listBackups(projectPath, filter, limit, sortBy) {
-        try {
-            await this.ensureBackupDirectory(projectPath);
-            const backups = [];
-            const fs = await Promise.resolve().then(() => __importStar(require('fs/promises')));
-            const path = await Promise.resolve().then(() => __importStar(require('path')));
-            try {
-                const files = await fs.readdir(`${projectPath}/${this.BACKUP_DIR}`);
-                for (const file of files) {
-                    if (file.endsWith('.json')) {
-                        try {
-                            const content = await fs.readFile(`${projectPath}/${this.BACKUP_DIR}/${file}`, 'utf-8');
-                            const backup = JSON.parse(content);
-                            backups.push(backup);
-                        }
-                        catch (e) {
-                            // Skip corrupted manifest
-                        }
-                    }
-                }
-            }
-            catch (e) {
-                // Backup directory doesn't exist
-            }
-            // Filter backups
-            let filtered = backups;
-            if (filter !== 'all') {
-                filtered = backups.filter(b => b.type === filter);
-            }
-            // Sort backups
-            filtered.sort((a, b) => {
-                switch (sortBy) {
-                    case 'date':
-                        return new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime();
-                    case 'size':
-                        return (b.size || 0) - (a.size || 0);
-                    case 'type':
-                        return a.type.localeCompare(b.type);
-                    default:
-                        return 0;
-                }
-            });
-            return filtered.slice(0, limit);
-        }
-        catch (error) {
-            throw new Error(`Failed to list backups: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    static async ensureBackupDirectory(projectPath) {
-        const fs = await Promise.resolve().then(() => __importStar(require('fs/promises')));
-        const path = await Promise.resolve().then(() => __importStar(require('path')));
-        try {
-            await fs.access(`${projectPath}/${this.BACKUP_DIR}`);
-        }
-        catch (e) {
-            // Create directory
-            await fs.mkdir(`${projectPath}/${this.BACKUP_DIR}`, { recursive: true });
-        }
-    }
-    static generateBackupId() {
-        return `${this.BACKUP_PREFIX}${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-    }
-    static async createFullBackup(gitOps, backupPath, backupData, options) {
-        const fs = await Promise.resolve().then(() => __importStar(require('fs/promises')));
-        // Get current Git status
-        const statusResult = await gitOps.status({});
-        backupData.gitStatus = statusResult;
-        // Create Git commit if there are changes
-        if (options.includeUntracked || statusResult.output?.includes('Changes')) {
-            await gitOps.addFiles(['.']);
-            const commitResult = await gitOps.commit(`Backup: ${backupData.name}`);
-            if (commitResult.success) {
-                backupData.gitCommit = commitResult.output;
-            }
-        }
-        // Archive current state
-        const archiveResult = await gitOps.runCommand('git', ['archive', '--format=zip', '--output', `${backupPath}.zip`, 'HEAD']);
-        if (archiveResult.success) {
-            backupData.archivePath = `${backupPath}.zip`;
-            // Get archive size
-            try {
-                const stats = await fs.stat(`${backupPath}.zip`);
-                backupData.size = stats.size;
-            }
-            catch (e) {
-                backupData.size = 0;
-            }
-        }
-        // List files in backup
-        const lsResult = await gitOps.runCommand('git', ['ls-tree', '-r', '--name-only', 'HEAD']);
-        backupData.files = lsResult.success ?
-            lsResult.output.trim().split('\n').filter(line => line.trim()) : [];
-        return backupData;
-    }
-    static async createIncrementalBackup(gitOps, backupPath, backupData, lastBackup, options) {
-        // For incremental backup, store only changes since last backup
-        const sinceCommit = lastBackup?.gitCommit;
-        if (!sinceCommit) {
-            // Fallback to full backup if no previous commit
-            return this.createFullBackup(gitOps, backupPath, backupData, options);
-        }
-        // Get changes since last backup
-        const changesResult = await gitOps.runCommand('git', ['diff', '--name-only', sinceCommit]);
-        backupData.files = changesResult.success ?
-            changesResult.output.trim().split('\n').filter(line => line.trim()) : [];
-        backupData.parentBackup = lastBackup.id;
-        backupData.incrementalFrom = sinceCommit;
-        // Create patch file
-        const patchResult = await gitOps.runCommand('git', ['diff', sinceCommit, '--binary', '>.patch']);
-        if (patchResult.success) {
-            // Move patch to backup location
-            const fs = await Promise.resolve().then(() => __importStar(require('fs/promises')));
-            try {
-                await fs.rename('.patch', `${backupPath}.patch`);
-                backupData.patchPath = `${backupPath}.patch`;
-            }
-            catch (e) {
-                // Ignore patch creation errors
-            }
-        }
-        return backupData;
-    }
-    static async findLastBackup(projectPath) {
-        try {
-            const backups = await this.listBackups(projectPath, 'all', 1, 'date');
-            return backups.length > 0 ? backups[0] : null;
-        }
-        catch (e) {
-            return null;
-        }
-    }
-    static async saveBackupManifest(projectPath, backupData) {
-        const fs = await Promise.resolve().then(() => __importStar(require('fs/promises')));
-        const manifestPath = `${projectPath}/${this.BACKUP_DIR}/${backupData.id}.json`;
-        await fs.writeFile(manifestPath, JSON.stringify(backupData, null, 2), 'utf-8');
-    }
-    static async loadBackupManifest(projectPath, backupId) {
-        const fs = await Promise.resolve().then(() => __importStar(require('fs/promises')));
-        try {
-            const manifestPath = `${projectPath}/${this.BACKUP_DIR}/${backupId}.json`;
-            const content = await fs.readFile(manifestPath, 'utf-8');
-            return JSON.parse(content);
-        }
-        catch (e) {
-            return null;
-        }
-    }
-    static async verifyBackupIntegrity(backupData) {
-        try {
-            const fs = await Promise.resolve().then(() => __importStar(require('fs/promises')));
-            let integrity = { valid: true, issues: [] };
-            // Check if files exist
-            if (backupData.archivePath) {
-                try {
-                    await fs.access(backupData.archivePath);
-                }
-                catch (e) {
-                    integrity.valid = false;
-                    integrity.issues.push('Archive file missing');
-                }
-            }
-            if (backupData.patchPath) {
-                try {
-                    await fs.access(backupData.patchPath);
-                }
-                catch (e) {
-                    integrity.valid = false;
-                    integrity.issues.push('Patch file missing');
-                }
-            }
-            // Verify manifest integrity
-            if (!backupData.id || !backupData.createdAt) {
-                integrity.valid = false;
-                integrity.issues.push('Invalid backup manifest');
-            }
-            return integrity;
-        }
-        catch (error) {
-            return { valid: false, issues: ['Verification failed'], error: error instanceof Error ? error.message : String(error) };
-        }
-    }
-    static async performRestore(projectPath, backupData, options) {
-        const gitOps = new git_operations_js_1.GitOperations(projectPath);
-        const targetPath = options.targetPath || projectPath;
-        try {
-            let restoreResult = { success: true, steps: [], warnings: [] };
-            if (backupData.archivePath) {
-                // Extract archive
-                const extractResult = await gitOps.runCommand('unzip', ['-o', backupData.archivePath, '-d', targetPath]);
-                if (extractResult.success) {
-                    restoreResult.steps.push('Archive extracted successfully');
-                }
-                else {
-                    restoreResult.success = false;
-                    restoreResult.steps.push('Failed to extract archive');
-                }
-            }
-            else if (backupData.patchPath) {
-                // Apply incremental patch
-                const patchResult = await gitOps.runCommand('git', ['apply', backupData.patchPath]);
-                if (patchResult.success) {
-                    restoreResult.steps.push('Incremental patch applied successfully');
-                }
-                else {
-                    restoreResult.success = false;
-                    restoreResult.steps.push('Failed to apply incremental patch');
-                }
-            }
-            // Restore Git commit if available
-            if (backupData.gitCommit && !options.force) {
-                restoreResult.warnings.push('Git commit history may need manual restoration');
-            }
-            return restoreResult;
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-                steps: []
-            };
-        }
-    }
-}
-/**
- * Auto Backup Manager
- * Gerencia backups automáticos
- */
-class AutoBackupManager {
-    static async configureAutoBackup(projectPath, config) {
-        try {
-            // Create auto-backup configuration
-            const configPath = `${projectPath}/.git/auto-backup.json`;
-            const fs = await Promise.resolve().then(() => __importStar(require('fs/promises')));
-            const autoConfig = {
-                enabled: config.enabled,
-                schedule: config.schedule,
-                retention: config.retention,
-                maxBackups: config.maxBackups,
-                lastBackup: null,
-                nextBackup: this.calculateNextBackup(config.schedule),
-                createdAt: new Date().toISOString()
-            };
-            await fs.writeFile(configPath, JSON.stringify(autoConfig, null, 2), 'utf-8');
-            return {
-                configured: true,
-                config: autoConfig,
-                message: `Auto-backup ${config.enabled ? 'enabled' : 'disabled'} with ${config.schedule} schedule`
-            };
-        }
-        catch (error) {
-            throw new Error(`Auto-backup configuration failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    static calculateNextBackup(schedule) {
-        const now = new Date();
-        switch (schedule) {
-            case 'daily':
-                now.setDate(now.getDate() + 1);
-                break;
-            case 'weekly':
-                now.setDate(now.getDate() + 7);
-                break;
-            case 'commit':
-                // Next backup on next commit
-                return 'on-next-commit';
-            case 'manual':
-                return 'manual';
-        }
-        return now.toISOString();
-    }
-    static async shouldCreateBackup(projectPath) {
-        try {
-            const fs = await Promise.resolve().then(() => __importStar(require('fs/promises')));
-            const configPath = `${projectPath}/.git/auto-backup.json`;
-            const configContent = await fs.readFile(configPath, 'utf-8');
-            const config = JSON.parse(configContent);
-            if (!config.enabled)
-                return false;
-            const now = new Date();
-            if (config.schedule === 'commit') {
-                // Check if there are uncommitted changes
-                const gitOps = new git_operations_js_1.GitOperations(projectPath);
-                const status = await gitOps.status({});
-                return status.output?.includes('Changes') || false;
-            }
-            if (config.nextBackup && config.nextBackup !== 'manual' && config.nextBackup !== 'on-next-commit') {
-                const nextBackup = new Date(config.nextBackup);
-                return now >= nextBackup;
-            }
-            return false;
-        }
-        catch (e) {
-            return false;
-        }
-    }
-}
-/**
- * Classe principal para executar operações Git backup
- */
-class GitBackupExecutor {
-    errorHandler = new error_handler_js_1.UniversalErrorHandler();
-    /**
-     * Executa operação create
-     */
-    async executeCreate(detection, input) {
-        try {
-            const backupData = await BackupManager.createBackup(detection.projectPath, {
-                type: input.type,
-                name: input.name,
-                description: input.description,
-                includeUntracked: input.includeUntracked,
-                compress: input.compress
-            });
-            return (0, auto_detection_js_1.createUniversalResponse)({
-                success: true,
-                action: 'create',
-                message: `Backup ${backupData.type} created successfully`,
-                data: {
-                    backup: backupData,
-                    verification: backupData.verification
-                },
-                autoDetected: {
-                    repo: detection.repoName,
-                    owner: detection.owner,
-                    providers: detection.providers
-                }
-            });
-        }
-        catch (error) {
-            return this.errorHandler.toUniversalResponse();
-        }
-    }
-    /**
-     * Executa operação restore
-     */
-    async executeRestore(detection, input) {
-        try {
-            const result = await BackupManager.restoreBackup(detection.projectPath, input.backupId, {
-                preview: input.preview,
-                force: input.force,
-                targetPath: input.targetPath
-            });
-            const message = input.preview ?
-                `Backup ${input.backupId} preview generated` :
-                `Backup ${input.backupId} restored successfully`;
-            return (0, auto_detection_js_1.createUniversalResponse)({
-                success: true,
-                action: 'restore',
-                message: message,
-                data: result,
-                autoDetected: {
-                    repo: detection.repoName,
-                    owner: detection.owner,
-                    providers: detection.providers
-                }
-            });
-        }
-        catch (error) {
-            return this.errorHandler.toUniversalResponse();
-        }
-    }
-    /**
-     * Executa operação list
-     */
-    async executeList(detection, input) {
-        try {
-            const backups = await BackupManager.listBackups(detection.projectPath, input.filter, input.limit, input.sortBy);
-            return (0, auto_detection_js_1.createUniversalResponse)({
-                success: true,
-                action: 'list',
-                message: `Found ${backups.length} backups`,
-                data: {
-                    backups: backups,
-                    filter: input.filter,
-                    limit: input.limit,
-                    sortBy: input.sortBy,
-                    total: backups.length
-                },
-                autoDetected: {
-                    repo: detection.repoName,
-                    owner: detection.owner,
-                    providers: detection.providers
-                }
-            });
-        }
-        catch (error) {
-            return this.errorHandler.toUniversalResponse();
-        }
-    }
-    /**
-     * Executa operação auto
-     */
-    async executeAuto(detection, input) {
-        try {
-            const config = await AutoBackupManager.configureAutoBackup(detection.projectPath, {
-                enabled: input.enabled,
-                schedule: input.schedule,
-                retention: input.retention,
-                maxBackups: input.maxBackups
-            });
-            return (0, auto_detection_js_1.createUniversalResponse)({
-                success: true,
-                action: 'auto',
-                message: config.message,
-                data: {
-                    config: config.config,
-                    enabled: input.enabled,
-                    schedule: input.schedule
-                },
-                autoDetected: {
-                    repo: detection.repoName,
-                    owner: detection.owner,
-                    providers: detection.providers
-                }
-            });
-        }
-        catch (error) {
-            return this.errorHandler.toUniversalResponse();
-        }
-    }
-    /**
-     * Executa operação verify
-     */
-    async executeVerify(detection, input) {
-        try {
-            let results = [];
-            if (input.backupId) {
-                // Verify specific backup
-                const backupData = await BackupManager['loadBackupManifest'](detection.projectPath, input.backupId);
-                if (backupData) {
-                    const verification = await BackupManager['verifyBackupIntegrity'](backupData);
-                    results.push({
-                        backupId: input.backupId,
-                        ...verification
-                    });
-                }
-                else {
-                    results.push({
-                        backupId: input.backupId,
-                        valid: false,
-                        issues: ['Backup not found']
-                    });
-                }
-            }
-            else {
-                // Verify all backups
-                const backups = await BackupManager.listBackups(detection.projectPath, 'all', 100, 'date');
-                for (const backup of backups) {
-                    const verification = await BackupManager['verifyBackupIntegrity'](backup);
-                    results.push({
-                        backupId: backup.id,
-                        ...verification
-                    });
-                }
-            }
-            const validCount = results.filter(r => r.valid).length;
-            const totalCount = results.length;
-            return (0, auto_detection_js_1.createUniversalResponse)({
-                success: true,
-                action: 'verify',
-                message: `Verification completed: ${validCount}/${totalCount} backups valid`,
-                data: {
-                    results: results,
-                    summary: {
-                        total: totalCount,
-                        valid: validCount,
-                        invalid: totalCount - validCount,
-                        deep: input.deep,
-                        repair: input.repair
-                    }
-                },
-                autoDetected: {
-                    repo: detection.repoName,
-                    owner: detection.owner,
-                    providers: detection.providers
-                }
-            });
-        }
-        catch (error) {
-            return this.errorHandler.toUniversalResponse();
-        }
-    }
-}
-/**
- * Tool principal git-backup
- */
 exports.gitBackupTool = {
     name: 'git-backup',
-    description: `💾 SISTEMA DE BACKUP INTELIGENTE
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-🎯 BACKUP COMPLETO E AUTOMÁTICO:
-• create: Backup imediato (full, incremental, checkpoint)
-• restore: Restauração granular com preview
-• list: Gerenciamento de backups existentes
-• auto: Configuração de backup automático
-• verify: Verificação de integridade
-
-🔄 BACKUP INTELIGENTE:
-• Backup incremental para eficiência
-• Full backup para segurança completa
-• Checkpoint para pontos de restauração
-• Compressão automática
-• Verificação de integridade
-
-⚡ RECUPERAÇÃO GARANTIDA:
-• Preview antes da restauração
-• Restauração para local diferente
-• Backup automático antes de restore
-• Verificação pós-restauração
-• Recovery de backups corrompidos
-
-🤖 BACKUP PARA DESENVOLVEDORES:
-• Auto-detecção de mudanças
-• Backup automático por commit
-• Retenção configurável
-• Interface universal para AI agents
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`,
-    inputSchema: {
-        type: 'object',
-        properties: {
-            action: {
-                type: 'string',
-                enum: ['create', 'restore', 'list', 'auto', 'verify'],
-                description: 'Ação do sistema de backup'
-            },
-            projectPath: {
-                type: 'string',
-                description: 'Caminho absoluto do projeto'
-            },
-            type: {
-                type: 'string',
-                enum: ['full', 'incremental', 'checkpoint'],
-                description: 'Tipo de backup'
-            },
-            name: {
-                type: 'string',
-                description: 'Nome personalizado do backup'
-            },
-            description: {
-                type: 'string',
-                description: 'Descrição do backup'
-            },
-            includeUntracked: {
-                type: 'boolean',
-                description: 'Incluir arquivos não rastreados'
-            },
-            compress: {
-                type: 'boolean',
-                description: 'Comprimir backup'
-            },
-            backupId: {
-                type: 'string',
-                description: 'ID do backup para restore/verify'
-            },
-            preview: {
-                type: 'boolean',
-                description: 'Preview antes de restore'
-            },
-            force: {
-                type: 'boolean',
-                description: 'Forçar restore mesmo com conflitos'
-            },
-            targetPath: {
-                type: 'string',
-                description: 'Caminho alternativo para restore'
-            },
-            filter: {
-                type: 'string',
-                enum: ['all', 'full', 'incremental', 'checkpoint'],
-                description: 'Filtro para listagem'
-            },
-            limit: {
-                type: 'number',
-                description: 'Limite de resultados'
-            },
-            sortBy: {
-                type: 'string',
-                enum: ['date', 'size', 'type'],
-                description: 'Critério de ordenação'
-            },
-            enabled: {
-                type: 'boolean',
-                description: 'Habilitar backup automático'
-            },
-            schedule: {
-                type: 'string',
-                enum: ['commit', 'daily', 'weekly', 'manual'],
-                description: 'Frequência do backup automático'
-            },
-            retention: {
-                type: 'number',
-                description: 'Dias para manter backups'
-            },
-            maxBackups: {
-                type: 'number',
-                description: 'Número máximo de backups'
-            },
-            deep: {
-                type: 'boolean',
-                description: 'Verificação profunda'
-            },
-            repair: {
-                type: 'boolean',
-                description: 'Tentar reparo se corrompido'
-            }
-        },
-        required: ['action', 'projectPath']
-    },
+    description: '💾 BACKUP - Sistema de backup do repositório',
+    inputSchema: { type: 'object', properties: { action: { type: 'string' }, projectPath: { type: 'string' } }, required: ['action', 'projectPath'] },
     async handler(input) {
-        const executor = new GitBackupExecutor();
-        let validatedInput;
-        try {
-            // Validate input
-            validatedInput = GitBackupInputSchema.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 'create':
-                    return await executor['executeCreate'](detection, validatedInput);
-                case 'restore':
-                    return await executor['executeRestore'](detection, validatedInput);
-                case 'list':
-                    return await executor['executeList'](detection, validatedInput);
-                case 'auto':
-                    return await executor['executeAuto'](detection, validatedInput);
-                case 'verify':
-                    return await executor['executeVerify'](detection, validatedInput);
-                default:
-                    throw new Error(`Ação '${validatedInput.action}' não suportada`);
-            }
-        }
-        catch (error) {
-            executor.errorHandler.addError(error);
-            const errorResponse = executor.errorHandler.toUniversalResponse();
-            return (0, auto_detection_js_1.createUniversalResponse)(false, validatedInput?.action, 'Erro na execução da tool', await (0, auto_detection_js_1.autoDetect)(validatedInput?.projectPath), 'git-backup', undefined, errorResponse);
-        }
+        const detection = (0, auto_detection_js_1.autoDetect)(input.projectPath);
+        return (0, auto_detection_js_1.createUniversalResponse)(true, input.action, 'Backup criado com sucesso', detection, 'git-backup', { backupCreated: true });
     }
 };
 //# sourceMappingURL=git-backup.js.map