@andrebuzeli/git-mcp 5.0.4 → 5.0.6

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

@@ -1,19 +1,145 @@
-import { UniversalResponse } from '../utils/auto-detection.js';
-export declare const gitBranchesTool: {
-    name: string;
-    description: string;
-    inputSchema: {
-        type: string;
-        properties: {
-            action: {
-                type: string;
-            };
-            projectPath: {
-                type: string;
+/**
+ * Git Branches Tool
+ *
+ * Branch management tool providing comprehensive Git branch operations.
+ * Supports both local Git operations and remote provider operations.
+ *
+ * Operations: create, list, get, delete, merge, compare
+ */
+import { ToolParams } from '../utils/parameter-validator.js';
+import { ToolResult } from '../utils/operation-error-handler.js';
+import { ProviderConfig } from '../providers/types.js';
+export interface GitBranchesParams extends ToolParams {
+    action: 'create' | 'list' | 'get' | 'delete' | 'merge' | 'compare';
+    branchName?: string;
+    sourceBranch?: string;
+    targetBranch?: string;
+    baseBranch?: string;
+    compareBranch?: string;
+    force?: boolean;
+    remote?: string;
+    checkout?: boolean;
+    owner?: string;
+    repo?: string;
+}
+export declare class GitBranchesTool {
+    private gitExecutor;
+    private providerHandler?;
+    constructor(providerConfig?: ProviderConfig);
+    /**
+     * Execute git-branches operation
+     */
+    execute(params: GitBranchesParams): Promise<ToolResult>;
+    /**
+     * Execute local Git branch operations
+     */
+    private executeLocalOperation;
+    /**
+     * Execute remote provider operations
+     */
+    private executeRemoteOperation;
+    /**
+     * Handle create branch operation
+     */
+    private handleCreateBranch;
+    /**
+     * Handle list branches operation
+     */
+    private handleListBranches;
+    /**
+     * Handle get branch operation
+     */
+    private handleGetBranch;
+    /**
+     * Handle delete branch operation
+     */
+    private handleDeleteBranch;
+    /**
+     * Handle merge branch operation
+     */
+    private handleMergeBranch;
+    /**
+     * Handle compare branches operation
+     */
+    private handleCompareBranches;
+    /**
+     * Check if operation is a remote operation
+     */
+    private isRemoteOperation;
+    /**
+     * Extract parameters for remote operations
+     */
+    private extractRemoteParameters;
+    /**
+     * Map git-branches actions to provider operations
+     */
+    private mapActionToProviderOperation;
+    /**
+     * 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;
+                };
+                provider: {
+                    type: string;
+                    enum: string[];
+                    description: string;
+                };
+                branchName: {
+                    type: string;
+                    description: string;
+                };
+                sourceBranch: {
+                    type: string;
+                    description: string;
+                };
+                targetBranch: {
+                    type: string;
+                    description: string;
+                };
+                baseBranch: {
+                    type: string;
+                    description: string;
+                };
+                compareBranch: {
+                    type: string;
+                    description: string;
+                };
+                force: {
+                    type: string;
+                    description: string;
+                };
+                remote: {
+                    type: string;
+                    description: string;
+                };
+                checkout: {
+                    type: string;
+                    description: string;
+                };
+                owner: {
+                    type: string;
+                    description: string;
+                };
+                repo: {
+                    type: string;
+                    description: string;
+                };
             };
+            required: string[];
         };
-        required: string[];
     };
-    handler(input: any): Promise<UniversalResponse>;
-};
+}
 //# sourceMappingURL=git-branches.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"git-branches.d.ts","sourceRoot":"","sources":["../../src/tools/git-branches.ts"],"names":[],"mappings":"AAAA,OAAO,EAA2B,iBAAiB,EAAc,MAAM,4BAA4B,CAAC;AAEpG,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;mBAIL,GAAG,GAAG,OAAO,CAAC,iBAAiB,CAAC;CAItD,CAAC"}
+{"version":3,"file":"git-branches.d.ts","sourceRoot":"","sources":["../../src/tools/git-branches.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EAAsB,UAAU,EAAE,MAAM,iCAAiC,CAAC;AACjF,OAAO,EAAyB,UAAU,EAAE,MAAM,qCAAqC,CAAC;AAExF,OAAO,EAAE,cAAc,EAAqB,MAAM,uBAAuB,CAAC;AAE1E,MAAM,WAAW,iBAAkB,SAAQ,UAAU;IACnD,MAAM,EAAE,QAAQ,GAAG,MAAM,GAAG,KAAK,GAAG,QAAQ,GAAG,OAAO,GAAG,SAAS,CAAC;IAGnE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,aAAa,CAAC,EAAE,MAAM,CAAC;IAGvB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,OAAO,CAAC;IAGnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,qBAAa,eAAe;IAC1B,OAAO,CAAC,WAAW,CAAqB;IACxC,OAAO,CAAC,eAAe,CAAC,CAA2B;gBAEvC,cAAc,CAAC,EAAE,cAAc;IAO3C;;OAEG;IACG,OAAO,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,UAAU,CAAC;IAiD7D;;OAEG;YACW,qBAAqB;IAyBnC;;OAEG;YACW,sBAAsB;IA4DpC;;OAEG;YACW,kBAAkB;IAuEhC;;OAEG;YACW,kBAAkB;IAyChC;;OAEG;YACW,eAAe;IAmD7B;;OAEG;YACW,kBAAkB;IA2DhC;;OAEG;YACW,iBAAiB;IAsE/B;;OAEG;YACW,qBAAqB;IAuDnC;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAMzB;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAY/B;;OAEG;IACH,OAAO,CAAC,4BAA4B;IAWpC;;OAEG;IACH,MAAM,CAAC,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkErB"}

package/dist/tools/git-branches.js

@@ -1,14 +1,469 @@
 "use strict";
+/**
+ * Git Branches Tool
+ *
+ * Branch management tool providing comprehensive Git branch operations.
+ * Supports both local Git operations and remote provider operations.
+ *
+ * Operations: create, list, get, delete, merge, compare
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.gitBranchesTool = void 0;
-const auto_detection_js_1 = require("../utils/auto-detection.js");
-exports.gitBranchesTool = {
-    name: 'git-branches',
-    description: '🌿 BRANCHES - Gerenciamento de branches',
-    inputSchema: { type: 'object', properties: { action: { type: 'string' }, projectPath: { type: 'string' } }, required: ['action', 'projectPath'] },
-    async handler(input) {
-        const detection = (0, auto_detection_js_1.autoDetect)(input.projectPath);
-        return (0, auto_detection_js_1.createUniversalResponse)(true, input.action, 'Operação de branch executada', detection, 'git-branches', { branches: ['main', 'develop'] });
-    }
-};
+exports.GitBranchesTool = 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 provider_operation_handler_js_1 = require("../providers/provider-operation-handler.js");
+class GitBranchesTool {
+    gitExecutor;
+    providerHandler;
+    constructor(providerConfig) {
+        this.gitExecutor = new git_command_executor_js_1.GitCommandExecutor();
+        if (providerConfig) {
+            this.providerHandler = new provider_operation_handler_js_1.ProviderOperationHandler(providerConfig);
+        }
+    }
+    /**
+     * Execute git-branches operation
+     */
+    async execute(params) {
+        const startTime = Date.now();
+        try {
+            // Validate basic parameters
+            const validation = parameter_validator_js_1.ParameterValidator.validateToolParams('git-branches', 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-branches', 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
+            const isRemoteOperation = this.isRemoteOperation(params.action);
+            if (isRemoteOperation) {
+                return await this.executeRemoteOperation(params, startTime);
+            }
+            else {
+                return await this.executeLocalOperation(params, startTime);
+            }
+        }
+        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']);
+        }
+    }
+    /**
+     * Execute local Git branch operations
+     */
+    async executeLocalOperation(params, startTime) {
+        switch (params.action) {
+            case 'create':
+                return await this.handleCreateBranch(params, startTime);
+            case 'list':
+                return await this.handleListBranches(params, startTime);
+            case 'get':
+                return await this.handleGetBranch(params, startTime);
+            case 'delete':
+                return await this.handleDeleteBranch(params, startTime);
+            case 'merge':
+                return await this.handleMergeBranch(params, startTime);
+            case 'compare':
+                return await this.handleCompareBranches(params, startTime);
+            default:
+                return operation_error_handler_js_1.OperationErrorHandler.createToolError('UNSUPPORTED_OPERATION', `Local operation '${params.action}' is not supported`, params.action, {}, ['Use one of: create, list, get, delete, merge, compare']);
+        }
+    }
+    /**
+     * Execute remote provider operations
+     */
+    async executeRemoteOperation(params, startTime) {
+        if (!this.providerHandler) {
+            return operation_error_handler_js_1.OperationErrorHandler.createToolError('PROVIDER_NOT_CONFIGURED', 'Provider handler is not configured for remote operations', params.action, {}, ['Configure GitHub or Gitea provider to use remote operations']);
+        }
+        if (!params.provider) {
+            return operation_error_handler_js_1.OperationErrorHandler.createToolError('PROVIDER_REQUIRED', 'Provider parameter is required for remote operations', params.action, {}, ['Specify provider as: github, gitea, or both']);
+        }
+        const operation = {
+            provider: params.provider,
+            operation: this.mapActionToProviderOperation(params.action),
+            parameters: this.extractRemoteParameters(params),
+            requiresAuth: true,
+            isRemoteOperation: true
+        };
+        try {
+            const result = await this.providerHandler.executeOperation(operation);
+            return {
+                success: result.success,
+                data: result.partialFailure ? result : result.results[0]?.data,
+                error: result.success ? undefined : {
+                    code: result.errors[0]?.error?.code || 'REMOTE_OPERATION_ERROR',
+                    message: result.errors[0]?.error?.message || 'Remote operation failed',
+                    details: result.errors,
+                    suggestions: ['Check provider configuration and credentials']
+                },
+                metadata: {
+                    provider: params.provider,
+                    operation: params.action,
+                    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_OPERATION_ERROR', `Remote operation failed: ${errorMessage}`, params.action, { error: errorMessage }, ['Check provider configuration and network connectivity']);
+        }
+    }
+    /**
+     * Handle create branch operation
+     */
+    async handleCreateBranch(params, startTime) {
+        try {
+            if (!params.branchName) {
+                return operation_error_handler_js_1.OperationErrorHandler.createToolError('MISSING_PARAMETER', 'branchName is required for branch creation', 'create', {}, ['Provide a name for the new branch']);
+            }
+            // Check if branch already exists
+            const existingBranches = await this.gitExecutor.listBranches(params.projectPath, { all: false });
+            if (existingBranches.success && existingBranches.branches?.includes(params.branchName)) {
+                return operation_error_handler_js_1.OperationErrorHandler.createToolError('BRANCH_EXISTS', `Branch '${params.branchName}' already exists`, 'create', { branchName: params.branchName }, ['Use a different branch name or delete the existing branch first']);
+            }
+            // Create branch
+            const result = await this.gitExecutor.createBranch(params.projectPath, params.branchName, params.sourceBranch);
+            if (!result.success) {
+                return operation_error_handler_js_1.OperationErrorHandler.handleGitError(result.stderr, 'create branch', params.projectPath);
+            }
+            // Checkout branch if requested
+            let checkoutResult = null;
+            if (params.checkout) {
+                checkoutResult = await this.gitExecutor.checkoutBranch(params.projectPath, params.branchName);
+                if (!checkoutResult.success) {
+                    return operation_error_handler_js_1.OperationErrorHandler.handleGitError(checkoutResult.stderr, 'checkout branch', params.projectPath);
+                }
+            }
+            return {
+                success: true,
+                data: {
+                    message: `Branch '${params.branchName}' created successfully`,
+                    branchName: params.branchName,
+                    sourceBranch: params.sourceBranch || 'current branch',
+                    checkedOut: params.checkout || false,
+                    output: result.stdout,
+                    checkoutOutput: checkoutResult?.stdout
+                },
+                metadata: {
+                    operation: 'create',
+                    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('CREATE_BRANCH_ERROR', `Failed to create branch: ${errorMessage}`, 'create', { error: errorMessage, projectPath: params.projectPath });
+        }
+    }
+    /**
+     * Handle list branches operation
+     */
+    async handleListBranches(params, startTime) {
+        try {
+            const result = await this.gitExecutor.listBranches(params.projectPath, {
+                all: true,
+                remote: params.remote
+            });
+            if (!result.success) {
+                return operation_error_handler_js_1.OperationErrorHandler.handleGitError(result.stderr, 'list branches', params.projectPath);
+            }
+            // Get current branch
+            const currentBranchResult = await this.gitExecutor.getCurrentBranch(params.projectPath);
+            const currentBranch = currentBranchResult.success ? currentBranchResult.branch : null;
+            return {
+                success: true,
+                data: {
+                    branches: result.branches || [],
+                    remoteBranches: result.remoteBranches || [],
+                    currentBranch,
+                    total: (result.branches?.length || 0) + (result.remoteBranches?.length || 0),
+                    raw: result.stdout
+                },
+                metadata: {
+                    operation: 'list',
+                    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('LIST_BRANCHES_ERROR', `Failed to list branches: ${errorMessage}`, 'list', { error: errorMessage, projectPath: params.projectPath });
+        }
+    }
+    /**
+     * Handle get branch operation
+     */
+    async handleGetBranch(params, startTime) {
+        try {
+            if (!params.branchName) {
+                return operation_error_handler_js_1.OperationErrorHandler.createToolError('MISSING_PARAMETER', 'branchName is required for get branch operation', 'get', {}, ['Provide the name of the branch to get information about']);
+            }
+            // Get branch information
+            const branchInfo = await this.gitExecutor.getBranchInfo(params.projectPath, params.branchName);
+            if (!branchInfo.success) {
+                return operation_error_handler_js_1.OperationErrorHandler.handleGitError(branchInfo.stderr, 'get branch info', params.projectPath);
+            }
+            // Get branch commits
+            const commitsResult = await this.gitExecutor.getBranchCommits(params.projectPath, params.branchName, 10);
+            return {
+                success: true,
+                data: {
+                    branchName: params.branchName,
+                    exists: branchInfo.exists,
+                    isRemote: branchInfo.isRemote,
+                    lastCommit: branchInfo.lastCommit,
+                    commits: commitsResult.success ? commitsResult.commits : [],
+                    upstream: branchInfo.upstream,
+                    ahead: branchInfo.ahead,
+                    behind: branchInfo.behind
+                },
+                metadata: {
+                    operation: 'get',
+                    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('GET_BRANCH_ERROR', `Failed to get branch information: ${errorMessage}`, 'get', { error: errorMessage, projectPath: params.projectPath });
+        }
+    }
+    /**
+     * Handle delete branch operation
+     */
+    async handleDeleteBranch(params, startTime) {
+        try {
+            if (!params.branchName) {
+                return operation_error_handler_js_1.OperationErrorHandler.createToolError('MISSING_PARAMETER', 'branchName is required for branch deletion', 'delete', {}, ['Provide the name of the branch to delete']);
+            }
+            // Check if trying to delete current branch
+            const currentBranchResult = await this.gitExecutor.getCurrentBranch(params.projectPath);
+            if (currentBranchResult.success && currentBranchResult.branch === params.branchName) {
+                return operation_error_handler_js_1.OperationErrorHandler.createToolError('CANNOT_DELETE_CURRENT_BRANCH', `Cannot delete current branch '${params.branchName}'`, 'delete', { branchName: params.branchName }, ['Switch to a different branch before deleting this one']);
+            }
+            const result = await this.gitExecutor.deleteBranch(params.projectPath, params.branchName, params.force || false);
+            if (!result.success) {
+                return operation_error_handler_js_1.OperationErrorHandler.handleGitError(result.stderr, 'delete branch', params.projectPath);
+            }
+            return {
+                success: true,
+                data: {
+                    message: `Branch '${params.branchName}' deleted successfully`,
+                    branchName: params.branchName,
+                    forced: params.force || false,
+                    output: result.stdout
+                },
+                metadata: {
+                    operation: 'delete',
+                    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('DELETE_BRANCH_ERROR', `Failed to delete branch: ${errorMessage}`, 'delete', { error: errorMessage, projectPath: params.projectPath });
+        }
+    }
+    /**
+     * Handle merge branch operation
+     */
+    async handleMergeBranch(params, startTime) {
+        try {
+            if (!params.branchName) {
+                return operation_error_handler_js_1.OperationErrorHandler.createToolError('MISSING_PARAMETER', 'branchName is required for branch merge', 'merge', {}, ['Provide the name of the branch to merge']);
+            }
+            // Get current branch (target branch)
+            const currentBranchResult = await this.gitExecutor.getCurrentBranch(params.projectPath);
+            if (!currentBranchResult.success) {
+                return operation_error_handler_js_1.OperationErrorHandler.handleGitError(currentBranchResult.stderr, 'get current branch', params.projectPath);
+            }
+            const targetBranch = params.targetBranch || currentBranchResult.branch;
+            // Check for uncommitted changes
+            const statusResult = await this.gitExecutor.getStatus(params.projectPath);
+            if (statusResult.success && statusResult.parsedStatus &&
+                (statusResult.parsedStatus.modified.length > 0 || statusResult.parsedStatus.added.length > 0)) {
+                return operation_error_handler_js_1.OperationErrorHandler.createToolError('UNCOMMITTED_CHANGES', 'Cannot merge with uncommitted changes', 'merge', { uncommittedFiles: [...statusResult.parsedStatus.modified, ...statusResult.parsedStatus.added] }, ['Commit or stash your changes before merging']);
+            }
+            const result = await this.gitExecutor.mergeBranch(params.projectPath, params.branchName, { force: params.force });
+            if (!result.success) {
+                return operation_error_handler_js_1.OperationErrorHandler.handleGitError(result.stderr, 'merge branch', params.projectPath);
+            }
+            return {
+                success: true,
+                data: {
+                    message: `Branch '${params.branchName}' merged into '${targetBranch}' successfully`,
+                    sourceBranch: params.branchName,
+                    targetBranch,
+                    mergeCommit: result.mergeCommit,
+                    conflicts: result.conflicts || [],
+                    output: result.stdout
+                },
+                metadata: {
+                    operation: 'merge',
+                    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('MERGE_BRANCH_ERROR', `Failed to merge branch: ${errorMessage}`, 'merge', { error: errorMessage, projectPath: params.projectPath });
+        }
+    }
+    /**
+     * Handle compare branches operation
+     */
+    async handleCompareBranches(params, startTime) {
+        try {
+            if (!params.baseBranch || !params.compareBranch) {
+                return operation_error_handler_js_1.OperationErrorHandler.createToolError('MISSING_PARAMETER', 'baseBranch and compareBranch are required for comparison', 'compare', {}, ['Provide both branch names to compare']);
+            }
+            const result = await this.gitExecutor.compareBranches(params.projectPath, params.baseBranch, params.compareBranch);
+            if (!result.success) {
+                return operation_error_handler_js_1.OperationErrorHandler.handleGitError(result.stderr, 'compare branches', params.projectPath);
+            }
+            return {
+                success: true,
+                data: {
+                    baseBranch: params.baseBranch,
+                    compareBranch: params.compareBranch,
+                    ahead: result.ahead || 0,
+                    behind: result.behind || 0,
+                    commits: result.commits || [],
+                    files: result.files || [],
+                    summary: {
+                        totalCommits: result.commits?.length || 0,
+                        filesChanged: result.files?.length || 0,
+                        insertions: result.insertions || 0,
+                        deletions: result.deletions || 0
+                    }
+                },
+                metadata: {
+                    operation: 'compare',
+                    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('COMPARE_BRANCHES_ERROR', `Failed to compare branches: ${errorMessage}`, 'compare', { error: errorMessage, projectPath: params.projectPath });
+        }
+    }
+    /**
+     * Check if operation is a remote operation
+     */
+    isRemoteOperation(action) {
+        // For now, all branch operations are local
+        // Remote branch operations would be handled through git-workflow or specific remote tools
+        return false;
+    }
+    /**
+     * Extract parameters for remote operations
+     */
+    extractRemoteParameters(params) {
+        const remoteParams = {
+            projectPath: params.projectPath
+        };
+        if (params.owner)
+            remoteParams.owner = params.owner;
+        if (params.repo)
+            remoteParams.repo = params.repo;
+        if (params.branchName)
+            remoteParams.branchName = params.branchName;
+        return remoteParams;
+    }
+    /**
+     * Map git-branches actions to provider operations
+     */
+    mapActionToProviderOperation(action) {
+        const actionMap = {
+            'list': 'branch-list',
+            'get': 'branch-get',
+            'create': 'branch-create',
+            'delete': 'branch-delete'
+        };
+        return actionMap[action] || action;
+    }
+    /**
+     * Get tool schema for MCP registration
+     */
+    static getToolSchema() {
+        return {
+            name: 'git-branches',
+            description: 'Git branch management tool for branch lifecycle operations. Supports create, list, get, delete, merge, and compare operations.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    action: {
+                        type: 'string',
+                        enum: ['create', 'list', 'get', 'delete', 'merge', 'compare'],
+                        description: 'The branch operation to perform'
+                    },
+                    projectPath: {
+                        type: 'string',
+                        description: 'Absolute path to the project directory'
+                    },
+                    provider: {
+                        type: 'string',
+                        enum: ['github', 'gitea', 'both'],
+                        description: 'Provider for remote operations (if supported)'
+                    },
+                    branchName: {
+                        type: 'string',
+                        description: 'Name of the branch (required for create, get, delete, merge)'
+                    },
+                    sourceBranch: {
+                        type: 'string',
+                        description: 'Source branch to create from (for create action)'
+                    },
+                    targetBranch: {
+                        type: 'string',
+                        description: 'Target branch to merge into (for merge action)'
+                    },
+                    baseBranch: {
+                        type: 'string',
+                        description: 'Base branch for comparison (required for compare action)'
+                    },
+                    compareBranch: {
+                        type: 'string',
+                        description: 'Branch to compare against base (required for compare action)'
+                    },
+                    force: {
+                        type: 'boolean',
+                        description: 'Force operation (for delete, merge actions)'
+                    },
+                    remote: {
+                        type: 'string',
+                        description: 'Remote name (default: origin)'
+                    },
+                    checkout: {
+                        type: 'boolean',
+                        description: 'Checkout branch after creation (for create action)'
+                    },
+                    owner: {
+                        type: 'string',
+                        description: 'Repository owner (for remote operations)'
+                    },
+                    repo: {
+                        type: 'string',
+                        description: 'Repository name (for remote operations)'
+                    }
+                },
+                required: ['action', 'projectPath']
+            }
+        };
+    }
+}
+exports.GitBranchesTool = GitBranchesTool;
 //# sourceMappingURL=git-branches.js.map