@andrebuzeli/git-mcp 5.4.0 → 5.4.2

package/dist/tools/git-automations.js

@@ -1,878 +0,0 @@
-"use strict";
-/**
- * Git Automations Tool
- *
- * Custom automation tool providing comprehensive Git workflow automation.
- * Supports creating, managing, and executing custom Git workflows and sequences.
- *
- * Operations: create, list, run, update, delete, schedule, enable, disable
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GitAutomationsTool = void 0;
-const git_command_executor_js_1 = require("../utils/git-command-executor.js");
-const parameter_validator_js_1 = require("../utils/parameter-validator.js");
-const operation_error_handler_js_1 = require("../utils/operation-error-handler.js");
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-class GitAutomationsTool {
-    gitExecutor;
-    automationsPath;
-    // Built-in automation templates
-    templates = {
-        'release-workflow': {
-            name: 'Release Workflow',
-            description: 'Automated release workflow with versioning and tagging',
-            commands: [
-                'npm version patch',
-                'git push origin --follow-tags',
-                'npm publish'
-            ],
-            trigger: 'manual',
-            category: 'release'
-        },
-        'dependency-update': {
-            name: 'Dependency Update',
-            description: 'Update dependencies and create PR',
-            commands: [
-                'npm update',
-                'npm audit fix',
-                'git add package*.json',
-                'git commit -m "chore: update dependencies"',
-                'git push origin HEAD'
-            ],
-            trigger: 'schedule',
-            schedule: '0 0 * * 0', // Weekly
-            category: 'maintenance'
-        },
-        'code-quality': {
-            name: 'Code Quality Check',
-            description: 'Run linting, testing, and formatting',
-            commands: [
-                'npm run lint',
-                'npm run test',
-                'npm run format'
-            ],
-            trigger: 'pre-commit',
-            category: 'quality'
-        },
-        'deployment': {
-            name: 'Deployment Workflow',
-            description: 'Build and deploy application',
-            commands: [
-                'npm run build',
-                'npm run test',
-                'npm run deploy'
-            ],
-            trigger: 'post-merge',
-            conditions: { branch: 'main' },
-            category: 'deployment'
-        },
-        'backup': {
-            name: 'Repository Backup',
-            description: 'Create repository backup',
-            commands: [
-                'git bundle create backup-$(date +%Y%m%d).bundle --all',
-                'tar -czf backup-$(date +%Y%m%d).tar.gz .git'
-            ],
-            trigger: 'schedule',
-            schedule: '0 2 * * *', // Daily at 2 AM
-            category: 'backup'
-        }
-    };
-    constructor() {
-        this.gitExecutor = new git_command_executor_js_1.GitCommandExecutor();
-        this.automationsPath = path_1.default.join(process.cwd(), '.git-automations');
-    }
-    /**
-     * Execute git-automations operation
-     */
-    async execute(params) {
-        const startTime = Date.now();
-        try {
-            // Validate basic parameters
-            const validation = parameter_validator_js_1.ParameterValidator.validateToolParams('git-automations', params);
-            if (!validation.isValid) {
-                return operation_error_handler_js_1.OperationErrorHandler.createToolError('VALIDATION_ERROR', `Parameter validation failed: ${validation.errors.join(', ')}`, params.action, { validationErrors: validation.errors }, validation.suggestions);
-            }
-            // Validate operation-specific parameters
-            const operationValidation = parameter_validator_js_1.ParameterValidator.validateOperationParams('git-automations', params.action, params);
-            if (!operationValidation.isValid) {
-                return operation_error_handler_js_1.OperationErrorHandler.createToolError('VALIDATION_ERROR', `Operation validation failed: ${operationValidation.errors.join(', ')}`, params.action, { validationErrors: operationValidation.errors }, operationValidation.suggestions);
-            }
-            // Ensure automations directory exists
-            this.ensureAutomationsDirectory();
-            // Route to appropriate handler
-            switch (params.action) {
-                case 'create':
-                    return await this.handleCreate(params, startTime);
-                case 'list':
-                    return await this.handleList(params, startTime);
-                case 'run':
-                    return await this.handleRun(params, startTime);
-                case 'update':
-                    return await this.handleUpdate(params, startTime);
-                case 'delete':
-                    return await this.handleDelete(params, startTime);
-                case 'schedule':
-                    return await this.handleSchedule(params, startTime);
-                case 'enable':
-                    return await this.handleEnable(params, startTime);
-                case 'disable':
-                    return await this.handleDisable(params, startTime);
-                default:
-                    return operation_error_handler_js_1.OperationErrorHandler.createToolError('INVALID_ACTION', `Unknown action: ${params.action}`, params.action, { supportedActions: ['create', 'list', 'run', 'update', 'delete', 'schedule', 'enable', 'disable'] }, ['Use one of the supported actions']);
-            }
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            return operation_error_handler_js_1.OperationErrorHandler.createToolError('EXECUTION_ERROR', `Failed to execute ${params.action}: ${errorMessage}`, params.action, { error: errorMessage }, ['Check the error details and try again']);
-        }
-    }
-    /**
-     * Create automation
-     */
-    async handleCreate(params, startTime) {
-        try {
-            if (!params.name) {
-                return operation_error_handler_js_1.OperationErrorHandler.createToolError('MISSING_NAME', 'Name is required for creating automation', params.action, { name: params.name }, ['Provide name parameter']);
-            }
-            // Check if automation already exists
-            const existingAutomation = this.getAutomation(params.name);
-            if (existingAutomation) {
-                return operation_error_handler_js_1.OperationErrorHandler.createToolError('AUTOMATION_EXISTS', `Automation '${params.name}' already exists`, params.action, { name: params.name }, ['Use update action to modify existing automation', 'Use different name']);
-            }
-            const automation = this.createAutomationDefinition(params);
-            this.saveAutomation(automation);
-            const executionTime = Date.now() - startTime;
-            return {
-                success: true,
-                data: {
-                    automation: {
-                        id: automation.id,
-                        name: automation.name,
-                        trigger: automation.trigger,
-                        enabled: automation.enabled,
-                        commands: automation.commands.length,
-                        created: automation.created
-                    },
-                    message: `Automation '${params.name}' created successfully`,
-                    executionTime
-                }
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            return operation_error_handler_js_1.OperationErrorHandler.createToolError('CREATE_ERROR', `Failed to create automation: ${errorMessage}`, params.action, { name: params.name, error: errorMessage }, ['Check automation definition', 'Verify permissions']);
-        }
-    }
-    /**
-     * List automations
-     */
-    async handleList(params, startTime) {
-        try {
-            const automations = this.getAllAutomations();
-            // Apply filters
-            let filteredAutomations = automations;
-            if (params.filter) {
-                filteredAutomations = automations.filter(automation => automation.name.includes(params.filter) ||
-                    automation.description?.includes(params.filter));
-            }
-            if (params.category) {
-                filteredAutomations = filteredAutomations.filter(automation => automation.category === params.category);
-            }
-            const executionTime = Date.now() - startTime;
-            return {
-                success: true,
-                data: {
-                    automations: filteredAutomations.map(automation => ({
-                        id: automation.id,
-                        name: automation.name,
-                        description: automation.description,
-                        trigger: automation.trigger,
-                        enabled: automation.enabled,
-                        category: automation.category,
-                        commands: automation.commands.length,
-                        created: automation.created,
-                        lastRun: automation.lastRun
-                    })),
-                    count: filteredAutomations.length,
-                    message: `Found ${filteredAutomations.length} automations`,
-                    executionTime
-                }
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            return operation_error_handler_js_1.OperationErrorHandler.createToolError('LIST_ERROR', `Failed to list automations: ${errorMessage}`, params.action, { error: errorMessage }, ['Check automations directory permissions']);
-        }
-    }
-    /**
-     * Run automation
-     */
-    async handleRun(params, startTime) {
-        try {
-            if (!params.name && !params.id) {
-                return operation_error_handler_js_1.OperationErrorHandler.createToolError('MISSING_IDENTIFIER', 'Either name or id is required for running automation', params.action, { name: params.name, id: params.id }, ['Provide name or id parameter']);
-            }
-            const automation = params.name ? this.getAutomation(params.name) : this.getAutomationById(params.id);
-            if (!automation) {
-                return operation_error_handler_js_1.OperationErrorHandler.createToolError('AUTOMATION_NOT_FOUND', `Automation not found: ${params.name || params.id}`, params.action, { name: params.name, id: params.id }, ['Check automation name/id', 'Use list action to see available automations']);
-            }
-            if (!automation.enabled) {
-                return operation_error_handler_js_1.OperationErrorHandler.createToolError('AUTOMATION_DISABLED', `Automation '${automation.name}' is disabled`, params.action, { name: automation.name }, ['Enable the automation first', 'Use enable action']);
-            }
-            const result = await this.executeAutomation(automation, params);
-            const executionTime = Date.now() - startTime;
-            return {
-                success: result.success,
-                data: {
-                    automation: {
-                        id: automation.id,
-                        name: automation.name,
-                        execution: result
-                    },
-                    message: `Automation '${automation.name}' ${result.success ? 'executed successfully' : 'execution failed'}`,
-                    executionTime
-                }
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            return operation_error_handler_js_1.OperationErrorHandler.createToolError('RUN_ERROR', `Failed to run automation: ${errorMessage}`, params.action, { name: params.name, id: params.id, error: errorMessage }, ['Check automation definition', 'Verify commands are valid']);
-        }
-    }
-    /**
-     * Update automation
-     */
-    async handleUpdate(params, startTime) {
-        try {
-            if (!params.name && !params.id) {
-                return operation_error_handler_js_1.OperationErrorHandler.createToolError('MISSING_IDENTIFIER', 'Either name or id is required for updating automation', params.action, { name: params.name, id: params.id }, ['Provide name or id parameter']);
-            }
-            const existingAutomation = params.name ? this.getAutomation(params.name) : this.getAutomationById(params.id);
-            if (!existingAutomation) {
-                return operation_error_handler_js_1.OperationErrorHandler.createToolError('AUTOMATION_NOT_FOUND', `Automation not found: ${params.name || params.id}`, params.action, { name: params.name, id: params.id }, ['Check automation name/id', 'Use list action to see available automations']);
-            }
-            const updatedAutomation = this.updateAutomationDefinition(existingAutomation, params);
-            this.saveAutomation(updatedAutomation);
-            const executionTime = Date.now() - startTime;
-            return {
-                success: true,
-                data: {
-                    automation: {
-                        id: updatedAutomation.id,
-                        name: updatedAutomation.name,
-                        trigger: updatedAutomation.trigger,
-                        enabled: updatedAutomation.enabled,
-                        commands: updatedAutomation.commands.length,
-                        updated: updatedAutomation.updated
-                    },
-                    message: `Automation '${updatedAutomation.name}' updated successfully`,
-                    executionTime
-                }
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            return operation_error_handler_js_1.OperationErrorHandler.createToolError('UPDATE_ERROR', `Failed to update automation: ${errorMessage}`, params.action, { name: params.name, id: params.id, error: errorMessage }, ['Check automation definition', 'Verify permissions']);
-        }
-    }
-    /**
-     * Delete automation
-     */
-    async handleDelete(params, startTime) {
-        try {
-            if (!params.name && !params.id) {
-                return operation_error_handler_js_1.OperationErrorHandler.createToolError('MISSING_IDENTIFIER', 'Either name or id is required for deleting automation', params.action, { name: params.name, id: params.id }, ['Provide name or id parameter']);
-            }
-            const automation = params.name ? this.getAutomation(params.name) : this.getAutomationById(params.id);
-            if (!automation) {
-                return operation_error_handler_js_1.OperationErrorHandler.createToolError('AUTOMATION_NOT_FOUND', `Automation not found: ${params.name || params.id}`, params.action, { name: params.name, id: params.id }, ['Check automation name/id', 'Use list action to see available automations']);
-            }
-            this.deleteAutomation(automation.id);
-            const executionTime = Date.now() - startTime;
-            return {
-                success: true,
-                data: {
-                    automation: {
-                        id: automation.id,
-                        name: automation.name,
-                        deleted: true
-                    },
-                    message: `Automation '${automation.name}' deleted successfully`,
-                    executionTime
-                }
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            return operation_error_handler_js_1.OperationErrorHandler.createToolError('DELETE_ERROR', `Failed to delete automation: ${errorMessage}`, params.action, { name: params.name, id: params.id, error: errorMessage }, ['Check automation exists', 'Verify permissions']);
-        }
-    }
-    /**
-     * Schedule automation
-     */
-    async handleSchedule(params, startTime) {
-        try {
-            if (!params.name && !params.id) {
-                return operation_error_handler_js_1.OperationErrorHandler.createToolError('MISSING_IDENTIFIER', 'Either name or id is required for scheduling automation', params.action, { name: params.name, id: params.id }, ['Provide name or id parameter']);
-            }
-            const automation = params.name ? this.getAutomation(params.name) : this.getAutomationById(params.id);
-            if (!automation) {
-                return operation_error_handler_js_1.OperationErrorHandler.createToolError('AUTOMATION_NOT_FOUND', `Automation not found: ${params.name || params.id}`, params.action, { name: params.name, id: params.id }, ['Check automation name/id', 'Use list action to see available automations']);
-            }
-            // Update automation with schedule
-            automation.schedule = params.schedule;
-            automation.trigger = 'schedule';
-            this.saveAutomation(automation);
-            const executionTime = Date.now() - startTime;
-            return {
-                success: true,
-                data: {
-                    automation: {
-                        id: automation.id,
-                        name: automation.name,
-                        schedule: automation.schedule,
-                        trigger: automation.trigger
-                    },
-                    message: `Automation '${automation.name}' scheduled successfully`,
-                    executionTime
-                }
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            return operation_error_handler_js_1.OperationErrorHandler.createToolError('SCHEDULE_ERROR', `Failed to schedule automation: ${errorMessage}`, params.action, { name: params.name, id: params.id, error: errorMessage }, ['Check schedule format', 'Verify automation exists']);
-        }
-    }
-    /**
-     * Enable automation
-     */
-    async handleEnable(params, startTime) {
-        try {
-            if (!params.name && !params.id) {
-                return operation_error_handler_js_1.OperationErrorHandler.createToolError('MISSING_IDENTIFIER', 'Either name or id is required for enabling automation', params.action, { name: params.name, id: params.id }, ['Provide name or id parameter']);
-            }
-            const automation = params.name ? this.getAutomation(params.name) : this.getAutomationById(params.id);
-            if (!automation) {
-                return operation_error_handler_js_1.OperationErrorHandler.createToolError('AUTOMATION_NOT_FOUND', `Automation not found: ${params.name || params.id}`, params.action, { name: params.name, id: params.id }, ['Check automation name/id', 'Use list action to see available automations']);
-            }
-            automation.enabled = true;
-            this.saveAutomation(automation);
-            const executionTime = Date.now() - startTime;
-            return {
-                success: true,
-                data: {
-                    automation: {
-                        id: automation.id,
-                        name: automation.name,
-                        enabled: automation.enabled
-                    },
-                    message: `Automation '${automation.name}' enabled successfully`,
-                    executionTime
-                }
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            return operation_error_handler_js_1.OperationErrorHandler.createToolError('ENABLE_ERROR', `Failed to enable automation: ${errorMessage}`, params.action, { name: params.name, id: params.id, error: errorMessage }, ['Check automation exists', 'Verify permissions']);
-        }
-    }
-    /**
-     * Disable automation
-     */
-    async handleDisable(params, startTime) {
-        try {
-            if (!params.name && !params.id) {
-                return operation_error_handler_js_1.OperationErrorHandler.createToolError('MISSING_IDENTIFIER', 'Either name or id is required for disabling automation', params.action, { name: params.name, id: params.id }, ['Provide name or id parameter']);
-            }
-            const automation = params.name ? this.getAutomation(params.name) : this.getAutomationById(params.id);
-            if (!automation) {
-                return operation_error_handler_js_1.OperationErrorHandler.createToolError('AUTOMATION_NOT_FOUND', `Automation not found: ${params.name || params.id}`, params.action, { name: params.name, id: params.id }, ['Check automation name/id', 'Use list action to see available automations']);
-            }
-            automation.enabled = false;
-            this.saveAutomation(automation);
-            const executionTime = Date.now() - startTime;
-            return {
-                success: true,
-                data: {
-                    automation: {
-                        id: automation.id,
-                        name: automation.name,
-                        enabled: automation.enabled
-                    },
-                    message: `Automation '${automation.name}' disabled successfully`,
-                    executionTime
-                }
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            return operation_error_handler_js_1.OperationErrorHandler.createToolError('DISABLE_ERROR', `Failed to disable automation: ${errorMessage}`, params.action, { name: params.name, id: params.id, error: errorMessage }, ['Check automation exists', 'Verify permissions']);
-        }
-    }
-    /**
-     * Ensure automations directory exists
-     */
-    ensureAutomationsDirectory() {
-        if (!fs_1.default.existsSync(this.automationsPath)) {
-            fs_1.default.mkdirSync(this.automationsPath, { recursive: true });
-        }
-    }
-    /**
-     * Create automation definition
-     */
-    createAutomationDefinition(params) {
-        const id = params.id || this.generateId();
-        const now = new Date().toISOString();
-        return {
-            id,
-            name: params.name,
-            description: this.getAutomationDescription(params),
-            commands: params.commands || [],
-            script: params.script || '',
-            trigger: params.trigger || 'manual',
-            schedule: params.schedule,
-            conditions: params.conditions || {},
-            parallel: params.parallel || false,
-            continueOnError: params.continueOnError || false,
-            timeout: params.timeout || 300,
-            retries: params.retries || 0,
-            workingDirectory: params.workingDirectory,
-            environment: params.environment || {},
-            context: params.context || {},
-            createBranch: params.createBranch || false,
-            autoCommit: params.autoCommit || false,
-            createPR: params.createPR || false,
-            enabled: params.enabled !== false,
-            category: params.category || 'custom',
-            created: now,
-            updated: now,
-            lastRun: null
-        };
-    }
-    /**
-     * Update automation definition
-     */
-    updateAutomationDefinition(existing, params) {
-        const updated = { ...existing };
-        if (params.commands)
-            updated.commands = params.commands;
-        if (params.script)
-            updated.script = params.script;
-        if (params.trigger)
-            updated.trigger = params.trigger;
-        if (params.schedule !== undefined)
-            updated.schedule = params.schedule;
-        if (params.conditions)
-            updated.conditions = params.conditions;
-        if (params.parallel !== undefined)
-            updated.parallel = params.parallel;
-        if (params.continueOnError !== undefined)
-            updated.continueOnError = params.continueOnError;
-        if (params.timeout !== undefined)
-            updated.timeout = params.timeout;
-        if (params.retries !== undefined)
-            updated.retries = params.retries;
-        if (params.workingDirectory)
-            updated.workingDirectory = params.workingDirectory;
-        if (params.environment)
-            updated.environment = { ...updated.environment, ...params.environment };
-        if (params.context)
-            updated.context = { ...updated.context, ...params.context };
-        if (params.createBranch !== undefined)
-            updated.createBranch = params.createBranch;
-        if (params.autoCommit !== undefined)
-            updated.autoCommit = params.autoCommit;
-        if (params.createPR !== undefined)
-            updated.createPR = params.createPR;
-        if (params.enabled !== undefined)
-            updated.enabled = params.enabled;
-        if (params.category)
-            updated.category = params.category;
-        updated.updated = new Date().toISOString();
-        return updated;
-    }
-    /**
-     * Execute automation
-     */
-    async executeAutomation(automation, params) {
-        const startTime = Date.now();
-        const results = [];
-        let success = true;
-        let error = null;
-        try {
-            // Create branch if requested
-            let branchName = '';
-            if (automation.createBranch && !params.dryRun) {
-                branchName = `automation-${automation.name}-${Date.now()}`;
-                await this.createBranch(branchName, params.projectPath);
-            }
-            // Set working directory
-            const workingDir = automation.workingDirectory || params.projectPath;
-            // Execute commands
-            if (automation.commands && automation.commands.length > 0) {
-                for (let i = 0; i < automation.commands.length; i++) {
-                    const command = automation.commands[i];
-                    try {
-                        const result = await this.gitExecutor.executeGitCommand(command, workingDir);
-                        results.push({
-                            command,
-                            success: result.success,
-                            output: result.stdout,
-                            error: result.stderr,
-                            exitCode: result.exitCode
-                        });
-                        if (!result.success && !automation.continueOnError) {
-                            success = false;
-                            error = result.stderr || 'Command failed';
-                            break;
-                        }
-                    }
-                    catch (cmdError) {
-                        results.push({
-                            command,
-                            success: false,
-                            output: '',
-                            error: cmdError instanceof Error ? cmdError.message : 'Unknown error',
-                            exitCode: 1
-                        });
-                        if (!automation.continueOnError) {
-                            success = false;
-                            error = cmdError instanceof Error ? cmdError.message : 'Unknown error';
-                            break;
-                        }
-                    }
-                }
-            }
-            // Execute script if provided
-            if (automation.script && !error) {
-                try {
-                    const scriptResult = await this.executeScript(automation.script, workingDir);
-                    results.push({
-                        command: 'custom-script',
-                        success: scriptResult.success,
-                        output: scriptResult.stdout,
-                        error: scriptResult.stderr,
-                        exitCode: scriptResult.exitCode
-                    });
-                    if (!scriptResult.success && !automation.continueOnError) {
-                        success = false;
-                        error = scriptResult.stderr || 'Script failed';
-                    }
-                }
-                catch (scriptError) {
-                    results.push({
-                        command: 'custom-script',
-                        success: false,
-                        output: '',
-                        error: scriptError instanceof Error ? scriptError.message : 'Unknown error',
-                        exitCode: 1
-                    });
-                    if (!automation.continueOnError) {
-                        success = false;
-                        error = scriptError instanceof Error ? scriptError.message : 'Unknown error';
-                    }
-                }
-            }
-            // Auto-commit if requested and successful
-            if (success && automation.autoCommit && !params.dryRun) {
-                try {
-                    await this.autoCommit(automation.name, params.projectPath);
-                }
-                catch (commitError) {
-                    error = commitError instanceof Error ? commitError.message : 'Auto-commit failed';
-                    success = false;
-                }
-            }
-            // Update automation with last run info
-            automation.lastRun = {
-                timestamp: new Date().toISOString(),
-                success,
-                error,
-                duration: Date.now() - startTime,
-                results
-            };
-            this.saveAutomation(automation);
-            return {
-                success,
-                error,
-                results,
-                duration: Date.now() - startTime,
-                branchName
-            };
-        }
-        catch (execError) {
-            return {
-                success: false,
-                error: execError instanceof Error ? execError.message : 'Unknown error',
-                results,
-                duration: Date.now() - startTime
-            };
-        }
-    }
-    /**
-     * Execute custom script
-     */
-    async executeScript(script, workingDir) {
-        // Write script to temporary file
-        const scriptPath = path_1.default.join(workingDir, 'temp-script.sh');
-        fs_1.default.writeFileSync(scriptPath, script, 'utf8');
-        fs_1.default.chmodSync(scriptPath, '755');
-        try {
-            const result = await this.gitExecutor.executeGitCommand('./temp-script.sh', [], workingDir);
-            return result;
-        }
-        finally {
-            // Clean up script file
-            if (fs_1.default.existsSync(scriptPath)) {
-                fs_1.default.unlinkSync(scriptPath);
-            }
-        }
-    }
-    /**
-     * Create branch for automation
-     */
-    async createBranch(branchName, projectPath) {
-        const result = await this.gitExecutor.executeGitCommand('git', ['checkout', '-b', branchName], projectPath);
-        if (!result.success) {
-            throw new Error(`Failed to create branch: ${result.stderr}`);
-        }
-    }
-    /**
-     * Auto-commit changes
-     */
-    async autoCommit(automationName, projectPath) {
-        // Add all changes
-        await this.gitExecutor.executeGitCommand('git', ['add', '.'], projectPath);
-        // Commit with automation name
-        const commitMessage = `chore: automated changes by ${automationName}`;
-        const result = await this.gitExecutor.executeGitCommand('git', ['commit', '-m', commitMessage], projectPath);
-        if (!result.success) {
-            throw new Error(`Failed to auto-commit: ${result.stderr}`);
-        }
-    }
-    /**
-     * Save automation to file
-     */
-    saveAutomation(automation) {
-        const filePath = path_1.default.join(this.automationsPath, `${automation.id}.json`);
-        fs_1.default.writeFileSync(filePath, JSON.stringify(automation, null, 2), 'utf8');
-    }
-    /**
-     * Get automation by name
-     */
-    getAutomation(name) {
-        const automations = this.getAllAutomations();
-        return automations.find(a => a.name === name) || null;
-    }
-    /**
-     * Get automation by ID
-     */
-    getAutomationById(id) {
-        const filePath = path_1.default.join(this.automationsPath, `${id}.json`);
-        if (!fs_1.default.existsSync(filePath)) {
-            return null;
-        }
-        try {
-            const content = fs_1.default.readFileSync(filePath, 'utf8');
-            return JSON.parse(content);
-        }
-        catch {
-            return null;
-        }
-    }
-    /**
-     * Get all automations
-     */
-    getAllAutomations() {
-        if (!fs_1.default.existsSync(this.automationsPath)) {
-            return [];
-        }
-        const files = fs_1.default.readdirSync(this.automationsPath);
-        const automations = [];
-        for (const file of files) {
-            if (file.endsWith('.json')) {
-                const filePath = path_1.default.join(this.automationsPath, file);
-                try {
-                    const content = fs_1.default.readFileSync(filePath, 'utf8');
-                    const automation = JSON.parse(content);
-                    automations.push(automation);
-                }
-                catch {
-                    // Skip invalid files
-                }
-            }
-        }
-        return automations;
-    }
-    /**
-     * Delete automation
-     */
-    deleteAutomation(id) {
-        const filePath = path_1.default.join(this.automationsPath, `${id}.json`);
-        if (fs_1.default.existsSync(filePath)) {
-            fs_1.default.unlinkSync(filePath);
-        }
-    }
-    /**
-     * Generate unique ID
-     */
-    generateId() {
-        return `automation-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-    }
-    /**
-     * Get automation description
-     */
-    getAutomationDescription(params) {
-        if (params.description) {
-            return params.description;
-        }
-        // Generate description based on commands
-        if (params.commands && params.commands.length > 0) {
-            return `Automation with ${params.commands.length} commands`;
-        }
-        if (params.script) {
-            return 'Custom script automation';
-        }
-        return 'Custom automation';
-    }
-    /**
-     * Get tool schema for MCP registration
-     */
-    static getToolSchema() {
-        return {
-            name: 'git-automations',
-            description: 'Custom workflow automation tool. Create and manage automated Git workflows with triggers, scheduling, and execution monitoring.',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    "action": {
-                        "type": "string",
-                        "enum": [
-                            "create",
-                            "list",
-                            "run",
-                            "update",
-                            "delete",
-                            "schedule",
-                            "enable",
-                            "disable"
-                        ],
-                        "description": "The operation to perform"
-                    },
-                    "projectPath": {
-                        "type": "string",
-                        "description": "Path to the Git repository"
-                    },
-                    "name": {
-                        "type": "string",
-                        "description": "name parameter"
-                    },
-                    "id": {
-                        "type": "string",
-                        "description": "id parameter"
-                    },
-                    "commands": {
-                        "type": "array",
-                        "items": {
-                            "type": "string"
-                        },
-                        "description": "commands parameter"
-                    },
-                    "script": {
-                        "type": "string",
-                        "description": "script parameter"
-                    },
-                    "workflow": {
-                        "type": "object",
-                        "description": "workflow parameter"
-                    },
-                    "trigger": {
-                        "type": "string",
-                        "description": "trigger parameter"
-                    },
-                    "schedule": {
-                        "type": "string",
-                        "description": "schedule parameter"
-                    },
-                    "conditions": {
-                        "type": "object",
-                        "description": "conditions parameter"
-                    },
-                    "parallel": {
-                        "type": "string",
-                        "description": "parallel parameter"
-                    },
-                    "continueOnError": {
-                        "type": "string",
-                        "description": "continueOnError parameter"
-                    },
-                    "timeout": {
-                        "type": "string",
-                        "description": "timeout parameter"
-                    },
-                    "retries": {
-                        "type": "string",
-                        "description": "retries parameter"
-                    },
-                    "workingDirectory": {
-                        "type": "string",
-                        "description": "workingDirectory parameter"
-                    },
-                    "environment": {
-                        "type": "object",
-                        "description": "environment parameter"
-                    },
-                    "context": {
-                        "type": "object",
-                        "description": "context parameter"
-                    },
-                    "createBranch": {
-                        "type": "string",
-                        "description": "createBranch parameter"
-                    },
-                    "autoCommit": {
-                        "type": "string",
-                        "description": "autoCommit parameter"
-                    },
-                    "createPR": {
-                        "type": "string",
-                        "description": "createPR parameter"
-                    },
-                    "enabled": {
-                        "type": "string",
-                        "description": "enabled parameter"
-                    },
-                    "dryRun": {
-                        "type": "string",
-                        "description": "dryRun parameter"
-                    },
-                    "verbose": {
-                        "type": "string",
-                        "description": "verbose parameter"
-                    },
-                    "filter": {
-                        "type": "string",
-                        "description": "filter parameter"
-                    },
-                    "category": {
-                        "type": "string",
-                        "description": "category parameter"
-                    }
-                },
-                required: ['action', 'projectPath'],
-                additionalProperties: false
-            },
-            errorCodes: {
-                'VALIDATION_ERROR': 'Parameter validation failed',
-                'EXECUTION_ERROR': 'Tool execution failed'
-            }
-        };
-    }
-}
-exports.GitAutomationsTool = GitAutomationsTool;
-//# sourceMappingURL=git-automations.js.map