@andrebuzeli/git-mcp 5.1.0 → 5.2.0

package/dist/tools/git-changelog.js

@@ -0,0 +1,728 @@
+"use strict";
+/**
+ * Git Changelog Tool
+ *
+ * Changelog generation tool providing comprehensive changelog operations.
+ * Supports conventional commits parsing, multiple formats, and semantic versioning.
+ *
+ * Operations: generate, update, preview, formats
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitChangelogTool = 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 GitChangelogTool {
+    gitExecutor;
+    // Conventional commit types and their display names
+    commitTypes = {
+        feat: { emoji: '✨', name: 'Features', description: 'New features' },
+        fix: { emoji: '🐛', name: 'Bug Fixes', description: 'Bug fixes' },
+        docs: { emoji: '📚', name: 'Documentation', description: 'Documentation changes' },
+        style: { emoji: '💎', name: 'Styles', description: 'Code style changes' },
+        refactor: { emoji: '📦', name: 'Code Refactoring', description: 'Code refactoring' },
+        perf: { emoji: '⚡️', name: 'Performance Improvements', description: 'Performance improvements' },
+        test: { emoji: '✅', name: 'Tests', description: 'Test changes' },
+        build: { emoji: '🏗️', name: 'Build System', description: 'Build system changes' },
+        ci: { emoji: '👷', name: 'Continuous Integration', description: 'CI changes' },
+        chore: { emoji: '🔧', name: 'Chores', description: 'Chore changes' },
+        revert: { emoji: '⏪️', name: 'Reverts', description: 'Reverted changes' }
+    };
+    constructor() {
+        this.gitExecutor = new git_command_executor_js_1.GitCommandExecutor();
+    }
+    /**
+     * Execute git-changelog operation
+     */
+    async execute(params) {
+        const startTime = Date.now();
+        try {
+            // Validate basic parameters
+            const validation = parameter_validator_js_1.ParameterValidator.validateToolParams('git-changelog', 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-changelog', 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);
+            }
+            // Route to appropriate handler
+            switch (params.action) {
+                case 'generate':
+                    return await this.handleGenerate(params, startTime);
+                case 'update':
+                    return await this.handleUpdate(params, startTime);
+                case 'preview':
+                    return await this.handlePreview(params, startTime);
+                case 'formats':
+                    return await this.handleFormats(params, startTime);
+                default:
+                    return operation_error_handler_js_1.OperationErrorHandler.createToolError('INVALID_ACTION', `Unknown action: ${params.action}`, params.action, { supportedActions: ['generate', 'update', 'preview', 'formats'] }, ['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']);
+        }
+    }
+    /**
+     * Generate changelog
+     */
+    async handleGenerate(params, startTime) {
+        try {
+            const commits = await this.getCommits(params);
+            const changelog = await this.generateChangelog(commits, params);
+            // Write to file if output path is specified
+            if (params.stdout) {
+                const outputPath = path_1.default.resolve(params.projectPath, params.stdout);
+                fs_1.default.writeFileSync(outputPath, changelog, 'utf8');
+            }
+            const executionTime = Date.now() - startTime;
+            return {
+                success: true,
+                data: {
+                    changelog: {
+                        content: changelog,
+                        format: params.format || 'markdown',
+                        outputPath: params.stdout,
+                        version: params.version,
+                        commits: commits.length,
+                        stats: this.getChangelogStats(commits)
+                    },
+                    message: `Changelog generated successfully${params.stdout ? ` and saved to ${params.stdout}` : ''}`,
+                    executionTime
+                }
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return operation_error_handler_js_1.OperationErrorHandler.createToolError('GENERATE_ERROR', `Failed to generate changelog: ${errorMessage}`, params.action, { error: errorMessage }, ['Check repository state', 'Verify date/tag parameters']);
+        }
+    }
+    /**
+     * Update existing changelog
+     */
+    async handleUpdate(params, startTime) {
+        try {
+            if (!params.stdout) {
+                return operation_error_handler_js_1.OperationErrorHandler.createToolError('MISSING_OUTPUT', 'Output path is required for update operation', params.action, { output: params.stdout }, ['Provide output parameter with changelog file path']);
+            }
+            const outputPath = path_1.default.resolve(params.projectPath, params.stdout);
+            // Read existing changelog
+            let existingContent = '';
+            if (fs_1.default.existsSync(outputPath)) {
+                existingContent = fs_1.default.readFileSync(outputPath, 'utf8');
+            }
+            // Generate new changelog
+            const commits = await this.getCommits(params);
+            const newChangelog = await this.generateChangelog(commits, params);
+            // Merge with existing content
+            const updatedContent = this.mergeChangelog(existingContent, newChangelog, params);
+            // Write updated content
+            fs_1.default.writeFileSync(outputPath, updatedContent, 'utf8');
+            const executionTime = Date.now() - startTime;
+            return {
+                success: true,
+                data: {
+                    changelog: {
+                        content: updatedContent,
+                        format: params.format || 'markdown',
+                        outputPath: params.stdout,
+                        version: params.version,
+                        commits: commits.length,
+                        stats: this.getChangelogStats(commits),
+                        updated: true
+                    },
+                    message: `Changelog updated successfully in ${params.stdout}`,
+                    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 changelog: ${errorMessage}`, params.action, { error: errorMessage }, ['Check output file permissions', 'Verify changelog format']);
+        }
+    }
+    /**
+     * Preview changelog
+     */
+    async handlePreview(params, startTime) {
+        try {
+            const commits = await this.getCommits(params);
+            const preview = await this.generateChangelog(commits, params);
+            const executionTime = Date.now() - startTime;
+            return {
+                success: true,
+                data: {
+                    changelog: {
+                        content: preview,
+                        format: params.format || 'markdown',
+                        version: params.version,
+                        commits: commits.length,
+                        stats: this.getChangelogStats(commits),
+                        preview: true
+                    },
+                    message: 'Changelog preview generated successfully',
+                    executionTime
+                }
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return operation_error_handler_js_1.OperationErrorHandler.createToolError('PREVIEW_ERROR', `Failed to preview changelog: ${errorMessage}`, params.action, { error: errorMessage }, ['Check repository state', 'Verify date/tag parameters']);
+        }
+    }
+    /**
+     * Get available formats
+     */
+    async handleFormats(params, startTime) {
+        try {
+            const formats = [
+                {
+                    name: 'markdown',
+                    description: 'Markdown format with headers and lists',
+                    extension: '.md',
+                    template: 'markdown'
+                },
+                {
+                    name: 'json',
+                    description: 'JSON format with structured data',
+                    extension: '.json',
+                    template: 'json'
+                },
+                {
+                    name: 'html',
+                    description: 'HTML format with styling',
+                    extension: '.html',
+                    template: 'html'
+                },
+                {
+                    name: 'plain',
+                    description: 'Plain text format',
+                    extension: '.txt',
+                    template: 'plain'
+                }
+            ];
+            const executionTime = Date.now() - startTime;
+            return {
+                success: true,
+                data: {
+                    formats,
+                    message: 'Available changelog formats retrieved successfully',
+                    executionTime
+                }
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return operation_error_handler_js_1.OperationErrorHandler.createToolError('FORMATS_ERROR', `Failed to get formats: ${errorMessage}`, params.action, { error: errorMessage }, ['Check tool configuration']);
+        }
+    }
+    /**
+     * Get commits for changelog
+     */
+    async getCommits(params) {
+        let command = 'git log --pretty=format:"%H|%an|%ae|%ad|%s|%b" --date=iso';
+        // Add date/tag filters
+        if (params.fromTag && params.toTag) {
+            command += ` ${params.toTag}..${params.fromTag}`;
+        }
+        else if (params.fromTag) {
+            command += ` ${params.fromTag}..HEAD`;
+        }
+        else if (params.since && params.until) {
+            command += ` --since="${params.since}" --until="${params.until}"`;
+        }
+        else if (params.since) {
+            command += ` --since="${params.since}"`;
+        }
+        else if (params.until) {
+            command += ` --until="${params.until}"`;
+        }
+        // Add merge commit filter
+        if (!params.includeMergeCommits) {
+            command += ' --no-merges';
+        }
+        // Add commit limit
+        if (params.maxCommits) {
+            command += ` --max-count=${params.maxCommits}`;
+        }
+        const result = await this.gitExecutor.executeGitCommand(command, [], params.projectPath);
+        if (!result.success) {
+            return [];
+        }
+        const commits = [];
+        const lines = result.stdout.trim().split('\n').filter(line => line.trim());
+        for (const line of lines) {
+            const [hash, author, email, date, subject, body] = line.split('|', 6);
+            const commit = {
+                hash,
+                author,
+                email,
+                date: new Date(date),
+                subject,
+                body: body || '',
+                type: this.parseCommitType(subject),
+                scope: this.parseCommitScope(subject),
+                breaking: this.isBreakingChange(subject, body),
+                issues: this.extractIssues(subject, body)
+            };
+            // Apply filters
+            if (this.shouldIncludeCommit(commit, params)) {
+                commits.push(commit);
+            }
+        }
+        return commits;
+    }
+    /**
+     * Generate changelog content
+     */
+    async generateChangelog(commits, params) {
+        const format = params.format || 'markdown';
+        switch (format) {
+            case 'markdown':
+                return this.generateMarkdownChangelog(commits, params);
+            case 'json':
+                return this.generateJsonChangelog(commits, params);
+            case 'html':
+                return this.generateHtmlChangelog(commits, params);
+            case 'plain':
+                return this.generatePlainChangelog(commits, params);
+            default:
+                return this.generateMarkdownChangelog(commits, params);
+        }
+    }
+    /**
+     * Generate Markdown changelog
+     */
+    generateMarkdownChangelog(commits, params) {
+        let changelog = '';
+        // Header
+        const version = params.version || 'Unreleased';
+        const date = new Date().toISOString().split('T')[0];
+        changelog += `# Changelog\n\n`;
+        changelog += `## [${version}] - ${date}\n\n`;
+        // Breaking changes
+        const breakingChanges = commits.filter(c => c.breaking);
+        if (breakingChanges.length > 0) {
+            changelog += `### ⚠️ Breaking Changes\n\n`;
+            for (const commit of breakingChanges) {
+                changelog += `- ${commit.subject.replace(/^BREAKING CHANGE: /, '')}\n`;
+            }
+            changelog += '\n';
+        }
+        // Group by type
+        const grouped = this.groupCommitsByType(commits);
+        for (const [type, typeCommits] of Object.entries(grouped)) {
+            if (typeCommits.length === 0)
+                continue;
+            const typeInfo = this.commitTypes[type];
+            if (typeInfo) {
+                changelog += `### ${typeInfo.emoji} ${typeInfo.name}\n\n`;
+                for (const commit of typeCommits) {
+                    const scope = commit.scope ? `**${commit.scope}**: ` : '';
+                    const description = this.formatCommitDescription(commit.subject, type);
+                    changelog += `- ${scope}${description}\n`;
+                }
+                changelog += '\n';
+            }
+        }
+        // Footer
+        if (params.includeIssues) {
+            const allIssues = commits.flatMap(c => c.issues);
+            if (allIssues.length > 0) {
+                changelog += `### 🔗 Issues & Pull Requests\n\n`;
+                const uniqueIssues = [...new Set(allIssues)];
+                for (const issue of uniqueIssues) {
+                    changelog += `- ${issue}\n`;
+                }
+                changelog += '\n';
+            }
+        }
+        return changelog;
+    }
+    /**
+     * Generate JSON changelog
+     */
+    generateJsonChangelog(commits, params) {
+        const changelog = {
+            version: params.version || 'Unreleased',
+            date: new Date().toISOString(),
+            changes: {
+                breaking: commits.filter(c => c.breaking),
+                features: commits.filter(c => c.type === 'feat'),
+                fixes: commits.filter(c => c.type === 'fix'),
+                other: commits.filter(c => !['feat', 'fix'].includes(c.type) && !c.breaking)
+            },
+            stats: this.getChangelogStats(commits),
+            commits: commits.map(c => ({
+                hash: c.hash,
+                type: c.type,
+                scope: c.scope,
+                subject: c.subject,
+                author: c.author,
+                date: c.date.toISOString(),
+                breaking: c.breaking,
+                issues: c.issues
+            }))
+        };
+        return JSON.stringify(changelog, null, 2);
+    }
+    /**
+     * Generate HTML changelog
+     */
+    generateHtmlChangelog(commits, params) {
+        let html = `
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Changelog</title>
+    <style>
+        body { font-family: Arial, sans-serif; max-width: 800px; margin: 0 auto; padding: 20px; }
+        .version { color: #0366d6; border-bottom: 2px solid #e1e4e8; padding-bottom: 10px; }
+        .breaking { background: #fff5f5; border-left: 4px solid #d73a49; padding: 10px; margin: 10px 0; }
+        .feature { color: #28a745; }
+        .fix { color: #d73a49; }
+        .other { color: #6a737d; }
+        .commit { margin: 5px 0; }
+        .scope { font-weight: bold; }
+        ul { list-style-type: none; padding-left: 0; }
+    </style>
+</head>
+<body>
+    <h1>Changelog</h1>
+    <div class="version">
+        <h2>${params.version || 'Unreleased'} - ${new Date().toISOString().split('T')[0]}</h2>
+    </div>
+`;
+        // Breaking changes
+        const breakingChanges = commits.filter(c => c.breaking);
+        if (breakingChanges.length > 0) {
+            html += `<div class="breaking">
+        <h3>⚠️ Breaking Changes</h3>
+        <ul>`;
+            for (const commit of breakingChanges) {
+                html += `<li class="commit">${commit.subject.replace(/^BREAKING CHANGE: /, '')}</li>`;
+            }
+            html += `</ul></div>`;
+        }
+        // Group by type
+        const grouped = this.groupCommitsByType(commits);
+        for (const [type, typeCommits] of Object.entries(grouped)) {
+            if (typeCommits.length === 0)
+                continue;
+            const typeInfo = this.commitTypes[type];
+            if (typeInfo) {
+                html += `<h3>${typeInfo.emoji} ${typeInfo.name}</h3>
+        <ul>`;
+                for (const commit of typeCommits) {
+                    const scope = commit.scope ? `<span class="scope">${commit.scope}:</span> ` : '';
+                    const description = this.formatCommitDescription(commit.subject, type);
+                    html += `<li class="commit ${type}">${scope}${description}</li>`;
+                }
+                html += `</ul>`;
+            }
+        }
+        html += `</body></html>`;
+        return html;
+    }
+    /**
+     * Generate plain text changelog
+     */
+    generatePlainChangelog(commits, params) {
+        let changelog = `CHANGELOG\n`;
+        changelog += `${'='.repeat(50)}\n\n`;
+        changelog += `${params.version || 'Unreleased'} - ${new Date().toISOString().split('T')[0]}\n\n`;
+        // Group by type
+        const grouped = this.groupCommitsByType(commits);
+        for (const [type, typeCommits] of Object.entries(grouped)) {
+            if (typeCommits.length === 0)
+                continue;
+            const typeInfo = this.commitTypes[type];
+            if (typeInfo) {
+                changelog += `${typeInfo.name.toUpperCase()}\n`;
+                changelog += `${'-'.repeat(typeInfo.name.length)}\n`;
+                for (const commit of typeCommits) {
+                    const scope = commit.scope ? `${commit.scope}: ` : '';
+                    const description = this.formatCommitDescription(commit.subject, type);
+                    changelog += `  - ${scope}${description}\n`;
+                }
+                changelog += '\n';
+            }
+        }
+        return changelog;
+    }
+    /**
+     * Parse commit type from subject
+     */
+    parseCommitType(subject) {
+        const match = subject.match(/^(\w+)(?:\(.+\))?:/);
+        return match ? match[1].toLowerCase() : 'other';
+    }
+    /**
+     * Parse commit scope from subject
+     */
+    parseCommitScope(subject) {
+        const match = subject.match(/^\w+\((.+)\):/);
+        return match ? match[1] : null;
+    }
+    /**
+     * Check if commit is a breaking change
+     */
+    isBreakingChange(subject, body) {
+        return subject.includes('BREAKING CHANGE:') ||
+            subject.includes('!') ||
+            body.includes('BREAKING CHANGE:');
+    }
+    /**
+     * Extract issues and PRs from commit
+     */
+    extractIssues(subject, body) {
+        const issues = [];
+        const text = `${subject} ${body}`;
+        // GitHub issues/PRs
+        const githubMatches = text.match(/#\d+/g);
+        if (githubMatches) {
+            issues.push(...githubMatches);
+        }
+        // Jira issues
+        const jiraMatches = text.match(/[A-Z]+-\d+/g);
+        if (jiraMatches) {
+            issues.push(...jiraMatches);
+        }
+        return issues;
+    }
+    /**
+     * Check if commit should be included
+     */
+    shouldIncludeCommit(commit, params) {
+        // Filter by type
+        if (params.includeTypes && !params.includeTypes.includes(commit.type)) {
+            return false;
+        }
+        if (params.excludeTypes && params.excludeTypes.includes(commit.type)) {
+            return false;
+        }
+        // Filter by scope
+        if (params.includeScopes && commit.scope && !params.includeScopes.includes(commit.scope)) {
+            return false;
+        }
+        if (params.excludeScopes && commit.scope && params.excludeScopes.includes(commit.scope)) {
+            return false;
+        }
+        // Filter reverts
+        if (!params.includeReverts && commit.type === 'revert') {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Group commits by type
+     */
+    groupCommitsByType(commits) {
+        const grouped = {};
+        for (const commit of commits) {
+            if (!grouped[commit.type]) {
+                grouped[commit.type] = [];
+            }
+            grouped[commit.type].push(commit);
+        }
+        return grouped;
+    }
+    /**
+     * Format commit description
+     */
+    formatCommitDescription(subject, type) {
+        // Remove type and scope from subject
+        let description = subject.replace(/^\w+(?:\(.+\))?: ?/, '');
+        // Remove breaking change prefix
+        description = description.replace(/^BREAKING CHANGE: ?/, '');
+        return description;
+    }
+    /**
+     * Get changelog statistics
+     */
+    getChangelogStats(commits) {
+        const stats = {
+            totalCommits: commits.length,
+            breakingChanges: commits.filter(c => c.breaking).length,
+            features: commits.filter(c => c.type === 'feat').length,
+            fixes: commits.filter(c => c.type === 'fix').length,
+            types: {},
+            scopes: {},
+            authors: {},
+            issues: []
+        };
+        for (const commit of commits) {
+            // Count types
+            stats.types[commit.type] = (stats.types[commit.type] || 0) + 1;
+            // Count scopes
+            if (commit.scope) {
+                stats.scopes[commit.scope] = (stats.scopes[commit.scope] || 0) + 1;
+            }
+            // Count authors
+            stats.authors[commit.author] = (stats.authors[commit.author] || 0) + 1;
+            // Collect issues
+            stats.issues.push(...commit.issues);
+        }
+        // Remove duplicates from issues
+        stats.issues = [...new Set(stats.issues)];
+        return stats;
+    }
+    /**
+     * Merge new changelog with existing content
+     */
+    mergeChangelog(existing, newContent, params) {
+        if (!existing.trim()) {
+            return newContent;
+        }
+        // Simple merge: prepend new content
+        return `${newContent}\n\n---\n\n${existing}`;
+    }
+    /**
+     * Get tool schema for MCP registration
+     */
+    static getToolSchema() {
+        return {
+            name: 'git-changelog',
+            description: 'Automatic changelog generation tool. Creates changelogs from conventional commits with multiple output formats and filtering options.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    "action": {
+                        "type": "string",
+                        "enum": [
+                            "generate",
+                            "update",
+                            "preview",
+                            "formats"
+                        ],
+                        "description": "The operation to perform"
+                    },
+                    "projectPath": {
+                        "type": "string",
+                        "description": "Path to the Git repository"
+                    },
+                    "format": {
+                        "type": "string",
+                        "description": "format parameter"
+                    },
+                    "output": {
+                        "type": "string",
+                        "description": "output parameter"
+                    },
+                    "fromTag": {
+                        "type": "string",
+                        "description": "fromTag parameter"
+                    },
+                    "toTag": {
+                        "type": "string",
+                        "description": "toTag parameter"
+                    },
+                    "since": {
+                        "type": "string",
+                        "description": "since parameter"
+                    },
+                    "until": {
+                        "type": "string",
+                        "description": "until parameter"
+                    },
+                    "groupBy": {
+                        "type": "string",
+                        "description": "groupBy parameter"
+                    },
+                    "includeTypes": {
+                        "type": "array",
+                        "items": {
+                            "type": "string"
+                        },
+                        "description": "includeTypes parameter"
+                    },
+                    "excludeTypes": {
+                        "type": "array",
+                        "items": {
+                            "type": "string"
+                        },
+                        "description": "excludeTypes parameter"
+                    },
+                    "includeScopes": {
+                        "type": "array",
+                        "items": {
+                            "type": "string"
+                        },
+                        "description": "includeScopes parameter"
+                    },
+                    "excludeScopes": {
+                        "type": "array",
+                        "items": {
+                            "type": "string"
+                        },
+                        "description": "excludeScopes parameter"
+                    },
+                    "includeBreakingChanges": {
+                        "type": "string",
+                        "description": "includeBreakingChanges parameter"
+                    },
+                    "includeMergeCommits": {
+                        "type": "string",
+                        "description": "includeMergeCommits parameter"
+                    },
+                    "includeReverts": {
+                        "type": "string",
+                        "description": "includeReverts parameter"
+                    },
+                    "includeIssues": {
+                        "type": "string",
+                        "description": "includeIssues parameter"
+                    },
+                    "template": {
+                        "type": "string",
+                        "description": "template parameter"
+                    },
+                    "headerTemplate": {
+                        "type": "string",
+                        "description": "headerTemplate parameter"
+                    },
+                    "sectionTemplate": {
+                        "type": "string",
+                        "description": "sectionTemplate parameter"
+                    },
+                    "commitTemplate": {
+                        "type": "string",
+                        "description": "commitTemplate parameter"
+                    },
+                    "version": {
+                        "type": "string",
+                        "description": "version parameter"
+                    },
+                    "unreleased": {
+                        "type": "string",
+                        "description": "unreleased parameter"
+                    },
+                    "showStats": {
+                        "type": "string",
+                        "description": "showStats parameter"
+                    },
+                    "maxCommits": {
+                        "type": "string",
+                        "description": "maxCommits parameter"
+                    }
+                },
+                required: ['action', 'projectPath'],
+                additionalProperties: false
+            },
+            errorCodes: {
+                'VALIDATION_ERROR': 'Parameter validation failed',
+                'EXECUTION_ERROR': 'Tool execution failed'
+            }
+        };
+    }
+}
+exports.GitChangelogTool = GitChangelogTool;
+//# sourceMappingURL=git-changelog.js.map