@andrebuzeli/git-mcp 5.5.0 → 5.5.2

package/dist/tools/git-remote.d.ts

@@ -1,128 +0,0 @@
-/**
- * Git Remote Tool
- *
- * Comprehensive Git remote management tool providing remote repository operations.
- * Supports add, remove, rename, show, set-url, and prune operations.
- *
- * Operations: add, remove, rename, show, set-url, prune
- */
-import { ToolParams } from '../utils/parameter-validator.js';
-import { ToolResult } from '../utils/operation-error-handler.js';
-export interface GitRemoteParams extends ToolParams {
-    action: 'add' | 'remove' | 'rename' | 'show' | 'set-url' | 'prune' | 'list';
-    name?: string;
-    url?: string;
-    newName?: string;
-    fetch?: boolean;
-    push?: boolean;
-    all?: boolean;
-    verbose?: boolean;
-    dryRun?: boolean;
-}
-export declare class GitRemoteTool {
-    private gitExecutor;
-    constructor();
-    /**
-     * Execute git-remote operation
-     */
-    execute(params: GitRemoteParams): Promise<ToolResult>;
-    /**
-     * Validate operation-specific parameters
-     */
-    private validateOperationParams;
-    /**
-     * Handle git remote add operation
-     */
-    private handleAdd;
-    /**
-     * Handle git remote remove operation
-     */
-    private handleRemove;
-    /**
-     * Handle git remote rename operation
-     */
-    private handleRename;
-    /**
-     * Handle git remote show operation
-     */
-    private handleShow;
-    /**
-     * Handle git remote set-url operation
-     */
-    private handleSetUrl;
-    /**
-     * Handle git remote prune operation
-     */
-    private handlePrune;
-    /**
-     * Handle list remotes
-     */
-    private handleList;
-    /**
-     * Parse remote details from git remote show output
-     */
-    private parseRemoteDetails;
-    /**
-     * Parse verbose remotes output
-     */
-    private parseVerboseRemotes;
-    /**
-     * Parse pruned branches from git remote prune output
-     */
-    private parsePrunedBranches;
-    /**
-     * Get tool schema for MCP registration
-     */
-    static getToolSchema(): {
-        name: string;
-        description: string;
-        inputSchema: {
-            type: string;
-            properties: {
-                action: {
-                    type: string;
-                    enum: string[];
-                    description: string;
-                };
-                projectPath: {
-                    type: string;
-                    description: string;
-                };
-                name: {
-                    type: string;
-                    description: string;
-                };
-                url: {
-                    type: string;
-                    description: string;
-                };
-                newName: {
-                    type: string;
-                    description: string;
-                };
-                fetch: {
-                    type: string;
-                    description: string;
-                };
-                push: {
-                    type: string;
-                    description: string;
-                };
-                all: {
-                    type: string;
-                    description: string;
-                };
-                verbose: {
-                    type: string;
-                    description: string;
-                };
-                dryRun: {
-                    type: string;
-                    description: string;
-                };
-            };
-            required: string[];
-        };
-    };
-}
-//# sourceMappingURL=git-remote.d.ts.map

package/dist/tools/git-remote.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"git-remote.d.ts","sourceRoot":"","sources":["../../src/tools/git-remote.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EAAsB,UAAU,EAAE,MAAM,iCAAiC,CAAC;AACjF,OAAO,EAAyB,UAAU,EAAE,MAAM,qCAAqC,CAAC;AAGxF,MAAM,WAAW,eAAgB,SAAQ,UAAU;IACjD,MAAM,EAAE,KAAK,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,GAAG,SAAS,GAAG,OAAO,GAAG,MAAM,CAAC;IAG5E,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;IAGjB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,qBAAa,aAAa;IACxB,OAAO,CAAC,WAAW,CAAqB;;IAMxC;;OAEG;IACG,OAAO,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,UAAU,CAAC;IA8E3D;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAgE/B;;OAEG;YACW,SAAS;IA8CvB;;OAEG;YACW,YAAY;IA+C1B;;OAEG;YACW,YAAY;IAyD1B;;OAEG;YACW,UAAU;IA4DxB;;OAEG;YACW,YAAY;IA0D1B;;OAEG;YACW,WAAW;IA+DzB;;OAEG;YACW,UAAU;IAsCxB;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAkB1B;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAgC3B;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAiB3B;;OAEG;IACH,MAAM,CAAC,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqDrB"}

package/dist/tools/git-remote.js

@@ -1,542 +0,0 @@
-"use strict";
-/**
- * Git Remote Tool
- *
- * Comprehensive Git remote management tool providing remote repository operations.
- * Supports add, remove, rename, show, set-url, and prune operations.
- *
- * Operations: add, remove, rename, show, set-url, prune
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GitRemoteTool = 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");
-class GitRemoteTool {
-    gitExecutor;
-    constructor() {
-        this.gitExecutor = new git_command_executor_js_1.GitCommandExecutor();
-    }
-    /**
-     * Execute git-remote operation
-     */
-    async execute(params) {
-        const startTime = Date.now();
-        try {
-            // Validate basic parameters
-            const validation = parameter_validator_js_1.ParameterValidator.validateToolParams('git-remote', 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 = this.validateOperationParams(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);
-            }
-            // Check if it's a Git repository
-            const isRepo = await this.gitExecutor.isGitRepository(params.projectPath);
-            if (!isRepo) {
-                return operation_error_handler_js_1.OperationErrorHandler.createToolError('NOT_A_GIT_REPOSITORY', 'The specified path is not a Git repository', params.action, { projectPath: params.projectPath }, ['Initialize a Git repository first with: git init']);
-            }
-            // Route to appropriate handler
-            switch (params.action) {
-                case 'add':
-                    return await this.handleAdd(params, startTime);
-                case 'remove':
-                    return await this.handleRemove(params, startTime);
-                case 'rename':
-                    return await this.handleRename(params, startTime);
-                case 'show':
-                    return await this.handleShow(params, startTime);
-                case 'set-url':
-                    return await this.handleSetUrl(params, startTime);
-                case 'prune':
-                    return await this.handlePrune(params, startTime);
-                case 'list':
-                    return await this.handleList(params, startTime);
-                default:
-                    return operation_error_handler_js_1.OperationErrorHandler.createToolError('UNSUPPORTED_OPERATION', `Operation '${params.action}' is not supported`, params.action, {}, ['Use one of: add, remove, rename, show, set-url, prune, list']);
-            }
-        }
-        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']);
-        }
-    }
-    /**
-     * Validate operation-specific parameters
-     */
-    validateOperationParams(params) {
-        const errors = [];
-        const suggestions = [];
-        switch (params.action) {
-            case 'add':
-                if (!params.name) {
-                    errors.push('Remote name is required for add operation');
-                    suggestions.push('Provide a remote name (e.g., "origin", "upstream")');
-                }
-                if (!params.url) {
-                    errors.push('Remote URL is required for add operation');
-                    suggestions.push('Provide a remote URL (e.g., "https://github.com/user/repo.git")');
-                }
-                break;
-            case 'remove':
-                if (!params.name) {
-                    errors.push('Remote name is required for remove operation');
-                    suggestions.push('Provide the name of the remote to remove');
-                }
-                break;
-            case 'rename':
-                if (!params.name) {
-                    errors.push('Current remote name is required for rename operation');
-                    suggestions.push('Provide the current remote name');
-                }
-                if (!params.newName) {
-                    errors.push('New remote name is required for rename operation');
-                    suggestions.push('Provide the new remote name');
-                }
-                break;
-            case 'set-url':
-                if (!params.name) {
-                    errors.push('Remote name is required for set-url operation');
-                    suggestions.push('Provide the remote name to update');
-                }
-                if (!params.url) {
-                    errors.push('Remote URL is required for set-url operation');
-                    suggestions.push('Provide the new remote URL');
-                }
-                break;
-            case 'prune':
-                if (!params.name) {
-                    errors.push('Remote name is required for prune operation');
-                    suggestions.push('Provide the remote name to prune (e.g., "origin")');
-                }
-                break;
-            case 'show':
-                // Show operation can work without parameters (shows all remotes)
-                break;
-        }
-        return {
-            isValid: errors.length === 0,
-            errors,
-            suggestions
-        };
-    }
-    /**
-     * Handle git remote add operation
-     */
-    async handleAdd(params, startTime) {
-        try {
-            const args = [params.name, params.url];
-            // Add fetch option if specified
-            if (params.fetch) {
-                args.unshift('-f');
-            }
-            const result = await this.gitExecutor.executeGitCommand('remote', ['add', ...args], params.projectPath);
-            if (!result.success) {
-                return operation_error_handler_js_1.OperationErrorHandler.handleGitError(result.stderr, 'remote add', params.projectPath);
-            }
-            // If fetch was requested, the output will include fetch information
-            const message = params.fetch
-                ? `Remote '${params.name}' added and fetched successfully`
-                : `Remote '${params.name}' added successfully`;
-            return {
-                success: true,
-                data: {
-                    message,
-                    remoteName: params.name,
-                    remoteUrl: params.url,
-                    fetched: params.fetch || false,
-                    output: result.stdout
-                },
-                metadata: {
-                    operation: 'remote add',
-                    timestamp: new Date().toISOString(),
-                    executionTime: Date.now() - startTime
-                }
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            return operation_error_handler_js_1.OperationErrorHandler.createToolError('REMOTE_ADD_ERROR', `Failed to add remote: ${errorMessage}`, 'add', { error: errorMessage, remoteName: params.name, remoteUrl: params.url });
-        }
-    }
-    /**
-     * Handle git remote remove operation
-     */
-    async handleRemove(params, startTime) {
-        try {
-            // Check if remote exists first
-            const showResult = await this.gitExecutor.executeGitCommand('remote', ['show'], params.projectPath);
-            if (showResult.success) {
-                const remotes = showResult.stdout.split('\n').filter(line => line.trim());
-                if (!remotes.includes(params.name)) {
-                    return operation_error_handler_js_1.OperationErrorHandler.createToolError('REMOTE_NOT_FOUND', `Remote '${params.name}' does not exist`, 'remove', { remoteName: params.name, availableRemotes: remotes }, [`Available remotes: ${remotes.join(', ')}`]);
-                }
-            }
-            const result = await this.gitExecutor.executeGitCommand('remote', ['remove', params.name], params.projectPath);
-            if (!result.success) {
-                return operation_error_handler_js_1.OperationErrorHandler.handleGitError(result.stderr, 'remote remove', params.projectPath);
-            }
-            return {
-                success: true,
-                data: {
-                    message: `Remote '${params.name}' removed successfully`,
-                    remoteName: params.name,
-                    output: result.stdout
-                },
-                metadata: {
-                    operation: 'remote remove',
-                    timestamp: new Date().toISOString(),
-                    executionTime: Date.now() - startTime
-                }
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            return operation_error_handler_js_1.OperationErrorHandler.createToolError('REMOTE_REMOVE_ERROR', `Failed to remove remote: ${errorMessage}`, 'remove', { error: errorMessage, remoteName: params.name });
-        }
-    }
-    /**
-     * Handle git remote rename operation
-     */
-    async handleRename(params, startTime) {
-        try {
-            // Check if current remote exists
-            const showResult = await this.gitExecutor.executeGitCommand('remote', ['show'], params.projectPath);
-            if (showResult.success) {
-                const remotes = showResult.stdout.split('\n').filter(line => line.trim());
-                if (!remotes.includes(params.name)) {
-                    return operation_error_handler_js_1.OperationErrorHandler.createToolError('REMOTE_NOT_FOUND', `Remote '${params.name}' does not exist`, 'rename', { remoteName: params.name, availableRemotes: remotes }, [`Available remotes: ${remotes.join(', ')}`]);
-                }
-                if (remotes.includes(params.newName)) {
-                    return operation_error_handler_js_1.OperationErrorHandler.createToolError('REMOTE_ALREADY_EXISTS', `Remote '${params.newName}' already exists`, 'rename', { newRemoteName: params.newName, availableRemotes: remotes }, ['Choose a different name for the remote']);
-                }
-            }
-            const result = await this.gitExecutor.executeGitCommand('remote', ['rename', params.name, params.newName], params.projectPath);
-            if (!result.success) {
-                return operation_error_handler_js_1.OperationErrorHandler.handleGitError(result.stderr, 'remote rename', params.projectPath);
-            }
-            return {
-                success: true,
-                data: {
-                    message: `Remote '${params.name}' renamed to '${params.newName}' successfully`,
-                    oldName: params.name,
-                    newName: params.newName,
-                    output: result.stdout
-                },
-                metadata: {
-                    operation: 'remote rename',
-                    timestamp: new Date().toISOString(),
-                    executionTime: Date.now() - startTime
-                }
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            return operation_error_handler_js_1.OperationErrorHandler.createToolError('REMOTE_RENAME_ERROR', `Failed to rename remote: ${errorMessage}`, 'rename', { error: errorMessage, oldName: params.name, newName: params.newName });
-        }
-    }
-    /**
-     * Handle git remote show operation
-     */
-    async handleShow(params, startTime) {
-        try {
-            const args = [];
-            if (params.verbose) {
-                args.push('-v');
-            }
-            if (params.name && !params.all) {
-                // Show specific remote details
-                args.push(params.name);
-            }
-            const result = await this.gitExecutor.executeGitCommand('remote', ['show', ...args], params.projectPath);
-            if (!result.success) {
-                return operation_error_handler_js_1.OperationErrorHandler.handleGitError(result.stderr, 'remote show', params.projectPath);
-            }
-            // Parse the output
-            const output = result.stdout.trim();
-            let parsedData = { raw: output };
-            if (params.name && !params.all) {
-                // Detailed remote information
-                parsedData.remoteName = params.name;
-                parsedData.details = this.parseRemoteDetails(output);
-            }
-            else {
-                // List of remotes
-                const lines = output.split('\n').filter(line => line.trim());
-                if (params.verbose) {
-                    parsedData.remotes = this.parseVerboseRemotes(lines);
-                }
-                else {
-                    parsedData.remotes = lines;
-                }
-            }
-            return {
-                success: true,
-                data: {
-                    message: params.name ? `Remote '${params.name}' details` : 'Remote repositories',
-                    ...parsedData
-                },
-                metadata: {
-                    operation: 'remote show',
-                    timestamp: new Date().toISOString(),
-                    executionTime: Date.now() - startTime
-                }
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            return operation_error_handler_js_1.OperationErrorHandler.createToolError('REMOTE_SHOW_ERROR', `Failed to show remote information: ${errorMessage}`, 'show', { error: errorMessage, remoteName: params.name });
-        }
-    }
-    /**
-     * Handle git remote set-url operation
-     */
-    async handleSetUrl(params, startTime) {
-        try {
-            // Check if remote exists
-            const showResult = await this.gitExecutor.executeGitCommand('remote', ['show'], params.projectPath);
-            if (showResult.success) {
-                const remotes = showResult.stdout.split('\n').filter(line => line.trim());
-                if (!remotes.includes(params.name)) {
-                    return operation_error_handler_js_1.OperationErrorHandler.createToolError('REMOTE_NOT_FOUND', `Remote '${params.name}' does not exist`, 'set-url', { remoteName: params.name, availableRemotes: remotes }, [`Available remotes: ${remotes.join(', ')}`]);
-                }
-            }
-            const args = [params.name, params.url];
-            // Add push option if specified
-            if (params.push) {
-                args.unshift('--push');
-            }
-            const result = await this.gitExecutor.executeGitCommand('remote', ['set-url', ...args], params.projectPath);
-            if (!result.success) {
-                return operation_error_handler_js_1.OperationErrorHandler.handleGitError(result.stderr, 'remote set-url', params.projectPath);
-            }
-            const urlType = params.push ? 'push URL' : 'URL';
-            return {
-                success: true,
-                data: {
-                    message: `Remote '${params.name}' ${urlType} updated successfully`,
-                    remoteName: params.name,
-                    newUrl: params.url,
-                    urlType: params.push ? 'push' : 'fetch',
-                    output: result.stdout
-                },
-                metadata: {
-                    operation: 'remote set-url',
-                    timestamp: new Date().toISOString(),
-                    executionTime: Date.now() - startTime
-                }
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            return operation_error_handler_js_1.OperationErrorHandler.createToolError('REMOTE_SET_URL_ERROR', `Failed to set remote URL: ${errorMessage}`, 'set-url', { error: errorMessage, remoteName: params.name, url: params.url });
-        }
-    }
-    /**
-     * Handle git remote prune operation
-     */
-    async handlePrune(params, startTime) {
-        try {
-            // Check if remote exists
-            const showResult = await this.gitExecutor.executeGitCommand('remote', ['show'], params.projectPath);
-            if (showResult.success) {
-                const remotes = showResult.stdout.split('\n').filter(line => line.trim());
-                if (!remotes.includes(params.name)) {
-                    return operation_error_handler_js_1.OperationErrorHandler.createToolError('REMOTE_NOT_FOUND', `Remote '${params.name}' does not exist`, 'prune', { remoteName: params.name, availableRemotes: remotes }, [`Available remotes: ${remotes.join(', ')}`]);
-                }
-            }
-            const args = [params.name];
-            // Add dry-run option if specified
-            if (params.dryRun) {
-                args.unshift('--dry-run');
-            }
-            const result = await this.gitExecutor.executeGitCommand('remote', ['prune', ...args], params.projectPath);
-            if (!result.success) {
-                return operation_error_handler_js_1.OperationErrorHandler.handleGitError(result.stderr, 'remote prune', params.projectPath);
-            }
-            // Parse pruned branches from output
-            const prunedBranches = this.parsePrunedBranches(result.stdout);
-            const message = params.dryRun
-                ? `Dry run: Would prune ${prunedBranches.length} stale branches from '${params.name}'`
-                : `Pruned ${prunedBranches.length} stale branches from '${params.name}'`;
-            return {
-                success: true,
-                data: {
-                    message,
-                    remoteName: params.name,
-                    dryRun: params.dryRun || false,
-                    prunedBranches,
-                    output: result.stdout
-                },
-                metadata: {
-                    operation: 'remote prune',
-                    timestamp: new Date().toISOString(),
-                    executionTime: Date.now() - startTime
-                }
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            return operation_error_handler_js_1.OperationErrorHandler.createToolError('REMOTE_PRUNE_ERROR', `Failed to prune remote: ${errorMessage}`, 'prune', { error: errorMessage, remoteName: params.name });
-        }
-    }
-    /**
-     * Handle list remotes
-     */
-    async handleList(params, startTime) {
-        try {
-            const result = await this.gitExecutor.executeGitCommand('remote', [], params.projectPath);
-            if (!result.success) {
-                return operation_error_handler_js_1.OperationErrorHandler.handleGitError(result.stderr, 'remote list', params.projectPath);
-            }
-            // Parse remotes from output
-            const remotes = result.stdout
-                .split('\n')
-                .map(line => line.trim())
-                .filter(line => line.length > 0);
-            return {
-                success: true,
-                data: {
-                    operation: 'list',
-                    message: `Found ${remotes.length} remote(s)`,
-                    details: {
-                        remotes,
-                        count: remotes.length
-                    },
-                    duration: Date.now() - startTime
-                }
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            return operation_error_handler_js_1.OperationErrorHandler.createToolError('REMOTE_LIST_ERROR', `Failed to list remotes: ${errorMessage}`, 'list', { error: errorMessage });
-        }
-    }
-    /**
-     * Parse remote details from git remote show output
-     */
-    parseRemoteDetails(output) {
-        const lines = output.split('\n');
-        const details = {};
-        for (const line of lines) {
-            const trimmed = line.trim();
-            if (trimmed.includes('Fetch URL:')) {
-                details.fetchUrl = trimmed.split('Fetch URL:')[1]?.trim();
-            }
-            else if (trimmed.includes('Push  URL:')) {
-                details.pushUrl = trimmed.split('Push  URL:')[1]?.trim();
-            }
-            else if (trimmed.includes('HEAD branch:')) {
-                details.headBranch = trimmed.split('HEAD branch:')[1]?.trim();
-            }
-        }
-        return details;
-    }
-    /**
-     * Parse verbose remotes output
-     */
-    parseVerboseRemotes(lines) {
-        const remotes = [];
-        const remoteMap = new Map();
-        for (const line of lines) {
-            const parts = line.split('\t');
-            if (parts.length >= 2) {
-                const name = parts[0].trim();
-                const urlAndType = parts[1].trim();
-                const urlMatch = urlAndType.match(/^(.+?)\s+\((.+)\)$/);
-                if (urlMatch) {
-                    const url = urlMatch[1];
-                    const type = urlMatch[2];
-                    if (!remoteMap.has(name)) {
-                        remoteMap.set(name, { name });
-                    }
-                    const remote = remoteMap.get(name);
-                    if (type === 'fetch') {
-                        remote.fetchUrl = url;
-                    }
-                    else if (type === 'push') {
-                        remote.pushUrl = url;
-                    }
-                }
-            }
-        }
-        return Array.from(remoteMap.values());
-    }
-    /**
-     * Parse pruned branches from git remote prune output
-     */
-    parsePrunedBranches(output) {
-        const lines = output.split('\n');
-        const prunedBranches = [];
-        for (const line of lines) {
-            const trimmed = line.trim();
-            if (trimmed.startsWith('* [would prune]') || trimmed.startsWith('* [pruned]')) {
-                const branchMatch = trimmed.match(/\* \[(would prune|pruned)\] (.+)/);
-                if (branchMatch) {
-                    prunedBranches.push(branchMatch[2]);
-                }
-            }
-        }
-        return prunedBranches;
-    }
-    /**
-     * Get tool schema for MCP registration
-     */
-    static getToolSchema() {
-        return {
-            name: 'git-remote',
-            description: 'Git remote management tool for managing remote repositories. Supports add, remove, rename, show, set-url, and prune operations.',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    action: {
-                        type: 'string',
-                        enum: ['add', 'remove', 'rename', 'show', 'set-url', 'prune', 'list'],
-                        description: 'The remote operation to perform'
-                    },
-                    projectPath: {
-                        type: 'string',
-                        description: 'Absolute path to the project directory'
-                    },
-                    name: {
-                        type: 'string',
-                        description: 'Remote name (required for most operations)'
-                    },
-                    url: {
-                        type: 'string',
-                        description: 'Remote URL (required for add and set-url operations)'
-                    },
-                    newName: {
-                        type: 'string',
-                        description: 'New remote name (required for rename operation)'
-                    },
-                    fetch: {
-                        type: 'boolean',
-                        description: 'Fetch after adding remote (for add action)'
-                    },
-                    push: {
-                        type: 'boolean',
-                        description: 'Set push URL instead of fetch URL (for set-url action)'
-                    },
-                    all: {
-                        type: 'boolean',
-                        description: 'Show all remotes (for show action)'
-                    },
-                    verbose: {
-                        type: 'boolean',
-                        description: 'Show verbose output with URLs (for show action)'
-                    },
-                    dryRun: {
-                        type: 'boolean',
-                        description: 'Show what would be pruned without actually pruning (for prune action)'
-                    }
-                },
-                required: ['action', 'projectPath']
-            }
-        };
-    }
-}
-exports.GitRemoteTool = GitRemoteTool;
-//# sourceMappingURL=git-remote.js.map