@andrebuzeli/git-mcp 5.4.4 → 5.4.5

package/dist/tools/git-workflow.js

@@ -2,23 +2,18 @@
 /**
  * Git Workflow Tool
  *
- * Core Git workflow tool providing comprehensive Git operations.
- * Supports both local Git operations and remote provider operations.
- *
- * Local operations: init, status, commit, sync, backup
- * Remote operations: create, list, get, update, delete, fork, search
+ * Core Git workflow tool for local and remote Git operations.
+ * Supports init, status, commit, sync, backup, create, list, get, update, delete, fork, and search operations.
+ * Provides comprehensive Git repository management with both local and remote provider support (GitHub/Gitea).
+ * In universal mode (GIT_MCP_MODE=universal), automatically executes on both GitHub and Gitea providers.
  */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GitWorkflowTool = 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");
 const config_js_1 = require("../config.js");
-const path_1 = __importDefault(require("path"));
+const git_command_executor_js_1 = require("../utils/git-command-executor.js");
 class GitWorkflowTool {
     gitExecutor;
     providerHandler;
@@ -59,32 +54,18 @@ class GitWorkflowTool {
         }
     }
     /**
-     * Execute local Git operations
+     * Check if operation is remote
      */
-    async executeLocalOperation(params, startTime) {
-        switch (params.action) {
-            case 'init':
-                return await this.handleInit(params, startTime);
-            case 'status':
-                return await this.handleStatus(params, startTime);
-            case 'commit':
-                return await this.handleCommit(params, startTime);
-            case 'sync':
-                return await this.handleSync(params, startTime);
-            case 'backup':
-                return await this.handleBackup(params, startTime);
-            case 'push':
-                return await this.handlePush(params, startTime);
-            case 'pull':
-                return await this.handlePull(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: init, status, commit, sync, backup, push, pull']);
-        }
+    isRemoteOperation(action) {
+        // Remote operations require provider
+        const remoteOperations = ['create', 'list', 'get', 'update', 'delete', 'fork', 'search'];
+        return remoteOperations.includes(action);
     }
     /**
-     * Execute remote provider operations
+     * Execute remote repository operations
      */
     async executeRemoteOperation(params, startTime) {
+        // Check provider configuration
         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']);
         }
@@ -97,10 +78,45 @@ class GitWorkflowTool {
                 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']);
             }
         }
+        return await this.executeRepositoryOperation(params, startTime);
+    }
+    /**
+     * Execute local Git operations
+     */
+    async executeLocalOperation(params, startTime) {
+        try {
+            switch (params.action) {
+                case 'init':
+                    return await this.executeInit(params, startTime);
+                case 'status':
+                    return await this.executeStatus(params, startTime);
+                case 'commit':
+                    return await this.executeCommit(params, startTime);
+                case 'sync':
+                    return await this.executeSync(params, startTime);
+                case 'backup':
+                    return await this.executeBackup(params, startTime);
+                case 'push':
+                    return await this.executePush(params, startTime);
+                case 'pull':
+                    return await this.executePull(params, startTime);
+                default:
+                    return operation_error_handler_js_1.OperationErrorHandler.createToolError('UNSUPPORTED_OPERATION', `Local operation '${params.action}' is not supported`, params.action, {}, ['Use supported local operations: init, status, commit, sync, backup, push, pull']);
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return operation_error_handler_js_1.OperationErrorHandler.createToolError('LOCAL_OPERATION_ERROR', `Local operation failed: ${errorMessage}`, params.action, { error: errorMessage }, ['Check Git installation and repository state']);
+        }
+    }
+    /**
+     * Execute repository operation through provider
+     */
+    async executeRepositoryOperation(params, startTime) {
         const operation = {
             provider: params.provider,
             operation: this.mapActionToProviderOperation(params.action),
-            parameters: this.extractRemoteParameters(params),
+            parameters: this.extractRepositoryParameters(params),
             requiresAuth: true,
             isRemoteOperation: true
         };
@@ -110,10 +126,10 @@ class GitWorkflowTool {
                 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',
+                    code: result.errors[0]?.error?.code || 'REPO_OPERATION_ERROR',
+                    message: result.errors[0]?.error?.message || 'Repository operation failed',
                     details: result.errors,
-                    suggestions: ['Check provider configuration and credentials']
+                    suggestions: this.getOperationSuggestions(params.action)
                 },
                 metadata: {
                     provider: params.provider,
@@ -125,43 +141,19 @@ class GitWorkflowTool {
         }
         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']);
+            return operation_error_handler_js_1.OperationErrorHandler.createToolError('REPO_OPERATION_ERROR', `Repository operation failed: ${errorMessage}`, params.action, { error: errorMessage }, ['Check provider configuration and network connectivity']);
         }
     }
     /**
-     * Handle git init operation
+     * Execute Git init
      */
-    async handleInit(params, startTime) {
-        try {
-            // Check if already a git repository
-            const isRepo = await this.gitExecutor.isGitRepository(params.projectPath);
-            if (isRepo) {
-                return {
-                    success: true,
-                    data: {
-                        message: 'Repository already initialized',
-                        path: params.projectPath,
-                        alreadyExists: true
-                    },
-                    metadata: {
-                        operation: 'init',
-                        timestamp: new Date().toISOString(),
-                        executionTime: Date.now() - startTime
-                    }
-                };
-            }
-            const result = await this.gitExecutor.initRepository(params.projectPath, params.bare || false);
-            if (!result.success) {
-                return operation_error_handler_js_1.OperationErrorHandler.handleGitError(result.stderr, 'init', params.projectPath);
-            }
+    async executeInit(params, startTime) {
+        const initCommand = params.bare ? ['init', '--bare'] : ['init'];
+        const result = await this.gitExecutor.executeGitCommand('init', initCommand, params.projectPath);
+        if (result.success) {
             return {
                 success: true,
-                data: {
-                    message: 'Git repository initialized successfully',
-                    path: params.projectPath,
-                    bare: params.bare || false,
-                    output: result.stdout
-                },
+                data: { message: 'Git repository initialized successfully' },
                 metadata: {
                     operation: 'init',
                     timestamp: new Date().toISOString(),
@@ -169,29 +161,23 @@ class GitWorkflowTool {
                 }
             };
         }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            return operation_error_handler_js_1.OperationErrorHandler.createToolError('INIT_ERROR', `Failed to initialize repository: ${errorMessage}`, 'init', { error: errorMessage, projectPath: params.projectPath });
+        else {
+            return operation_error_handler_js_1.OperationErrorHandler.createToolError('INIT_FAILED', `Git init failed: ${result.stderr}`, 'init', { stderr: result.stderr }, ['Check if directory exists and is writable', 'Verify Git installation']);
         }
     }
     /**
-     * Handle git status operation
+     * Execute Git status
      */
-    async handleStatus(params, startTime) {
-        try {
-            const result = await this.gitExecutor.getStatus(params.projectPath);
-            if (!result.success) {
-                return operation_error_handler_js_1.OperationErrorHandler.handleGitError(result.stderr, 'status', params.projectPath);
-            }
+    async executeStatus(params, startTime) {
+        const result = await this.gitExecutor.executeGitCommand('status', ['--porcelain'], params.projectPath);
+        if (result.success) {
+            const hasChanges = result.stdout.trim().length > 0;
             return {
                 success: true,
                 data: {
-                    status: result.parsedStatus,
-                    raw: result.stdout,
-                    repository: {
-                        path: params.projectPath,
-                        isGitRepository: result.isGitRepository
-                    }
+                    hasChanges,
+                    changes: hasChanges ? result.stdout.trim().split('\n') : [],
+                    message: hasChanges ? 'Working directory has uncommitted changes' : 'Working directory is clean'
                 },
                 metadata: {
                     operation: 'status',
@@ -200,39 +186,37 @@ class GitWorkflowTool {
                 }
             };
         }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            return operation_error_handler_js_1.OperationErrorHandler.createToolError('STATUS_ERROR', `Failed to get repository status: ${errorMessage}`, 'status', { error: errorMessage, projectPath: params.projectPath });
+        else {
+            return operation_error_handler_js_1.OperationErrorHandler.createToolError('STATUS_FAILED', `Git status failed: ${result.stderr}`, 'status', { stderr: result.stderr }, ['Ensure this is a Git repository', 'Check Git installation']);
         }
     }
     /**
-     * Handle git commit operation
+     * Execute Git commit
      */
-    async handleCommit(params, startTime) {
-        try {
-            if (!params.message) {
-                return operation_error_handler_js_1.OperationErrorHandler.createToolError('MISSING_PARAMETER', 'Commit message is required', 'commit', {}, ['Provide a commit message using the message parameter']);
-            }
-            // Add files to staging area
-            const filesToAdd = params.files || ['.'];
-            const addResult = await this.gitExecutor.addFiles(params.projectPath, filesToAdd);
+    async executeCommit(params, startTime) {
+        if (!params.message) {
+            return operation_error_handler_js_1.OperationErrorHandler.createToolError('COMMIT_MESSAGE_REQUIRED', 'Commit message is required', 'commit', {}, ['Provide a commit message with the message parameter']);
+        }
+        const commitArgs = ['-m', params.message];
+        if (params.files && params.files.length > 0) {
+            // Add specific files first
+            const addResult = await this.gitExecutor.executeGitCommand('add', params.files, params.projectPath);
             if (!addResult.success) {
-                return operation_error_handler_js_1.OperationErrorHandler.handleGitError(addResult.stderr, 'commit (add)', params.projectPath);
+                return operation_error_handler_js_1.OperationErrorHandler.createToolError('ADD_FAILED', `Failed to add files: ${addResult.stderr}`, 'commit', { stderr: addResult.stderr }, ['Check if files exist', 'Verify file paths are correct']);
             }
-            // Commit changes
-            const commitResult = await this.gitExecutor.commit(params.projectPath, params.message);
-            if (!commitResult.success) {
-                return operation_error_handler_js_1.OperationErrorHandler.handleGitError(commitResult.stderr, 'commit', params.projectPath);
+        }
+        else {
+            // Add all changes
+            const addResult = await this.gitExecutor.executeGitCommand('add', ['.'], params.projectPath);
+            if (!addResult.success) {
+                return operation_error_handler_js_1.OperationErrorHandler.createToolError('ADD_FAILED', `Failed to add files: ${addResult.stderr}`, 'commit', { stderr: addResult.stderr }, ['Check working directory status']);
             }
+        }
+        const result = await this.gitExecutor.executeGitCommand('commit', commitArgs, params.projectPath);
+        if (result.success) {
             return {
                 success: true,
-                data: {
-                    message: 'Changes committed successfully',
-                    commitMessage: params.message,
-                    files: filesToAdd,
-                    output: commitResult.stdout,
-                    addOutput: addResult.stdout
-                },
+                data: { message: 'Changes committed successfully' },
                 metadata: {
                     operation: 'commit',
                     timestamp: new Date().toISOString(),
@@ -240,51 +224,29 @@ class GitWorkflowTool {
                 }
             };
         }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            return operation_error_handler_js_1.OperationErrorHandler.createToolError('COMMIT_ERROR', `Failed to commit changes: ${errorMessage}`, 'commit', { error: errorMessage, projectPath: params.projectPath });
+        else {
+            return operation_error_handler_js_1.OperationErrorHandler.createToolError('COMMIT_FAILED', `Git commit failed: ${result.stderr}`, 'commit', { stderr: result.stderr }, ['Check if there are changes to commit', 'Ensure commit message is provided']);
         }
     }
     /**
-     * Handle git sync operation (fetch + pull + push)
+     * Execute Git sync (pull + push)
      */
-    async handleSync(params, startTime) {
-        try {
-            const remote = params.remote || 'origin';
-            const results = [];
-            // Fetch from remote
-            const fetchResult = await this.gitExecutor.fetch(params.projectPath, remote, { all: true, prune: true });
-            results.push({ operation: 'fetch', success: fetchResult.success, output: fetchResult.stdout, error: fetchResult.stderr });
-            // Pull changes
-            const pullResult = await this.gitExecutor.pull(params.projectPath, remote, params.branch, { force: params.force });
-            results.push({ operation: 'pull', success: pullResult.success, output: pullResult.stdout, error: pullResult.stderr });
-            // Push changes (only if pull was successful)
-            let pushResult = null;
-            if (pullResult.success) {
-                pushResult = await this.gitExecutor.push(params.projectPath, remote, params.branch, { force: params.force });
-                results.push({ operation: 'push', success: pushResult.success, output: pushResult.stdout, error: pushResult.stderr });
-            }
-            const allSuccessful = results.every(r => r.success);
-            const hasErrors = results.some(r => !r.success);
+    async executeSync(params, startTime) {
+        const remote = params.remote || 'origin';
+        const branch = params.branch || await this.getCurrentBranch(params.projectPath) || 'main';
+        // Pull first
+        const pullResult = await this.gitExecutor.executeGitCommand('pull', [remote, branch], params.projectPath);
+        if (!pullResult.success) {
+            return operation_error_handler_js_1.OperationErrorHandler.createToolError('PULL_FAILED', `Git pull failed: ${pullResult.stderr}`, 'sync', { stderr: pullResult.stderr }, ['Check remote configuration', 'Resolve merge conflicts if any']);
+        }
+        // Push
+        const pushArgs = params.force ? ['--force'] : [];
+        pushArgs.push(remote, branch);
+        const pushResult = await this.gitExecutor.executeGitCommand('push', pushArgs, params.projectPath);
+        if (pushResult.success) {
             return {
-                success: allSuccessful,
-                data: {
-                    message: allSuccessful ? 'Repository synchronized successfully' : 'Synchronization completed with some errors',
-                    remote,
-                    branch: params.branch,
-                    operations: results,
-                    summary: {
-                        fetch: fetchResult.success,
-                        pull: pullResult.success,
-                        push: pushResult?.success || false
-                    }
-                },
-                error: hasErrors ? {
-                    code: 'SYNC_PARTIAL_ERROR',
-                    message: 'Some synchronization operations failed',
-                    details: results.filter(r => !r.success),
-                    suggestions: ['Check the individual operation errors and resolve them']
-                } : undefined,
+                success: true,
+                data: { message: 'Repository synchronized successfully' },
                 metadata: {
                     operation: 'sync',
                     timestamp: new Date().toISOString(),
@@ -292,140 +254,65 @@ class GitWorkflowTool {
                 }
             };
         }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            return operation_error_handler_js_1.OperationErrorHandler.createToolError('SYNC_ERROR', `Failed to synchronize repository: ${errorMessage}`, 'sync', { error: errorMessage, projectPath: params.projectPath });
+        else {
+            return operation_error_handler_js_1.OperationErrorHandler.createToolError('PUSH_FAILED', `Git push failed: ${pushResult.stderr}`, 'sync', { stderr: pushResult.stderr }, ['Check remote configuration', 'Verify you have push permissions']);
         }
     }
     /**
-     * Handle push operation
+     * Execute Git push
      */
-    async handlePush(params, startTime) {
-        try {
-            const remote = params.pushRemote || 'origin';
-            const branch = params.pushBranch || await this.getCurrentBranch(params.projectPath);
-            if (!branch) {
-                return operation_error_handler_js_1.OperationErrorHandler.createToolError('NO_BRANCH', 'No branch found to push', params.action, {}, ['Ensure you are on a valid branch or specify pushBranch parameter']);
-            }
-            const pushArgs = [remote, branch];
-            if (params.force) {
-                pushArgs.push('--force');
-            }
-            const result = await this.gitExecutor.executeGitCommand('push', pushArgs, params.projectPath);
-            if (!result.success) {
-                // Check for common push errors
-                if (result.stderr.includes('Push cannot contain secrets')) {
-                    return operation_error_handler_js_1.OperationErrorHandler.createToolError('SECURITY_VIOLATION', 'Push blocked due to detected secrets in commit history', params.action, {
-                        gitError: result.stderr,
-                        suggestion: 'Remove sensitive data from commit history using git reset or git filter-branch'
-                    }, [
-                        'Use git reset to remove commits with secrets',
-                        'Use git filter-branch to clean history',
-                        'Never commit tokens, passwords, or API keys'
-                    ]);
-                }
-                if (result.stderr.includes('rejected')) {
-                    return operation_error_handler_js_1.OperationErrorHandler.createToolError('PUSH_REJECTED', `Push rejected: ${result.stderr}`, params.action, { gitError: result.stderr }, [
-                        'Pull latest changes first with git pull',
-                        'Resolve any conflicts before pushing',
-                        'Check if you have push permissions'
-                    ]);
-                }
-                return operation_error_handler_js_1.OperationErrorHandler.handleGitError(result.stderr, 'push', params.projectPath);
-            }
+    async executePush(params, startTime) {
+        const remote = params.pushRemote || 'origin';
+        const branch = params.pushBranch || await this.getCurrentBranch(params.projectPath) || 'main';
+        const pushArgs = [remote, branch];
+        const result = await this.gitExecutor.executeGitCommand('push', pushArgs, params.projectPath);
+        if (result.success) {
             return {
                 success: true,
-                data: {
-                    message: `Successfully pushed to ${remote}/${branch}`,
-                    remote,
-                    branch,
-                    output: result.stdout
-                },
+                data: { message: 'Changes pushed successfully' },
                 metadata: {
                     operation: 'push',
-                    executionTime: Date.now() - startTime,
-                    timestamp: new Date().toISOString()
+                    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('PUSH_ERROR', `Push operation failed: ${errorMessage}`, params.action, { error: errorMessage }, ['Check network connectivity and repository permissions']);
+        else {
+            return operation_error_handler_js_1.OperationErrorHandler.createToolError('PUSH_FAILED', `Git push failed: ${result.stderr}`, 'push', { stderr: result.stderr }, ['Check remote configuration', 'Verify you have push permissions']);
         }
     }
     /**
-     * Handle pull operation
+     * Execute Git pull
      */
-    async handlePull(params, startTime) {
-        try {
-            const remote = params.pullRemote || 'origin';
-            const branch = params.pullBranch || await this.getCurrentBranch(params.projectPath);
-            if (!branch) {
-                return operation_error_handler_js_1.OperationErrorHandler.createToolError('NO_BRANCH', 'No branch found to pull from', params.action, {}, ['Ensure you are on a valid branch or specify pullBranch parameter']);
-            }
-            const pullArgs = [remote, branch];
-            if (params.strategy && params.strategy !== 'merge') {
-                pullArgs.push(`--${params.strategy}`);
-            }
-            const result = await this.gitExecutor.executeGitCommand('pull', pullArgs, params.projectPath);
-            if (!result.success) {
-                if (result.stderr.includes('merge conflict')) {
-                    return operation_error_handler_js_1.OperationErrorHandler.createToolError('MERGE_CONFLICT', 'Pull failed due to merge conflicts', params.action, {
-                        gitError: result.stderr,
-                        conflicts: this.extractConflictFiles(result.stderr)
-                    }, [
-                        'Resolve conflicts in the listed files',
-                        'Use git add to stage resolved files',
-                        'Complete merge with git commit'
-                    ]);
-                }
-                return operation_error_handler_js_1.OperationErrorHandler.handleGitError(result.stderr, 'pull', params.projectPath);
-            }
+    async executePull(params, startTime) {
+        const remote = params.pullRemote || 'origin';
+        const branch = params.pullBranch || await this.getCurrentBranch(params.projectPath) || 'main';
+        const result = await this.gitExecutor.executeGitCommand('pull', [remote, branch], params.projectPath);
+        if (result.success) {
             return {
                 success: true,
-                data: {
-                    message: `Successfully pulled from ${remote}/${branch}`,
-                    remote,
-                    branch,
-                    strategy: params.strategy || 'merge',
-                    output: result.stdout
-                },
+                data: { message: 'Changes pulled successfully' },
                 metadata: {
                     operation: 'pull',
-                    executionTime: Date.now() - startTime,
-                    timestamp: new Date().toISOString()
+                    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('PULL_ERROR', `Pull operation failed: ${errorMessage}`, params.action, { error: errorMessage }, ['Check network connectivity and repository access']);
+        else {
+            return operation_error_handler_js_1.OperationErrorHandler.createToolError('PULL_FAILED', `Git pull failed: ${result.stderr}`, 'pull', { stderr: result.stderr }, ['Check remote configuration', 'Resolve merge conflicts if any']);
         }
     }
     /**
-     * Handle git backup operation
+     * Execute backup
      */
-    async handleBackup(params, startTime) {
-        try {
-            if (!params.backupPath) {
-                // Generate default backup path
-                const projectName = path_1.default.basename(params.projectPath);
-                const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-                params.backupPath = path_1.default.join(params.projectPath, '..', `${projectName}-backup-${timestamp}`);
-            }
-            const result = await this.gitExecutor.createBackup(params.projectPath, params.backupPath, 'tar');
-            if (!result.success) {
-                return operation_error_handler_js_1.OperationErrorHandler.handleGitError(result.stderr, 'backup', params.projectPath);
-            }
+    async executeBackup(params, startTime) {
+        const backupPath = params.backupPath || `backup-${Date.now()}.tar.gz`;
+        const result = await this.gitExecutor.executeGitCommand('archive', ['--format=tar', '--output', backupPath, 'HEAD'], params.projectPath);
+        if (result.success) {
             return {
                 success: true,
-                data: {
-                    message: 'Repository backup created successfully',
-                    backupPath: `${params.backupPath}.tar.gz`,
-                    originalPath: params.projectPath,
-                    format: 'tar.gz',
-                    output: result.stdout
-                },
+                data: { backupPath, message: 'Repository backed up successfully' },
                 metadata: {
                     operation: 'backup',
                     timestamp: new Date().toISOString(),
@@ -433,66 +320,47 @@ class GitWorkflowTool {
                 }
             };
         }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            return operation_error_handler_js_1.OperationErrorHandler.createToolError('BACKUP_ERROR', `Failed to create repository backup: ${errorMessage}`, 'backup', { error: errorMessage, projectPath: params.projectPath });
+        else {
+            return operation_error_handler_js_1.OperationErrorHandler.createToolError('BACKUP_FAILED', `Backup failed: ${result.stderr}`, 'backup', { stderr: result.stderr }, ['Check write permissions', 'Verify Git repository integrity']);
         }
     }
     /**
-     * Check if operation is a remote operation
-     */
-    isRemoteOperation(action) {
-        const remoteOperations = ['create', 'list', 'get', 'update', 'delete', 'fork', 'search'];
-        return remoteOperations.includes(action);
-    }
-    /**
-     * Extract parameters for remote operations
+     * Extract parameters for repository operations
      */
-    extractRemoteParameters(params) {
-        const remoteParams = {
+    extractRepositoryParameters(params) {
+        const repoParams = {
             projectPath: params.projectPath
         };
-        // Common parameters
-        if (params.owner)
-            remoteParams.owner = params.owner;
+        // Auto-detect repo if not provided
         if (params.repo)
-            remoteParams.repo = params.repo;
+            repoParams.repo = params.repo;
         // Operation-specific parameters
         switch (params.action) {
             case 'create':
                 if (params.name)
-                    remoteParams.name = params.name;
+                    repoParams.name = params.name;
                 if (params.description)
-                    remoteParams.description = params.description;
+                    repoParams.description = params.description;
                 if (params.private !== undefined)
-                    remoteParams.private = params.private;
+                    repoParams.private = params.private;
                 break;
             case 'list':
-                // List operations may have type, sort, order parameters
+                // No additional parameters needed
                 break;
             case 'get':
-                // Get operations need owner and repo (already handled above)
-                break;
             case 'update':
-                if (params.name)
-                    remoteParams.name = params.name;
-                if (params.description)
-                    remoteParams.description = params.description;
-                if (params.private !== undefined)
-                    remoteParams.private = params.private;
-                break;
             case 'delete':
-                // Delete operations need owner and repo (already handled above)
-                break;
             case 'fork':
-                // Fork operations may have organization parameter
+                // repo parameter already handled above
+                if (params.description)
+                    repoParams.description = params.description;
                 break;
             case 'search':
                 if (params.query)
-                    remoteParams.query = params.query;
+                    repoParams.query = params.query;
                 break;
         }
-        return remoteParams;
+        return repoParams;
     }
     /**
      * Map git-workflow actions to provider operations
@@ -509,6 +377,63 @@ class GitWorkflowTool {
         };
         return actionMap[action] || action;
     }
+    /**
+     * Get current branch name
+     */
+    async getCurrentBranch(projectPath) {
+        try {
+            const result = await this.gitExecutor.executeGitCommand('branch', ['--show-current'], projectPath);
+            if (result.success && result.stdout.trim()) {
+                return result.stdout.trim();
+            }
+            return null;
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    /**
+     * Get operation-specific suggestions
+     */
+    getOperationSuggestions(action) {
+        const suggestions = {
+            'create': [
+                'Provide a unique repository name',
+                'Check provider permissions for repository creation',
+                'Verify repository name format'
+            ],
+            'list': [
+                'Check provider access permissions',
+                'Verify provider configuration'
+            ],
+            'get': [
+                'Verify repository exists',
+                'Check repository access permissions',
+                'Ensure correct repository name'
+            ],
+            'update': [
+                'Verify repository exists and you have admin access',
+                'Check what fields you can update',
+                'Ensure repository name uniqueness if changing name'
+            ],
+            'delete': [
+                'Verify repository exists and you have delete permissions',
+                'Ensure you really want to delete the repository',
+                'Consider creating a backup first'
+            ],
+            'fork': [
+                'Verify source repository exists and is accessible',
+                'Check fork permissions on the source repository',
+                'Ensure you don\'t already have a fork'
+            ],
+            'search': [
+                'Provide a search query',
+                'Check search syntax for the provider',
+                'Try different search terms'
+            ]
+        };
+        return suggestions[action] || ['Check provider configuration and try again'];
+    }
     /**
      * Get tool schema for MCP registration
      */
@@ -521,7 +446,7 @@ class GitWorkflowTool {
                 properties: {
                     action: {
                         type: 'string',
-                        enum: ['init', 'status', 'commit', 'sync', 'backup', 'create', 'list', 'get', 'update', 'delete', 'fork', 'search'],
+                        enum: ['init', 'status', 'commit', 'sync', 'backup', 'push', 'pull', 'create', 'list', 'get', 'update', 'delete', 'fork', 'search'],
                         description: 'The Git operation to perform. Local operations: init, status, commit, sync, backup. Remote operations: create, list, get, update, delete, fork, search (require provider parameter).'
                     },
                     projectPath: {
@@ -566,10 +491,6 @@ class GitWorkflowTool {
                         type: 'string',
                         description: 'Search query (for search action)'
                     },
-                    owner: {
-                        type: 'string',
-                        description: 'Repository owner (for get/update/delete/fork actions)'
-                    },
                     repo: {
                         type: 'string',
                         description: 'Repository name (for get/update/delete/fork actions)'
@@ -585,74 +506,27 @@ class GitWorkflowTool {
                     force: {
                         type: 'boolean',
                         description: 'Force operation (for sync action)'
+                    },
+                    pushRemote: {
+                        type: 'string',
+                        description: 'Remote name for push (default: origin)'
+                    },
+                    pushBranch: {
+                        type: 'string',
+                        description: 'Branch name for push (default: current branch)'
+                    },
+                    pullRemote: {
+                        type: 'string',
+                        description: 'Remote name for pull (default: origin)'
+                    },
+                    pullBranch: {
+                        type: 'string',
+                        description: 'Branch name for pull (default: current branch)'
                     }
                 },
-                required: ['action', 'projectPath'],
-                additionalProperties: false
-            },
-            errorCodes: {
-                'VALIDATION_ERROR': 'Parameter validation failed - check required parameters and format',
-                'NOT_A_GIT_REPOSITORY': 'Directory is not a Git repository - use init action first',
-                'NOTHING_TO_COMMIT': 'No changes to commit - make changes first',
-                'MERGE_CONFLICT': 'Merge conflicts detected - resolve conflicts before proceeding',
-                'PERMISSION_DENIED': 'Permission denied - check credentials and access rights',
-                'PROVIDER_NOT_CONFIGURED': 'Provider not configured - set up GitHub or Gitea credentials',
-                'NETWORK_ERROR': 'Network connectivity issue - check internet connection',
-                'BACKUP_ERROR': 'Backup creation failed - check disk space and permissions'
-            },
-            examples: [
-                {
-                    description: 'Initialize a new Git repository',
-                    input: {
-                        action: 'init',
-                        projectPath: '/path/to/project'
-                    }
-                },
-                {
-                    description: 'Commit all changes with message',
-                    input: {
-                        action: 'commit',
-                        projectPath: '/path/to/project',
-                        message: 'Add new feature implementation'
-                    }
-                },
-                {
-                    description: 'Create repository on GitHub',
-                    input: {
-                        action: 'create',
-                        projectPath: '/path/to/project',
-                        provider: 'github',
-                        name: 'my-new-repo',
-                        description: 'My new repository',
-                        private: true
-                    }
-                }
-            ]
-        };
-    }
-    /**
-     * Extract conflict files from git error output
-     */
-    extractConflictFiles(stderr) {
-        const conflictMatches = stderr.match(/both modified:\s+(.+)/g);
-        if (!conflictMatches)
-            return [];
-        return conflictMatches.map(match => match.replace('both modified:', '').trim());
-    }
-    /**
-     * Get current branch name
-     */
-    async getCurrentBranch(projectPath) {
-        try {
-            const result = await this.gitExecutor.executeGitCommand('branch', ['--show-current'], projectPath);
-            if (result.success && result.stdout.trim()) {
-                return result.stdout.trim();
+                required: ['action', 'projectPath']
             }
-            return null;
-        }
-        catch (error) {
-            return null;
-        }
+        };
     }
 }
 exports.GitWorkflowTool = GitWorkflowTool;