@andrebuzeli/git-mcp 5.1.0 → 5.2.0

package/dist/tools/git-dependencies.js

@@ -0,0 +1,761 @@
+"use strict";
+/**
+ * Git Dependencies Tool
+ *
+ * Dependencies analysis tool providing comprehensive dependency management operations.
+ * Supports multiple package managers and automated dependency updates.
+ *
+ * Operations: list, outdated, update, audit, changelog, compare
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitDependenciesTool = 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 GitDependenciesTool {
+    gitExecutor;
+    constructor() {
+        this.gitExecutor = new git_command_executor_js_1.GitCommandExecutor();
+    }
+    /**
+     * Execute git-dependencies operation
+     */
+    async execute(params) {
+        const startTime = Date.now();
+        try {
+            // Validate basic parameters
+            const validation = parameter_validator_js_1.ParameterValidator.validateToolParams('git-dependencies', 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-dependencies', 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);
+            }
+            // Detect package manager if not specified
+            const packageManager = params.packageManager || this.detectPackageManager(params.projectPath);
+            // Route to appropriate handler
+            switch (params.action) {
+                case 'list':
+                    return await this.handleList(params, packageManager, startTime);
+                case 'outdated':
+                    return await this.handleOutdated(params, packageManager, startTime);
+                case 'update':
+                    return await this.handleUpdate(params, packageManager, startTime);
+                case 'audit':
+                    return await this.handleAudit(params, packageManager, startTime);
+                case 'changelog':
+                    return await this.handleChangelog(params, packageManager, startTime);
+                case 'compare':
+                    return await this.handleCompare(params, packageManager, startTime);
+                default:
+                    return operation_error_handler_js_1.OperationErrorHandler.createToolError('INVALID_ACTION', `Unknown action: ${params.action}`, params.action, { supportedActions: ['list', 'outdated', 'update', 'audit', 'changelog', 'compare'] }, ['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']);
+        }
+    }
+    /**
+     * Detect package manager
+     */
+    detectPackageManager(projectPath) {
+        const packageFiles = {
+            'package.json': 'npm',
+            'yarn.lock': 'yarn',
+            'pnpm-lock.yaml': 'pnpm',
+            'requirements.txt': 'pip',
+            'Cargo.toml': 'cargo',
+            'composer.json': 'composer',
+            'pom.xml': 'maven',
+            'build.gradle': 'gradle'
+        };
+        for (const [file, manager] of Object.entries(packageFiles)) {
+            if (fs_1.default.existsSync(path_1.default.join(projectPath, file))) {
+                return manager;
+            }
+        }
+        return 'npm'; // Default to npm
+    }
+    /**
+     * List dependencies
+     */
+    async handleList(params, packageManager, startTime) {
+        try {
+            const dependencies = await this.getDependencies(params, packageManager);
+            const executionTime = Date.now() - startTime;
+            return {
+                success: true,
+                data: {
+                    dependencies: {
+                        packageManager,
+                        dependencies,
+                        count: dependencies.length,
+                        format: params.format || 'json'
+                    },
+                    message: `Listed ${dependencies.length} dependencies using ${packageManager}`,
+                    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 dependencies: ${errorMessage}`, params.action, { packageManager, error: errorMessage }, ['Check package manager configuration', 'Verify package files exist']);
+        }
+    }
+    /**
+     * Check for outdated dependencies
+     */
+    async handleOutdated(params, packageManager, startTime) {
+        try {
+            const outdated = await this.getOutdatedDependencies(params, packageManager);
+            const executionTime = Date.now() - startTime;
+            return {
+                success: true,
+                data: {
+                    dependencies: {
+                        packageManager,
+                        outdated,
+                        count: outdated.length,
+                        format: params.format || 'json'
+                    },
+                    message: `Found ${outdated.length} outdated dependencies using ${packageManager}`,
+                    executionTime
+                }
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return operation_error_handler_js_1.OperationErrorHandler.createToolError('OUTDATED_ERROR', `Failed to check outdated dependencies: ${errorMessage}`, params.action, { packageManager, error: errorMessage }, ['Check package manager configuration', 'Verify network connectivity']);
+        }
+    }
+    /**
+     * Update dependencies
+     */
+    async handleUpdate(params, packageManager, startTime) {
+        try {
+            // Create branch if requested
+            let branchName = '';
+            if (params.createBranch) {
+                branchName = params.branchName || `update-dependencies-${Date.now()}`;
+                await this.createBranch(branchName, params.projectPath);
+            }
+            const updates = await this.updateDependencies(params, packageManager);
+            // Commit changes if requested
+            if (params.autoCommit && updates.length > 0) {
+                const commitMessage = params.commitMessage || `chore: update dependencies (${updates.length} packages)`;
+                await this.commitUpdates(commitMessage, params.projectPath);
+            }
+            const executionTime = Date.now() - startTime;
+            return {
+                success: true,
+                data: {
+                    dependencies: {
+                        packageManager,
+                        updates,
+                        count: updates.length,
+                        branchName,
+                        committed: params.autoCommit,
+                        format: params.format || 'json'
+                    },
+                    message: `Updated ${updates.length} dependencies using ${packageManager}`,
+                    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 dependencies: ${errorMessage}`, params.action, { packageManager, error: errorMessage }, ['Check package manager configuration', 'Verify package files exist']);
+        }
+    }
+    /**
+     * Audit dependencies
+     */
+    async handleAudit(params, packageManager, startTime) {
+        try {
+            const audit = await this.auditDependencies(params, packageManager);
+            const executionTime = Date.now() - startTime;
+            return {
+                success: true,
+                data: {
+                    dependencies: {
+                        packageManager,
+                        audit,
+                        vulnerabilities: audit.vulnerabilities || [],
+                        count: (audit.vulnerabilities || []).length,
+                        format: params.format || 'json'
+                    },
+                    message: `Audit completed using ${packageManager}. Found ${(audit.vulnerabilities || []).length} vulnerabilities.`,
+                    executionTime
+                }
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return operation_error_handler_js_1.OperationErrorHandler.createToolError('AUDIT_ERROR', `Failed to audit dependencies: ${errorMessage}`, params.action, { packageManager, error: errorMessage }, ['Check package manager configuration', 'Verify audit command is available']);
+        }
+    }
+    /**
+     * Get dependency changelog
+     */
+    async handleChangelog(params, packageManager, startTime) {
+        try {
+            if (!params.packageName) {
+                return operation_error_handler_js_1.OperationErrorHandler.createToolError('MISSING_PACKAGE', 'Package name is required for changelog', params.action, { packageName: params.packageName }, ['Provide packageName parameter']);
+            }
+            const changelog = await this.getPackageChangelog(params.packageName, packageManager, params);
+            const executionTime = Date.now() - startTime;
+            return {
+                success: true,
+                data: {
+                    dependencies: {
+                        packageManager,
+                        packageName: params.packageName,
+                        changelog,
+                        format: params.format || 'json'
+                    },
+                    message: `Retrieved changelog for ${params.packageName}`,
+                    executionTime
+                }
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return operation_error_handler_js_1.OperationErrorHandler.createToolError('CHANGELOG_ERROR', `Failed to get changelog: ${errorMessage}`, params.action, { packageManager, packageName: params.packageName, error: errorMessage }, ['Check package name is valid', 'Verify package manager supports changelog']);
+        }
+    }
+    /**
+     * Compare dependency versions
+     */
+    async handleCompare(params, packageManager, startTime) {
+        try {
+            if (!params.packageName || !params.compareWith) {
+                return operation_error_handler_js_1.OperationErrorHandler.createToolError('MISSING_PARAMETERS', 'Both packageName and compareWith are required for comparison', params.action, { packageName: params.packageName, compareWith: params.compareWith }, ['Provide both packageName and compareWith parameters']);
+            }
+            const comparison = await this.compareVersions(params.packageName, params.compareWith, packageManager, params);
+            const executionTime = Date.now() - startTime;
+            return {
+                success: true,
+                data: {
+                    dependencies: {
+                        packageManager,
+                        packageName: params.packageName,
+                        comparison,
+                        format: params.format || 'json'
+                    },
+                    message: `Compared versions for ${params.packageName}`,
+                    executionTime
+                }
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return operation_error_handler_js_1.OperationErrorHandler.createToolError('COMPARE_ERROR', `Failed to compare versions: ${errorMessage}`, params.action, { packageManager, packageName: params.packageName, error: errorMessage }, ['Check package name is valid', 'Verify version format']);
+        }
+    }
+    /**
+     * Get dependencies list
+     */
+    async getDependencies(params, packageManager) {
+        let command = '';
+        switch (packageManager) {
+            case 'npm':
+                command = 'npm list --depth=0 --json';
+                break;
+            case 'yarn':
+                command = 'yarn list --depth=0 --json';
+                break;
+            case 'pnpm':
+                command = 'pnpm list --depth=0 --json';
+                break;
+            case 'pip':
+                command = 'pip list --format=json';
+                break;
+            case 'cargo':
+                command = 'cargo tree --format "{p} {f}"';
+                break;
+            default:
+                throw new Error(`Unsupported package manager: ${packageManager}`);
+        }
+        const result = await this.gitExecutor.executeGitCommand(command, [], params.projectPath);
+        if (!result.success) {
+            throw new Error(`Failed to list dependencies: ${result.stderr}`);
+        }
+        return this.parseDependenciesList(result.stdout, packageManager);
+    }
+    /**
+     * Get outdated dependencies
+     */
+    async getOutdatedDependencies(params, packageManager) {
+        let command = '';
+        switch (packageManager) {
+            case 'npm':
+                command = 'npm outdated --json';
+                break;
+            case 'yarn':
+                command = 'yarn outdated --json';
+                break;
+            case 'pnpm':
+                command = 'pnpm outdated --json';
+                break;
+            case 'pip':
+                command = 'pip list --outdated --format=json';
+                break;
+            case 'cargo':
+                command = 'cargo outdated --format json';
+                break;
+            default:
+                throw new Error(`Unsupported package manager: ${packageManager}`);
+        }
+        const result = await this.gitExecutor.executeGitCommand(command, [], params.projectPath);
+        if (!result.success) {
+            throw new Error(`Failed to check outdated dependencies: ${result.stderr}`);
+        }
+        return this.parseOutdatedDependencies(result.stdout, packageManager);
+    }
+    /**
+     * Update dependencies
+     */
+    async updateDependencies(params, packageManager) {
+        let command = '';
+        if (params.packageName) {
+            // Update specific package
+            switch (packageManager) {
+                case 'npm':
+                    command = `npm update ${params.packageName}`;
+                    break;
+                case 'yarn':
+                    command = `yarn upgrade ${params.packageName}`;
+                    break;
+                case 'pnpm':
+                    command = `pnpm update ${params.packageName}`;
+                    break;
+                case 'pip':
+                    command = `pip install --upgrade ${params.packageName}`;
+                    break;
+                case 'cargo':
+                    command = `cargo update -p ${params.packageName}`;
+                    break;
+            }
+        }
+        else {
+            // Update all packages
+            switch (packageManager) {
+                case 'npm':
+                    command = 'npm update';
+                    break;
+                case 'yarn':
+                    command = 'yarn upgrade';
+                    break;
+                case 'pnpm':
+                    command = 'pnpm update';
+                    break;
+                case 'pip':
+                    command = 'pip install --upgrade -r requirements.txt';
+                    break;
+                case 'cargo':
+                    command = 'cargo update';
+                    break;
+            }
+        }
+        const result = await this.gitExecutor.executeGitCommand(command, [], params.projectPath);
+        if (!result.success) {
+            throw new Error(`Failed to update dependencies: ${result.stderr}`);
+        }
+        return this.parseUpdateResult(result.stdout, packageManager);
+    }
+    /**
+     * Audit dependencies
+     */
+    async auditDependencies(params, packageManager) {
+        let command = '';
+        switch (packageManager) {
+            case 'npm':
+                command = 'npm audit --json';
+                break;
+            case 'yarn':
+                command = 'yarn audit --json';
+                break;
+            case 'pnpm':
+                command = 'pnpm audit --json';
+                break;
+            case 'pip':
+                command = 'safety check --json';
+                break;
+            case 'cargo':
+                command = 'cargo audit --json';
+                break;
+            default:
+                throw new Error(`Unsupported package manager: ${packageManager}`);
+        }
+        const result = await this.gitExecutor.executeGitCommand(command, [], params.projectPath);
+        if (!result.success) {
+            throw new Error(`Failed to audit dependencies: ${result.stderr}`);
+        }
+        return this.parseAuditResult(result.stdout, packageManager);
+    }
+    /**
+     * Get package changelog
+     */
+    async getPackageChangelog(packageName, packageManager, params) {
+        let command = '';
+        switch (packageManager) {
+            case 'npm':
+                command = `npm view ${packageName} versions --json`;
+                break;
+            case 'yarn':
+                command = `yarn info ${packageName} versions --json`;
+                break;
+            case 'pip':
+                command = `pip show ${packageName}`;
+                break;
+            default:
+                throw new Error(`Changelog not supported for ${packageManager}`);
+        }
+        const result = await this.gitExecutor.executeGitCommand(command, [], params.projectPath);
+        if (!result.success) {
+            throw new Error(`Failed to get changelog: ${result.stderr}`);
+        }
+        return this.parseChangelogResult(result.stdout, packageManager, packageName);
+    }
+    /**
+     * Compare package versions
+     */
+    async compareVersions(packageName, compareWith, packageManager, params) {
+        // Get current version
+        const currentResult = await this.gitExecutor.executeGitCommand('npm', ['list', packageName, '--depth=0', '--json'], params.projectPath);
+        const currentVersion = this.extractVersionFromOutput(currentResult.stdout, packageName);
+        return {
+            packageName,
+            currentVersion,
+            compareWith,
+            difference: this.compareVersionStrings(currentVersion, compareWith),
+            upgradeAvailable: this.isVersionNewer(compareWith, currentVersion),
+            downgradeAvailable: this.isVersionNewer(currentVersion, compareWith)
+        };
+    }
+    /**
+     * Create branch for updates
+     */
+    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}`);
+        }
+    }
+    /**
+     * Commit dependency updates
+     */
+    async commitUpdates(message, projectPath) {
+        // Add changed files
+        await this.gitExecutor.executeGitCommand('git', ['add', 'package.json', 'package-lock.json', 'yarn.lock', 'pnpm-lock.yaml', 'requirements.txt', 'Cargo.toml', 'composer.json', 'pom.xml', 'build.gradle'], projectPath);
+        // Commit changes
+        const result = await this.gitExecutor.executeGitCommand('git', ['commit', '-m', message], projectPath);
+        if (!result.success) {
+            throw new Error(`Failed to commit updates: ${result.stderr}`);
+        }
+    }
+    /**
+     * Parse dependencies list output
+     */
+    parseDependenciesList(output, packageManager) {
+        try {
+            switch (packageManager) {
+                case 'npm':
+                case 'yarn':
+                case 'pnpm':
+                    const data = JSON.parse(output);
+                    const dependencies = data.dependencies || {};
+                    return Object.entries(dependencies).map(([name, info]) => ({
+                        name,
+                        version: info.version,
+                        type: info.dev ? 'devDependency' : 'dependency'
+                    }));
+                case 'pip':
+                    const pipData = JSON.parse(output);
+                    return pipData.map((pkg) => ({
+                        name: pkg.name,
+                        version: pkg.version,
+                        type: 'dependency'
+                    }));
+                default:
+                    return [];
+            }
+        }
+        catch (error) {
+            return [];
+        }
+    }
+    /**
+     * Parse outdated dependencies output
+     */
+    parseOutdatedDependencies(output, packageManager) {
+        try {
+            switch (packageManager) {
+                case 'npm':
+                case 'yarn':
+                case 'pnpm':
+                    const data = JSON.parse(output);
+                    return Object.entries(data).map(([name, info]) => ({
+                        name,
+                        current: info.current,
+                        wanted: info.wanted,
+                        latest: info.latest,
+                        type: info.type || 'dependency'
+                    }));
+                case 'pip':
+                    const pipData = JSON.parse(output);
+                    return pipData.map((pkg) => ({
+                        name: pkg.name,
+                        current: pkg.version,
+                        latest: pkg.latest_version,
+                        type: 'dependency'
+                    }));
+                default:
+                    return [];
+            }
+        }
+        catch (error) {
+            return [];
+        }
+    }
+    /**
+     * Parse update result
+     */
+    parseUpdateResult(output, packageManager) {
+        // Parse update output to extract updated packages
+        const lines = output.split('\n');
+        const updates = [];
+        for (const line of lines) {
+            if (line.includes('updated') || line.includes('upgraded')) {
+                // Extract package name and version from output
+                const match = line.match(/(\w+)@([^\s]+)/);
+                if (match) {
+                    updates.push({
+                        name: match[1],
+                        version: match[2],
+                        updated: true
+                    });
+                }
+            }
+        }
+        return updates;
+    }
+    /**
+     * Parse audit result
+     */
+    parseAuditResult(output, packageManager) {
+        try {
+            const data = JSON.parse(output);
+            switch (packageManager) {
+                case 'npm':
+                case 'yarn':
+                case 'pnpm':
+                    return {
+                        vulnerabilities: data.vulnerabilities || [],
+                        summary: data.metadata || {},
+                        advisories: data.advisories || {}
+                    };
+                default:
+                    return { vulnerabilities: [] };
+            }
+        }
+        catch (error) {
+            return { vulnerabilities: [] };
+        }
+    }
+    /**
+     * Parse changelog result
+     */
+    parseChangelogResult(output, packageManager, packageName) {
+        try {
+            switch (packageManager) {
+                case 'npm':
+                    const data = JSON.parse(output);
+                    return {
+                        packageName,
+                        versions: data,
+                        latest: data[data.length - 1],
+                        count: data.length
+                    };
+                case 'pip':
+                    return {
+                        packageName,
+                        info: output,
+                        parsed: this.parsePipShowOutput(output)
+                    };
+                default:
+                    return { packageName, info: output };
+            }
+        }
+        catch (error) {
+            return { packageName, error: 'Failed to parse changelog' };
+        }
+    }
+    /**
+     * Parse pip show output
+     */
+    parsePipShowOutput(output) {
+        const lines = output.split('\n');
+        const info = {};
+        for (const line of lines) {
+            const [key, value] = line.split(': ', 2);
+            if (key && value) {
+                info[key.toLowerCase().replace(/\s+/g, '_')] = value;
+            }
+        }
+        return info;
+    }
+    /**
+     * Extract version from output
+     */
+    extractVersionFromOutput(output, packageName) {
+        try {
+            const data = JSON.parse(output);
+            const pkg = data.dependencies?.[packageName];
+            return pkg?.version || 'unknown';
+        }
+        catch {
+            return 'unknown';
+        }
+    }
+    /**
+     * Compare version strings
+     */
+    compareVersionStrings(version1, version2) {
+        // Simple version comparison - can be enhanced with semver library
+        const v1parts = version1.split('.').map(Number);
+        const v2parts = version2.split('.').map(Number);
+        for (let i = 0; i < Math.max(v1parts.length, v2parts.length); i++) {
+            const v1part = v1parts[i] || 0;
+            const v2part = v2parts[i] || 0;
+            if (v1part > v2part)
+                return 'higher';
+            if (v1part < v2part)
+                return 'lower';
+        }
+        return 'equal';
+    }
+    /**
+     * Check if version is newer
+     */
+    isVersionNewer(version1, version2) {
+        return this.compareVersionStrings(version1, version2) === 'higher';
+    }
+    /**
+     * Get tool schema for MCP registration
+     */
+    static getToolSchema() {
+        return {
+            name: 'git-dependencies',
+            description: 'Dependency analysis and management tool. Supports multiple package managers for listing, updating, auditing, and comparing dependencies.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    "action": {
+                        "type": "string",
+                        "enum": [
+                            "list",
+                            "outdated",
+                            "update",
+                            "audit",
+                            "changelog",
+                            "compare"
+                        ],
+                        "description": "The operation to perform"
+                    },
+                    "projectPath": {
+                        "type": "string",
+                        "description": "Path to the Git repository"
+                    },
+                    "packageManager": {
+                        "type": "string",
+                        "description": "packageManager parameter"
+                    },
+                    "packageName": {
+                        "type": "string",
+                        "description": "packageName parameter"
+                    },
+                    "packageNames": {
+                        "type": "array",
+                        "items": {
+                            "type": "string"
+                        },
+                        "description": "packageNames parameter"
+                    },
+                    "updateType": {
+                        "type": "string",
+                        "description": "updateType parameter"
+                    },
+                    "autoCommit": {
+                        "type": "string",
+                        "description": "autoCommit parameter"
+                    },
+                    "commitMessage": {
+                        "type": "string",
+                        "description": "commitMessage parameter"
+                    },
+                    "includeDevDeps": {
+                        "type": "string",
+                        "description": "includeDevDeps parameter"
+                    },
+                    "includePeerDeps": {
+                        "type": "string",
+                        "description": "includePeerDeps parameter"
+                    },
+                    "includeOptionalDeps": {
+                        "type": "string",
+                        "description": "includeOptionalDeps parameter"
+                    },
+                    "auditLevel": {
+                        "type": "string",
+                        "description": "auditLevel parameter"
+                    },
+                    "fixVulnerabilities": {
+                        "type": "string",
+                        "description": "fixVulnerabilities parameter"
+                    },
+                    "compareWith": {
+                        "type": "string",
+                        "description": "compareWith parameter"
+                    },
+                    "format": {
+                        "type": "string",
+                        "description": "format parameter"
+                    },
+                    "output": {
+                        "type": "string",
+                        "description": "output parameter"
+                    },
+                    "createBranch": {
+                        "type": "string",
+                        "description": "createBranch parameter"
+                    },
+                    "branchName": {
+                        "type": "string",
+                        "description": "branchName parameter"
+                    },
+                    "createPR": {
+                        "type": "string",
+                        "description": "createPR parameter"
+                    }
+                },
+                required: ['action', 'projectPath'],
+                additionalProperties: false
+            },
+            errorCodes: {
+                'VALIDATION_ERROR': 'Parameter validation failed',
+                'EXECUTION_ERROR': 'Tool execution failed'
+            }
+        };
+    }
+}
+exports.GitDependenciesTool = GitDependenciesTool;
+//# sourceMappingURL=git-dependencies.js.map