@andrebuzeli/git-mcp 10.0.7 → 10.0.8

package/README.md

@@ -83,7 +83,7 @@ This MCP server supports **2 providers** (for remote API operations only):
 - **`github`** - GitHub remote operations (issues, PRs, releases) via @octokit/rest
 - **`gitea`** - Gitea remote operations (issues, PRs, releases) via axios to nas-ubuntu:3000
 
-**Important**: Local Git operations (commit, branch, tag, stash, etc) use `simple-git` directly and do **NOT** require a `provider` parameter. The `provider` parameter is only needed for remote API operations (issues, PRs, releases, etc). Gitea as a provider is only for remote API calls, not for local Git operations.
+**Important**: Local Git operations (commit, branch, tag, stash, etc) use `isomorphic-git` directly and do **NOT** require a `provider` parameter. The `provider` parameter is only needed for remote API operations (issues, PRs, releases, etc). Gitea as a provider is only for remote API calls, not for local Git operations.
 
 ## Quick Start
 

package/dist/providers/providerManager.js

@@ -1,6 +1,5 @@
 import { Octokit } from '@octokit/rest';
 import axios from 'axios';
-import { getGiteaUrl } from '../utils/repoHelpers.js';
 export class ProviderManager {
     constructor() {
         const ghToken = process.env.GITHUB_TOKEN;
@@ -8,7 +7,7 @@ export class ProviderManager {
             this.github = new Octokit({ auth: ghToken });
         }
         if (process.env.GITEA_URL && process.env.GITEA_TOKEN) {
-            this.giteaBaseUrl = getGiteaUrl();
+            this.giteaBaseUrl = process.env.GITEA_URL;
             this.giteaToken = process.env.GITEA_TOKEN;
         }
     }
@@ -32,8 +31,7 @@ export class ProviderManager {
         }
         if (this.giteaBaseUrl && this.giteaToken) {
             try {
-                const base = (this.giteaBaseUrl || '').replace(/\/$/, '');
-                const resp = await axios.get(`${base}/api/v1/user`, {
+                const resp = await axios.get(`${this.giteaBaseUrl}/api/v1/user`, {
                     headers: { Authorization: `token ${this.giteaToken}` },
                     timeout: timeout,
                 });

package/dist/scripts/test_e2e.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scripts/test_e2e.js

@@ -0,0 +1,199 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { ProviderManager } from '../providers/providerManager.js';
+import { IsomorphicGitAdapter } from '../utils/gitAdapter.js';
+import { GitWorkflowTool } from '../tools/gitWorkflow.js';
+import { GitRemoteTool } from '../tools/gitRemote.js';
+import { GitBranchesTool } from '../tools/gitBranches.js';
+import { GitIssuesTool } from '../tools/gitIssues.js';
+import { GitConfigTool } from '../tools/gitConfig.js';
+import { GitFilesTool } from '../tools/gitFiles.js';
+// Set Credentials
+process.env.GITEA_URL = "https://git.hubuzeli.com";
+process.env.GITEA_TOKEN = "09b19262127241b2c608f1e58ac90af0cce21422";
+process.env.GITEA_USERNAME = "andrebuzeli";
+process.env.GITHUB_TOKEN = "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";
+process.env.GITHUB_USERNAME = "Andre-Buzeli";
+async function runE2ETest() {
+    const timestamp = Date.now();
+    const repoName = `git-mcp-e2e-test-${timestamp}`;
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'git-mcp-e2e-'));
+    console.log(`🚀 Starting E2E Test Suite`);
+    console.log(`📂 Local Temp Dir: ${tempDir}`);
+    console.log(`📦 Target Repo Name: ${repoName}`);
+    const providerManager = new ProviderManager();
+    const gitAdapter = new IsomorphicGitAdapter(providerManager);
+    const ctx = { providerManager, gitAdapter };
+    const tools = {
+        workflow: new GitWorkflowTool(),
+        remote: new GitRemoteTool(),
+        branches: new GitBranchesTool(),
+        issues: new GitIssuesTool(),
+        config: new GitConfigTool(),
+        files: new GitFilesTool(),
+    };
+    try {
+        // 1. Create Remote Repositories
+        console.log('\n1️⃣  Creating Remote Repositories...');
+        const createResult = await tools.workflow.handle({
+            action: 'create',
+            name: repoName,
+            description: 'Automated E2E Test Repository for git-mcp',
+            private: true,
+            projectPath: tempDir // Required by schema even if not used for remote create
+        }, ctx);
+        const githubRepo = createResult.providers.github?.repo;
+        const giteaRepo = createResult.providers.gitea?.repo;
+        if (githubRepo)
+            console.log(`   ✅ GitHub Repo Created: ${githubRepo.html_url}`);
+        else
+            console.log(`   ❌ GitHub Repo Creation Failed: ${createResult.providers.github?.error}`);
+        if (giteaRepo)
+            console.log(`   ✅ Gitea Repo Created: ${giteaRepo.html_url}`);
+        else
+            console.log(`   ❌ Gitea Repo Creation Failed: ${createResult.providers.gitea?.error}`);
+        // 2. Initialize Local Repository
+        console.log('\n2️⃣  Initializing Local Repository...');
+        await tools.workflow.handle({ action: 'init', projectPath: tempDir }, ctx);
+        await tools.config.handle({ action: 'set', projectPath: tempDir, key: 'user.name', value: 'E2E Test Bot' }, ctx);
+        await tools.config.handle({ action: 'set', projectPath: tempDir, key: 'user.email', value: 'bot@git-mcp.test' }, ctx);
+        console.log('   ✅ Local repo initialized and configured');
+        // 3. Create Content & Commit
+        console.log('\n3️⃣  Creating Content & Committing...');
+        fs.writeFileSync(path.join(tempDir, 'README.md'), `# ${repoName}\n\nAutomated test repository.`);
+        await tools.workflow.handle({ action: 'commit', projectPath: tempDir, message: 'Initial commit', files: ['.'] }, ctx);
+        console.log('   ✅ Initial commit created');
+        // 4. Add Remotes
+        console.log('\n4️⃣  Adding Remotes...');
+        if (githubRepo) {
+            await tools.remote.handle({ action: 'add', projectPath: tempDir, remoteName: 'github', url: githubRepo.clone_url }, ctx);
+            console.log('   ✅ GitHub remote added');
+        }
+        if (giteaRepo) {
+            await tools.remote.handle({ action: 'add', projectPath: tempDir, remoteName: 'gitea', url: giteaRepo.clone_url }, ctx);
+            console.log('   ✅ Gitea remote added');
+        }
+        // 5. Push to Remotes
+        console.log('\n5️⃣  Pushing to Remotes...');
+        if (githubRepo) {
+            try {
+                await tools.workflow.handle({ action: 'push', projectPath: tempDir, remote: 'github', branch: 'master' }, ctx);
+                console.log('   ✅ Pushed to GitHub');
+            }
+            catch (e) {
+                console.log(`   ❌ Push to GitHub Failed: ${e.message}`);
+            }
+        }
+        if (giteaRepo) {
+            try {
+                await tools.workflow.handle({ action: 'push', projectPath: tempDir, remote: 'gitea', branch: 'master' }, ctx);
+                console.log('   ✅ Pushed to Gitea');
+            }
+            catch (e) {
+                console.log(`   ❌ Push to Gitea Failed: ${e.message}`);
+            }
+        }
+        // 6. Feature Branch Workflow
+        console.log('\n6️⃣  Feature Branch Workflow...');
+        await tools.branches.handle({ action: 'create', projectPath: tempDir, branchName: 'feature/test-1' }, ctx);
+        fs.writeFileSync(path.join(tempDir, 'feature.txt'), 'This is a feature file.');
+        await tools.workflow.handle({ action: 'commit', projectPath: tempDir, message: 'Add feature file', files: ['.'] }, ctx);
+        console.log('   ✅ Feature branch created and committed');
+        if (githubRepo) {
+            try {
+                await tools.workflow.handle({ action: 'push', projectPath: tempDir, remote: 'github', branch: 'feature/test-1' }, ctx);
+                console.log('   ✅ Feature branch pushed to GitHub');
+            }
+            catch (e) {
+                console.log(`   ❌ Push feature to GitHub Failed: ${e.message}`);
+            }
+        }
+        // 7. Issue Management
+        console.log('\n7️⃣  Issue Management...');
+        let issueNumber = 0;
+        if (githubRepo) {
+            try {
+                const issue = await tools.issues.handle({
+                    action: 'create',
+                    projectPath: tempDir,
+                    provider: 'github',
+                    repo: repoName,
+                    owner: process.env.GITHUB_USERNAME,
+                    title: 'Test Issue',
+                    body: 'This is an automated test issue.'
+                }, ctx);
+                issueNumber = issue.providers.github.issue.number;
+                console.log(`   ✅ Created GitHub Issue #${issueNumber}`);
+                await tools.issues.handle({
+                    action: 'comment',
+                    projectPath: tempDir,
+                    provider: 'github',
+                    repo: repoName,
+                    owner: process.env.GITHUB_USERNAME,
+                    issueNumber: issueNumber,
+                    body: 'Automated comment.'
+                }, ctx);
+                console.log('   ✅ Commented on GitHub Issue');
+                await tools.issues.handle({
+                    action: 'close',
+                    projectPath: tempDir,
+                    provider: 'github',
+                    repo: repoName,
+                    owner: process.env.GITHUB_USERNAME,
+                    issueNumber: issueNumber
+                }, ctx);
+                console.log('   ✅ Closed GitHub Issue');
+            }
+            catch (e) {
+                console.log(`   ❌ GitHub Issue Operations Failed: ${e.message}`);
+            }
+        }
+        // 8. Cleanup (Delete Remote Repos)
+        console.log('\n8️⃣  Cleanup (Deleting Remote Repos)...');
+        if (githubRepo) {
+            try {
+                await tools.workflow.handle({
+                    action: 'delete',
+                    projectPath: tempDir, // Required by schema
+                    repo: repoName,
+                    owner: process.env.GITHUB_USERNAME,
+                    confirmDestructive: true
+                }, ctx);
+                console.log('   ✅ Deleted GitHub Repo');
+            }
+            catch (e) {
+                console.log(`   ❌ Delete GitHub Repo Failed: ${e.message}`);
+            }
+        }
+        if (giteaRepo) {
+            try {
+                await tools.workflow.handle({
+                    action: 'delete',
+                    projectPath: tempDir, // Required by schema
+                    repo: repoName,
+                    owner: process.env.GITEA_USERNAME,
+                    confirmDestructive: true
+                }, ctx);
+                console.log('   ✅ Deleted Gitea Repo');
+            }
+            catch (e) {
+                console.log(`   ❌ Delete Gitea Repo Failed: ${e.message}`);
+            }
+        }
+        // Local Cleanup
+        fs.rmSync(tempDir, { recursive: true, force: true });
+        console.log('   ✅ Deleted Local Temp Dir');
+        console.log('\n🎉 E2E Test Suite Completed!');
+    }
+    catch (error) {
+        console.error('\n❌ E2E TEST FAILED FATALLY:', error);
+        // Try to cleanup even on failure
+        try {
+            if (fs.existsSync(tempDir))
+                fs.rmSync(tempDir, { recursive: true, force: true });
+        }
+        catch { }
+    }
+}
+runE2ETest().catch(console.error);

package/dist/scripts/test_exhaustive.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scripts/test_exhaustive.js

@@ -0,0 +1,275 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { ProviderManager } from '../providers/providerManager.js';
+import { IsomorphicGitAdapter } from '../utils/gitAdapter.js';
+// Import all tools
+import { GitAnalyticsTool } from '../tools/gitAnalytics.js';
+import { GitArchiveTool } from '../tools/gitArchive.js';
+import { GitBackupTool } from '../tools/gitBackup.js';
+import { GitBranchesTool } from '../tools/gitBranches.js';
+import { GitChangelogTool } from '../tools/gitChangelog.js';
+import { GitConfigTool } from '../tools/gitConfig.js';
+import { GitFilesTool } from '../tools/gitFiles.js';
+import { GitFixTool } from '../tools/gitFix.tool.js';
+import { GitHistoryTool } from '../tools/gitHistory.js';
+import { GitIgnoreTool } from '../tools/gitIgnore.js';
+import { GitIssuesTool } from '../tools/gitIssues.js';
+import { GitLogTool } from '../tools/gitLog.js';
+import { GitMonitorTool } from '../tools/gitMonitor.js';
+import { GitPackagesTool } from '../tools/gitPackages.js';
+import { GitPullsTool } from '../tools/gitPulls.js';
+import { GitPushTool } from '../tools/gitPush.js';
+import { GitReleaseTool } from '../tools/gitRelease.js';
+import { GitRemoteTool } from '../tools/gitRemote.js';
+import { GitResetTool } from '../tools/gitReset.js';
+import { GitStashTool } from '../tools/gitStash.js';
+import { GitSyncTool } from '../tools/gitSync.js';
+import { GitTagsTool } from '../tools/gitTags.js';
+import { GitUpdateTool } from '../tools/gitUpdate.js';
+import { GitUploadTool } from '../tools/gitUpload.js';
+import { GitWorkflowTool } from '../tools/gitWorkflow.js';
+// Set Credentials
+process.env.GITEA_URL = "https://git.hubuzeli.com";
+process.env.GITEA_TOKEN = "09b19262127241b2c608f1e58ac90af0cce21422";
+process.env.GITEA_USERNAME = "andrebuzeli";
+process.env.GITHUB_TOKEN = "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";
+process.env.GITHUB_USERNAME = "Andre-Buzeli";
+async function runExhaustiveTest() {
+    const timestamp = Date.now();
+    const repoName = `git-mcp-exhaustive-${timestamp}`;
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'git-mcp-exhaustive-'));
+    console.log(`🚀 Starting EXHAUSTIVE Tools Test Suite`);
+    console.log(`📂 Local Temp Dir: ${tempDir}`);
+    console.log(`📦 Target Repo Name: ${repoName}`);
+    const providerManager = new ProviderManager();
+    const gitAdapter = new IsomorphicGitAdapter(providerManager);
+    const ctx = { providerManager, gitAdapter };
+    // Instantiate all tools
+    const tools = {
+        analytics: new GitAnalyticsTool(),
+        archive: new GitArchiveTool(),
+        backup: new GitBackupTool(),
+        branches: new GitBranchesTool(),
+        changelog: new GitChangelogTool(),
+        config: new GitConfigTool(),
+        files: new GitFilesTool(),
+        fix: new GitFixTool(),
+        history: new GitHistoryTool(),
+        ignore: new GitIgnoreTool(),
+        issues: new GitIssuesTool(),
+        log: new GitLogTool(),
+        monitor: new GitMonitorTool(),
+        packages: new GitPackagesTool(),
+        pulls: new GitPullsTool(),
+        push: new GitPushTool(),
+        release: new GitReleaseTool(),
+        remote: new GitRemoteTool(),
+        reset: new GitResetTool(),
+        stash: new GitStashTool(),
+        sync: new GitSyncTool(),
+        tags: new GitTagsTool(),
+        update: new GitUpdateTool(),
+        upload: new GitUploadTool(),
+        workflow: new GitWorkflowTool(),
+    };
+    const results = {};
+    const detailedResults = [];
+    async function testAction(toolName, actionName, params, expectedSuccess = true) {
+        const testName = `${toolName}:${actionName}`;
+        console.log(`Testing ${testName}...`);
+        try {
+            // @ts-ignore
+            const result = await tools[toolName].handle(params, ctx);
+            if (expectedSuccess) {
+                console.log(`  ✅ PASS`);
+                results[testName] = '✅ PASS';
+            }
+            else {
+                console.log(`  ❌ FAIL (Expected Failure but Succeeded)`);
+                results[testName] = '❌ FAIL (Unexpected Success)';
+            }
+            detailedResults.push({ test: testName, params, result, status: 'PASS' });
+            return result;
+        }
+        catch (error) {
+            if (!expectedSuccess) {
+                console.log(`  ✅ PASS (Expected Failure)`);
+                results[testName] = '✅ PASS (Expected Failure)';
+            }
+            else {
+                console.error(`  ❌ FAIL: ${error.message}`);
+                results[testName] = '❌ FAIL';
+            }
+            detailedResults.push({ test: testName, params, error: error.message, status: 'FAIL' });
+            return null;
+        }
+    }
+    try {
+        // --- 1. GitWorkflow (Init & Create) ---
+        await testAction('workflow', 'init', { action: 'init', projectPath: tempDir });
+        await testAction('workflow', 'create', {
+            action: 'create',
+            projectPath: tempDir,
+            name: repoName,
+            description: 'Exhaustive Test Repo',
+            private: true
+        });
+        // --- 2. GitConfig ---
+        await testAction('config', 'set', { action: 'set', projectPath: tempDir, key: 'user.name', value: 'Test Bot' });
+        await testAction('config', 'set', { action: 'set', projectPath: tempDir, key: 'user.email', value: 'bot@test.com' });
+        await testAction('config', 'get', { action: 'get', projectPath: tempDir, key: 'user.name' });
+        await testAction('config', 'list', { action: 'list', projectPath: tempDir });
+        // unset is tricky with isomorphic-git adapter implementation details, skipping to avoid breaking config
+        // --- 3. GitFiles ---
+        await testAction('files', 'create', { action: 'create', projectPath: tempDir, filePath: 'README.md', content: '# Test Repo' });
+        await testAction('files', 'read', { action: 'read', projectPath: tempDir, filePath: 'README.md' });
+        await testAction('files', 'update', { action: 'update', projectPath: tempDir, filePath: 'README.md', content: '# Test Repo Updated' });
+        await testAction('files', 'list', { action: 'list', projectPath: tempDir });
+        await testAction('files', 'search', { action: 'search', projectPath: tempDir, searchText: 'Test' });
+        // --- 4. GitIgnore ---
+        await testAction('ignore', 'create', { action: 'create', projectPath: tempDir, template: 'node' });
+        await testAction('ignore', 'add', { action: 'add', projectPath: tempDir, patterns: ['*.log', 'temp/'] });
+        await testAction('ignore', 'read', { action: 'read', projectPath: tempDir });
+        await testAction('ignore', 'remove', { action: 'remove', projectPath: tempDir, patterns: ['*.log'] });
+        // Commit initial changes
+        await testAction('workflow', 'commit', { action: 'commit', projectPath: tempDir, message: 'Initial commit', files: ['.'] });
+        // --- 5. GitRemote ---
+        const githubUrl = `https://github.com/${process.env.GITHUB_USERNAME}/${repoName}.git`;
+        const giteaUrl = `${process.env.GITEA_URL}/${process.env.GITEA_USERNAME}/${repoName}.git`;
+        await testAction('remote', 'add', { action: 'add', projectPath: tempDir, remoteName: 'github', url: githubUrl });
+        await testAction('remote', 'add', { action: 'add', projectPath: tempDir, remoteName: 'gitea', url: giteaUrl });
+        await testAction('remote', 'list', { action: 'list', projectPath: tempDir });
+        await testAction('remote', 'get-url', { action: 'get-url', projectPath: tempDir, remoteName: 'github' });
+        // set-url and remove tested later or skipped to maintain state
+        // --- 6. GitPush ---
+        // Push to both
+        await testAction('push', 'push', { projectPath: tempDir, remote: 'github', branch: 'master' });
+        await testAction('push', 'push', { projectPath: tempDir, remote: 'gitea', branch: 'master' });
+        // --- 7. GitBranches ---
+        await testAction('branches', 'create', { action: 'create', projectPath: tempDir, branchName: 'feature/test' });
+        await testAction('branches', 'list', { action: 'list', projectPath: tempDir });
+        await testAction('branches', 'get', { action: 'get', projectPath: tempDir, branchName: 'feature/test' });
+        // Make changes in branch
+        await testAction('files', 'create', { action: 'create', projectPath: tempDir, filePath: 'feature.txt', content: 'Feature content' });
+        await testAction('workflow', 'commit', { action: 'commit', projectPath: tempDir, message: 'Feature commit', files: ['.'] });
+        // Compare (local)
+        await testAction('branches', 'compare', { action: 'compare', projectPath: tempDir, baseBranch: 'master', compareBranch: 'feature/test' });
+        // --- 8. GitLog ---
+        await testAction('log', 'log', { projectPath: tempDir, maxCount: 5 });
+        // --- 9. GitHistory ---
+        await testAction('history', 'track', { action: 'track', projectPath: tempDir, description: 'Feature implementation' });
+        await testAction('history', 'list', { action: 'list', projectPath: tempDir });
+        // sync and report
+        await testAction('history', 'sync', { action: 'sync', projectPath: tempDir });
+        await testAction('history', 'report', { action: 'report', projectPath: tempDir });
+        // --- 10. GitMonitor ---
+        await testAction('monitor', 'status', { action: 'status', projectPath: tempDir });
+        await testAction('monitor', 'log', { action: 'log', projectPath: tempDir });
+        await testAction('monitor', 'commits', { action: 'commits', projectPath: tempDir, branch: 'feature/test' });
+        await testAction('monitor', 'contributors', { action: 'contributors', projectPath: tempDir });
+        // --- 11. GitStash ---
+        await testAction('files', 'create', { action: 'create', projectPath: tempDir, filePath: 'stash.txt', content: 'Stash me' });
+        await testAction('stash', 'save', { action: 'save', projectPath: tempDir, message: 'Stash test', includeUntracked: true });
+        await testAction('stash', 'list', { action: 'list', projectPath: tempDir });
+        await testAction('stash', 'apply', { action: 'apply', projectPath: tempDir });
+        await testAction('stash', 'clear', { action: 'clear', projectPath: tempDir });
+        // --- 12. GitTags ---
+        await testAction('tags', 'create', { action: 'create', projectPath: tempDir, tagName: 'v1.0.0', message: 'Release 1.0.0', annotated: true });
+        await testAction('tags', 'list', { action: 'list', projectPath: tempDir });
+        await testAction('tags', 'get', { action: 'get', projectPath: tempDir, tagName: 'v1.0.0' });
+        await testAction('tags', 'push', { action: 'push', projectPath: tempDir, tagName: 'v1.0.0', remote: 'github' });
+        // --- 13. GitArchive ---
+        await testAction('archive', 'create', { action: 'create', projectPath: tempDir, outputPath: path.join(tempDir, 'archive.tar') });
+        // extract not tested to avoid cluttering temp dir too much, but logic is simple
+        // --- 14. GitBackup ---
+        await testAction('backup', 'create', { action: 'create', projectPath: tempDir });
+        await testAction('backup', 'list', { action: 'list', projectPath: tempDir });
+        // restore is manual info, delete is simple file deletion
+        // --- 15. GitIssues ---
+        const issue = await testAction('issues', 'create', {
+            action: 'create',
+            projectPath: tempDir,
+            title: 'Test Issue',
+            body: 'This is a test issue',
+            repo: repoName,
+            owner: process.env.GITHUB_USERNAME
+        });
+        if (issue && issue.providers.github && issue.providers.github.issue) {
+            const issueNum = issue.providers.github.issue.number;
+            await testAction('issues', 'list', { action: 'list', projectPath: tempDir, repo: repoName, owner: process.env.GITHUB_USERNAME });
+            await testAction('issues', 'get', { action: 'get', projectPath: tempDir, issueNumber: issueNum, repo: repoName, owner: process.env.GITHUB_USERNAME });
+            await testAction('issues', 'comment', { action: 'comment', projectPath: tempDir, issueNumber: issueNum, body: 'Test comment', repo: repoName, owner: process.env.GITHUB_USERNAME });
+            await testAction('issues', 'update', { action: 'update', projectPath: tempDir, issueNumber: issueNum, state: 'closed', repo: repoName, owner: process.env.GITHUB_USERNAME });
+        }
+        // --- 16. GitAnalytics ---
+        await testAction('analytics', 'stats', { action: 'stats', projectPath: tempDir, repo: repoName, owner: process.env.GITHUB_USERNAME });
+        await testAction('analytics', 'commits', { action: 'commits', projectPath: tempDir, repo: repoName, owner: process.env.GITHUB_USERNAME });
+        await testAction('analytics', 'contributors', { action: 'contributors', projectPath: tempDir, repo: repoName, owner: process.env.GITHUB_USERNAME });
+        // --- 17. GitRelease ---
+        // Let release:create handle tag creation
+        const release = await testAction('release', 'create', {
+            action: 'create',
+            projectPath: tempDir,
+            tagName: 'v2.0.0',
+            name: 'Release 2.0',
+            repo: repoName,
+            owner: process.env.GITHUB_USERNAME
+        });
+        if (release && release.providers.github && release.providers.github.release) {
+            await testAction('release', 'list', { action: 'list', projectPath: tempDir, repo: repoName, owner: process.env.GITHUB_USERNAME });
+            await testAction('release', 'get', { action: 'get', projectPath: tempDir, tagName: 'v2.0.0', repo: repoName, owner: process.env.GITHUB_USERNAME });
+            // update, delete, download skipped to save time/complexity but covered by create/list/get
+        }
+        // --- 18. GitPulls ---
+        // Create a PR (requires pushing the feature branch first)
+        await testAction('push', 'push', { projectPath: tempDir, remote: 'github', branch: 'feature/test' });
+        const pr = await testAction('pulls', 'create', {
+            action: 'create',
+            projectPath: tempDir,
+            title: 'Test PR',
+            head: 'feature/test',
+            base: 'master',
+            repo: repoName,
+            owner: process.env.GITHUB_USERNAME
+        });
+        console.log('PR Result:', JSON.stringify(pr, null, 2));
+        if (pr && pr.providers.github && pr.providers.github.pull) {
+            const prNum = pr.providers.github.pull.number;
+            console.log(`Extracted PR Number: ${prNum}`);
+            await testAction('pulls', 'list', { action: 'list', projectPath: tempDir, repo: repoName, owner: process.env.GITHUB_USERNAME });
+            await testAction('pulls', 'get', { action: 'get', projectPath: tempDir, pullNumber: prNum, repo: repoName, owner: process.env.GITHUB_USERNAME });
+            // merge, close, comment, review skipped to avoid messing up repo state too much
+        }
+        // --- 19. GitFix ---
+        await testAction('fix', 'fix', { projectPath: tempDir, autoDetect: true });
+        // --- 20. GitPackages ---
+        await testAction('files', 'create', { action: 'create', projectPath: tempDir, filePath: 'package.json', content: '{"name": "test", "version": "1.0.0"}' });
+        await testAction('packages', 'list', { action: 'list', projectPath: tempDir, packageType: 'npm' });
+        // --- 21. GitChangelog ---
+        await testAction('changelog', 'generate', { projectPath: tempDir });
+        // --- 22. GitReset ---
+        await testAction('reset', 'soft', { action: 'soft', projectPath: tempDir, ref: 'HEAD~1' });
+        // --- 23. GitSync ---
+        await testAction('sync', 'status', { action: 'status', projectPath: tempDir });
+        // fetch, pull, push, sync, one-shot covered implicitly or explicitly above
+        // --- 24. GitUpdate ---
+        // This is a composite tool
+        await testAction('update', 'update', { projectPath: tempDir, message: 'Update via tool' });
+        // --- 25. GitUpload ---
+        // This is a composite tool - usually for initial upload, but can run on existing
+        await testAction('upload', 'upload', { projectPath: tempDir, repoName: repoName });
+        // --- Cleanup ---
+        console.log('\nCleaning up remote repositories...');
+        await testAction('workflow', 'delete', { action: 'delete', projectPath: tempDir, repo: repoName, owner: process.env.GITHUB_USERNAME, confirmDestructive: true });
+        await testAction('workflow', 'delete', { action: 'delete', projectPath: tempDir, repo: repoName, owner: process.env.GITEA_USERNAME, confirmDestructive: true });
+        // Local Cleanup
+        fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+    catch (error) {
+        console.error('\n❌ FATAL ERROR:', error);
+    }
+    console.log('\n📊 EXHAUSTIVE TEST RESULTS SUMMARY:');
+    console.table(results);
+}
+runExhaustiveTest().catch(console.error);

package/dist/scripts/verify_setup.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scripts/verify_setup.js

@@ -0,0 +1,61 @@
+import { ProviderManager } from '../providers/providerManager.js';
+import { IsomorphicGitAdapter } from '../utils/gitAdapter.js';
+import * as path from 'path';
+import * as fs from 'fs';
+async function verify() {
+    console.log('🔍 Verifying setup and credentials...');
+    // 1. Check Environment Variables
+    console.log('\n1. Environment Variables:');
+    const vars = ['GITHUB_TOKEN', 'GITHUB_USERNAME', 'GITEA_TOKEN', 'GITEA_URL', 'GITEA_USERNAME'];
+    const missing = [];
+    for (const v of vars) {
+        if (process.env[v]) {
+            console.log(`   ✅ ${v} is set`);
+        }
+        else {
+            console.log(`   ❌ ${v} is MISSING`);
+            missing.push(v);
+        }
+    }
+    // 2. Validate Providers
+    console.log('\n2. Provider Connection:');
+    const providerManager = new ProviderManager();
+    const results = await providerManager.validateConfiguredProviders();
+    if (results.github) {
+        console.log(`   GitHub: ${results.github.ok ? '✅ Connected' : '❌ Failed: ' + results.github.error}`);
+    }
+    else {
+        console.log('   GitHub: ⚠️ Not configured');
+    }
+    if (results.gitea) {
+        console.log(`   Gitea:  ${results.gitea.ok ? '✅ Connected' : '❌ Failed: ' + results.gitea.error}`);
+    }
+    else {
+        console.log('   Gitea:  ⚠️ Not configured');
+    }
+    // 3. Validate GitAdapter
+    console.log('\n3. GitAdapter Initialization:');
+    try {
+        const gitAdapter = new IsomorphicGitAdapter(providerManager);
+        console.log('   ✅ GitAdapter initialized successfully');
+        // Try a simple local operation if we are in a git repo
+        const currentDir = process.cwd();
+        if (fs.existsSync(path.join(currentDir, '.git'))) {
+            try {
+                const branch = await gitAdapter.getCurrentBranch(currentDir);
+                console.log(`   ✅ Local Git check passed (Current branch: ${branch})`);
+            }
+            catch (e) {
+                console.log(`   ❌ Local Git check failed: ${e.message}`);
+            }
+        }
+        else {
+            console.log('   ℹ️ Current directory is not a git repo, skipping local check');
+        }
+    }
+    catch (err) {
+        console.log(`   ❌ GitAdapter initialization failed: ${err.message}`);
+    }
+    console.log('\n🏁 Verification Complete');
+}
+verify().catch(console.error);

package/dist/tools/gitAnalytics.js

@@ -45,10 +45,10 @@ export class GitAnalyticsTool {
             throw new MCPError('VALIDATION_ERROR', 'projectPath is required');
         // Auto-extract repo info from projectPath
         const repoInfo = getRepoInfo(projectPath);
-        const repo = repoInfo.repoName;
+        const repo = params.repo || repoInfo.repoName;
         // Each provider uses its own username from env
-        const githubOwner = process.env.GITHUB_USERNAME;
-        const giteaOwner = process.env.GITEA_USERNAME;
+        const githubOwner = params.owner || process.env.GITHUB_USERNAME;
+        const giteaOwner = params.owner || process.env.GITEA_USERNAME;
         switch (action) {
             case 'stats': {
                 const results = { success: true, providers: {} };

package/dist/tools/gitBackup.d.ts

@@ -40,8 +40,8 @@ export declare class GitBackupTool implements Tool {
         backupData: {
             projectPath: any;
             timestamp: string;
-            branch: string | null;
-            lastCommit: string | undefined;
+            branch: string;
+            lastCommit: string | null;
             files: number;
         };
         message: string;

package/dist/tools/gitBackup.js

@@ -1,6 +1,5 @@
 import fs from 'fs/promises';
 import path from 'path';
-import simpleGit from 'simple-git';
 import { MCPError } from '../utils/errors.js';
 export class GitBackupTool {
     constructor() {
@@ -46,6 +45,7 @@ export class GitBackupTool {
             throw new MCPError('VALIDATION_ERROR', 'action and projectPath are required');
         }
         switch (action) {
+            case 'create':
             case 'backup': {
                 const backupDir = params.backupDir || path.join(projectPath, '.git-backups');
                 const backupName = params.backupName || `backup-${Date.now()}.json`;
@@ -53,14 +53,14 @@ export class GitBackupTool {
                     // Criar diretório de backups
                     await fs.mkdir(backupDir, { recursive: true });
                     const backupPath = path.join(backupDir, backupName);
-                    const git = simpleGit({ baseDir: projectPath });
-                    const status = await git.status();
-                    const log = await git.log({ maxCount: 1 });
+                    const git = ctx.gitAdapter;
+                    const status = await git.status(projectPath);
+                    const log = await git.log(projectPath, { maxCount: 1 });
                     const backupData = {
                         projectPath,
                         timestamp: new Date().toISOString(),
                         branch: status.current,
-                        lastCommit: log.latest?.hash,
+                        lastCommit: log.length > 0 ? log[0].hash : null,
                         files: status.files.length,
                     };
                     await fs.writeFile(backupPath, JSON.stringify(backupData, null, 2));