@andrebuzeli/git-mcp 10.0.7 → 10.0.9

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));

package/dist/tools/gitBranches.js

@@ -1,4 +1,3 @@
-import simpleGit from 'simple-git';
 import { MCPError } from '../utils/errors.js';
 import { requireConfirmationIfDestructive } from '../utils/safetyController.js';
 import { getRepoInfo } from '../utils/repoHelpers.js';
@@ -62,7 +61,9 @@ export class GitBranchesTool {
         if (!action || !projectPath) {
             throw new MCPError('VALIDATION_ERROR', 'action and projectPath are required');
         }
-        const git = simpleGit({ baseDir: projectPath });
+        if (!ctx.gitAdapter) {
+            throw new MCPError('INTERNAL_ERROR', 'Git adapter not available');
+        }
         switch (action) {
             case 'create': {
                 const branchName = params.branchName;
@@ -70,34 +71,36 @@ export class GitBranchesTool {
                     throw new MCPError('VALIDATION_ERROR', 'branchName is required');
                 const sourceBranch = params.sourceBranch;
                 if (sourceBranch) {
-                    await git.checkout(sourceBranch);
+                    await ctx.gitAdapter.checkout(projectPath, sourceBranch);
                 }
-                await git.checkoutLocalBranch(branchName);
+                await ctx.gitAdapter.createBranch(projectPath, branchName);
                 if (params.checkout !== false) {
-                    await git.checkout(branchName);
+                    await ctx.gitAdapter.checkout(projectPath, branchName);
                 }
                 return { success: true, branch: branchName, local: true };
             }
             case 'list': {
-                const localBranches = await git.branch();
+                const branches = await ctx.gitAdapter.listBranches(projectPath);
+                const current = await ctx.gitAdapter.getCurrentBranch(projectPath);
                 const results = {
                     success: true,
                     local: {
-                        branches: localBranches.all,
-                        current: localBranches.current,
+                        branches,
+                        current,
                     },
                     providers: {}
                 };
                 // Also query remote APIs
                 const repoInfo = getRepoInfo(projectPath);
-                const githubOwner = process.env.GITHUB_USERNAME;
-                const giteaOwner = process.env.GITEA_USERNAME;
+                const repo = params.repo || repoInfo.repoName;
+                const githubOwner = params.owner || process.env.GITHUB_USERNAME;
+                const giteaOwner = params.owner || process.env.GITEA_USERNAME;
                 // GitHub
                 if (ctx.providerManager.github && githubOwner) {
                     try {
                         const branches = await ctx.providerManager.github.rest.repos.listBranches({
                             owner: githubOwner,
-                            repo: repoInfo.repoName,
+                            repo: repo,
                         });
                         results.providers.github = {
                             success: true,
@@ -115,7 +118,7 @@ export class GitBranchesTool {
                 // Gitea
                 if (ctx.providerManager.giteaBaseUrl && giteaOwner) {
                     try {
-                        const branches = await axios.get(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${giteaOwner}/${repoInfo.repoName}/branches`, { headers: { Authorization: `token ${ctx.providerManager.giteaToken}` } });
+                        const branches = await axios.get(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${giteaOwner}/${repo}/branches`, { headers: { Authorization: `token ${ctx.providerManager.giteaToken}` } });
                         results.providers.gitea = {
                             success: true,
                             branches: branches.data.map((b) => ({
@@ -135,23 +138,25 @@ export class GitBranchesTool {
                 const branchName = params.branchName;
                 if (!branchName)
                     throw new MCPError('VALIDATION_ERROR', 'branchName is required');
-                const branches = await git.branch();
-                const branch = branches.all.find(b => b === branchName);
+                const branches = await ctx.gitAdapter.listBranches(projectPath);
+                const current = await ctx.gitAdapter.getCurrentBranch(projectPath);
+                const found = branches.includes(branchName);
                 const results = {
                     success: true,
-                    local: branch ? { branch, current: branches.current === branchName } : { found: false },
+                    local: found ? { branch: branchName, current: current === branchName } : { found: false },
                     providers: {}
                 };
                 // Also query remote APIs
                 const repoInfo = getRepoInfo(projectPath);
-                const githubOwner = process.env.GITHUB_USERNAME;
-                const giteaOwner = process.env.GITEA_USERNAME;
+                const repo = params.repo || repoInfo.repoName;
+                const githubOwner = params.owner || process.env.GITHUB_USERNAME;
+                const giteaOwner = params.owner || process.env.GITEA_USERNAME;
                 // GitHub
                 if (ctx.providerManager.github && githubOwner) {
                     try {
                         const branchData = await ctx.providerManager.github.rest.repos.getBranch({
                             owner: githubOwner,
-                            repo: repoInfo.repoName,
+                            repo: repo,
                             branch: branchName,
                         });
                         results.providers.github = {
@@ -171,7 +176,7 @@ export class GitBranchesTool {
                 // Gitea
                 if (ctx.providerManager.giteaBaseUrl && giteaOwner) {
                     try {
-                        const branchData = await axios.get(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${giteaOwner}/${repoInfo.repoName}/branches/${branchName}`, { headers: { Authorization: `token ${ctx.providerManager.giteaToken}` } });
+                        const branchData = await axios.get(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${giteaOwner}/${repo}/branches/${branchName}`, { headers: { Authorization: `token ${ctx.providerManager.giteaToken}` } });
                         results.providers.gitea = {
                             success: true,
                             branch: {
@@ -193,7 +198,7 @@ export class GitBranchesTool {
                 const branchName = params.branchName;
                 if (!branchName)
                     throw new MCPError('VALIDATION_ERROR', 'branchName is required');
-                await git.deleteLocalBranch(branchName, params.force);
+                await ctx.gitAdapter.deleteBranch(projectPath, branchName, params.force);
                 return { success: true, deleted: branchName, local: true };
             }
             case 'merge': {
@@ -202,9 +207,9 @@ export class GitBranchesTool {
                 if (!branchName)
                     throw new MCPError('VALIDATION_ERROR', 'branchName is required');
                 if (targetBranch) {
-                    await git.checkout(targetBranch);
+                    await ctx.gitAdapter.checkout(projectPath, targetBranch);
                 }
-                const result = await git.merge([branchName]);
+                const result = await ctx.gitAdapter.merge(projectPath, branchName);
                 return { success: true, result, local: true };
             }
             case 'compare': {
@@ -213,28 +218,34 @@ export class GitBranchesTool {
                 if (!baseBranch || !compareBranch) {
                     throw new MCPError('VALIDATION_ERROR', 'baseBranch and compareBranch are required');
                 }
-                const diff = await git.diff([`${baseBranch}...${compareBranch}`]);
-                const log = await git.log({ from: baseBranch, to: compareBranch });
+                // Basic comparison using log
+                // Note: This is a simplified comparison compared to git log base..compare
+                const baseLog = await ctx.gitAdapter.log(projectPath, { ref: baseBranch, maxCount: 20 });
+                const compareLog = await ctx.gitAdapter.log(projectPath, { ref: compareBranch, maxCount: 20 });
+                // Find commits in compare that are not in base
+                const baseHashes = new Set(baseLog.map(c => c.hash));
+                const uniqueCommits = compareLog.filter(c => !baseHashes.has(c.hash));
                 const results = {
                     success: true,
                     local: {
                         baseBranch,
                         compareBranch,
-                        commits: log.all,
-                        diff,
+                        commits: uniqueCommits,
+                        diff: "Diff not supported in adapter yet", // Placeholder
                     },
                     providers: {}
                 };
                 // Also compare on remote APIs
                 const repoInfo = getRepoInfo(projectPath);
-                const githubOwner = process.env.GITHUB_USERNAME;
-                const giteaOwner = process.env.GITEA_USERNAME;
+                const repo = params.repo || repoInfo.repoName;
+                const githubOwner = params.owner || process.env.GITHUB_USERNAME;
+                const giteaOwner = params.owner || process.env.GITEA_USERNAME;
                 // GitHub
                 if (ctx.providerManager.github && githubOwner) {
                     try {
                         const comparison = await ctx.providerManager.github.rest.repos.compareCommits({
                             owner: githubOwner,
-                            repo: repoInfo.repoName,
+                            repo: repo,
                             base: baseBranch,
                             head: compareBranch,
                         });

package/dist/tools/gitConfig.d.ts

@@ -63,7 +63,7 @@ export declare class GitConfigTool implements Tool {
     } | {
         success: boolean;
         scope: string;
-        configs: import("simple-git").ConfigValues;
+        configs: Record<string, string>;
         key?: undefined;
         value?: undefined;
         message?: undefined;
@@ -74,7 +74,7 @@ export declare class GitConfigTool implements Tool {
     } | {
         success: boolean;
         key: any;
-        value: string | null;
+        value: string | undefined;
         scope: string | undefined;
         message?: undefined;
         configs?: undefined;

package/dist/tools/gitConfig.js

@@ -1,4 +1,3 @@
-import simpleGit from 'simple-git';
 import { MCPError } from '../utils/errors.js';
 import * as fs from 'fs/promises';
 import * as path from 'path';
@@ -49,49 +48,49 @@ export class GitConfigTool {
         if (!action || !projectPath) {
             throw new MCPError('VALIDATION_ERROR', 'action and projectPath are required');
         }
-        const git = simpleGit({ baseDir: projectPath });
+        if (!ctx.gitAdapter) {
+            throw new MCPError('INTERNAL_ERROR', 'Git adapter not available');
+        }
         const scope = params.global ? 'global' : params.system ? 'system' : 'local';
         switch (action) {
             case 'get': {
                 const key = params.key;
                 if (!key)
                     throw new MCPError('VALIDATION_ERROR', 'key is required');
-                try {
-                    const value = await git.getConfig(key, scope);
-                    return { success: true, key, value: value.value };
-                }
-                catch (err) {
+                const value = await ctx.gitAdapter.getConfig(projectPath, key, scope);
+                if (value === undefined) {
                     throw new MCPError('CONFIG_NOT_FOUND', `Configuration key '${key}' not found`);
                 }
+                return { success: true, key, value };
             }
             case 'set': {
                 const key = params.key;
                 const value = params.value;
                 if (!key || value === undefined)
                     throw new MCPError('VALIDATION_ERROR', 'key and value are required');
-                await git.addConfig(key, value, false, scope);
+                await ctx.gitAdapter.setConfig(projectPath, key, value, scope);
                 return { success: true, key, value };
             }
             case 'unset': {
                 const key = params.key;
                 if (!key)
                     throw new MCPError('VALIDATION_ERROR', 'key is required');
-                await git.raw(['config', `--${scope}`, '--unset', key]);
+                await ctx.gitAdapter.unsetConfig(projectPath, key, scope);
                 return { success: true, key, message: 'Configuration removed' };
             }
             case 'list': {
-                const configs = await git.listConfig(scope);
-                return { success: true, scope, configs: configs.all };
+                const configs = await ctx.gitAdapter.listConfig(projectPath, scope);
+                return { success: true, scope, configs };
             }
             case 'show': {
                 const key = params.key;
                 if (!key)
                     throw new MCPError('VALIDATION_ERROR', 'key is required');
-                const value = await git.getConfig(key, scope);
+                const value = await ctx.gitAdapter.getConfig(projectPath, key, scope);
                 return {
                     success: true,
                     key,
-                    value: value.value,
+                    value,
                     scope: params.showScope ? scope : undefined,
                 };
             }

package/dist/tools/gitFix.d.ts

@@ -1,3 +1,4 @@
-export declare function handleGitFix(args: any): Promise<{
+import { MCPContext } from '../types.js';
+export declare function handleGitFix(args: any, ctx: MCPContext): Promise<{
     content: any[];
 }>;

package/dist/tools/gitFix.js

@@ -1,9 +1,8 @@
-import simpleGit from 'simple-git';
 import path from 'path';
 import fs from 'fs/promises';
 import { existsSync } from 'fs';
 import { buildGitHubUrl, buildGiteaUrl } from '../utils/repoHelpers.js';
-export async function handleGitFix(args) {
+export async function handleGitFix(args, ctx) {
     try {
         const { projectPath, githubRepo, giteaRepo, autoDetect = true } = args;
         if (!projectPath) {
@@ -13,7 +12,7 @@ export async function handleGitFix(args) {
         if (!existsSync(absolutePath)) {
             throw new Error(`Caminho não existe: ${absolutePath}`);
         }
-        const git = simpleGit(absolutePath);
+        const git = ctx.gitAdapter;
         const result = {
             success: false,
             projectPath: absolutePath,
@@ -28,24 +27,21 @@ export async function handleGitFix(args) {
         // Verificar se é um repositório Git
         let isGitRepo = false;
         try {
-            await git.status();
+            await git.status(absolutePath);
             isGitRepo = true;
             result.fixed.push('✅ Repositório Git válido encontrado');
         }
         catch (err) {
-            if (err.message.includes('not a git repository')) {
-                result.warnings.push('⚠️  Não é um repositório Git - inicializando...');
-                await git.init();
-                result.fixed.push('✅ Git inicializado');
-                isGitRepo = true;
-            }
-            else {
-                throw err;
-            }
+            // isomorphic-git throws if not a repo, but we should check the error message or type if possible
+            // For now, assume any error means it's not a repo or has issues
+            result.warnings.push('⚠️  Não é um repositório Git - inicializando...');
+            await git.init(absolutePath);
+            result.fixed.push('✅ Git inicializado');
+            isGitRepo = true;
         }
         // Capturar remotes antes
-        const remotesBefore = await git.getRemotes(true);
-        result.remotes.before = remotesBefore.map(r => ({ name: r.name, url: r.refs.fetch || '' }));
+        const remotesBefore = await git.listRemotes(absolutePath);
+        result.remotes.before = remotesBefore.map(r => ({ name: r.name, url: r.url || '' }));
         // Obter usernames das env vars (OBRIGATÓRIO usar as credenciais fornecidas)
         const githubUsername = process.env.GITHUB_USERNAME;
         const giteaUsername = process.env.GITEA_USERNAME;
@@ -58,7 +54,7 @@ export async function handleGitFix(args) {
         let detectedRepoName = null;
         if (autoDetect && remotesBefore.length > 0) {
             for (const remote of remotesBefore) {
-                const url = remote.refs.fetch || '';
+                const url = remote.url || '';
                 // Detectar APENAS o nome do repo (sem username)
                 if (url.includes('github.com') && !detectedRepoName) {
                     const match = url.match(/github\.com[:/][^/]+\/([^/.]+)/);
@@ -102,27 +98,27 @@ export async function handleGitFix(args) {
         for (const remoteName of remotesToRemove) {
             const exists = remotesBefore.find(r => r.name === remoteName);
             if (exists) {
-                await git.removeRemote(remoteName);
+                await git.removeRemote(absolutePath, remoteName);
                 result.fixed.push(`🗑️  Removido remote antigo: ${remoteName}`);
             }
         }
         // Adicionar novos remotes no padrão dual
         const githubUrl = buildGitHubUrl(finalGithubRepo.split('/')[0], finalGithubRepo.split('/')[1]);
         const giteaUrlFull = buildGiteaUrl(finalGiteaRepo.split('/')[0], finalGiteaRepo.split('/')[1]);
-        await git.addRemote('github', githubUrl);
+        await git.addRemote(absolutePath, 'github', githubUrl);
         result.fixed.push(`✅ Adicionado remote GitHub: ${githubUrl.replace(/oauth2:[^@]+@/, 'oauth2:***@')}`);
-        await git.addRemote('gitea', giteaUrlFull);
+        await git.addRemote(absolutePath, 'gitea', giteaUrlFull);
         result.fixed.push(`✅ Adicionado remote Gitea: ${giteaUrlFull.replace(/:[^:]+@/, ':***@')}`);
         // Configurar origin como push múltiplo
-        await git.addRemote('origin', githubUrl);
-        await git.addConfig('remote.origin.pushurl', giteaUrlFull, false, 'local');
+        await git.addRemote(absolutePath, 'origin', githubUrl);
+        await git.setConfig(absolutePath, 'remote.origin.pushurl', giteaUrlFull, 'local');
         result.fixed.push(`✅ Configurado origin para push dual (GitHub + Gitea)`);
         // Capturar remotes depois
-        const remotesAfter = await git.getRemotes(true);
-        result.remotes.after = remotesAfter.map(r => ({ name: r.name, url: r.refs.fetch || '' }));
+        const remotesAfter = await git.listRemotes(absolutePath);
+        result.remotes.after = remotesAfter.map(r => ({ name: r.name, url: r.url || '' }));
         // Verificar se há commits
         try {
-            await git.log();
+            await git.log(absolutePath);
             result.fixed.push('✅ Histórico de commits preservado');
         }
         catch (err) {

package/dist/tools/gitFix.tool.d.ts

@@ -1,4 +1,4 @@
-import { Tool } from '../types.js';
+import { Tool, MCPContext } from '../types.js';
 export declare class GitFixTool implements Tool {
     name: string;
     description: string;
@@ -25,7 +25,7 @@ export declare class GitFixTool implements Tool {
         required: string[];
         additionalProperties: boolean;
     };
-    handle(args: any): Promise<{
+    handle(args: any, ctx: MCPContext): Promise<{
         content: any[];
     }>;
 }

package/dist/tools/gitFix.tool.js

@@ -86,7 +86,7 @@ export class GitFixTool {
             additionalProperties: true
         };
     }
-    async handle(args) {
-        return handleGitFix(args);
+    async handle(args, ctx) {
+        return handleGitFix(args, ctx);
     }
 }

package/dist/tools/gitHistory.js

@@ -1,4 +1,3 @@
-import simpleGit from 'simple-git';
 import { MCPError } from '../utils/errors.js';
 import axios from 'axios';
 import * as fs from 'fs/promises';
@@ -44,7 +43,7 @@ export class GitHistoryTool {
             throw new MCPError('VALIDATION_ERROR', 'projectPath is required');
         }
         const action = params.action || 'track';
-        const git = simpleGit({ baseDir: projectPath });
+        const git = ctx.gitAdapter;
         switch (action) {
             case 'track': {
                 // Rastrear mudança específica e criar histórico remoto
@@ -82,9 +81,9 @@ export class GitHistoryTool {
         };
         try {
             // 1. Coletar detalhes da mudança
-            const status = await git.status();
-            const log = await git.log({ maxCount: 1 });
-            const lastCommit = log.latest;
+            const status = await git.status(projectPath);
+            const log = await git.log(projectPath, { maxCount: 1 });
+            const lastCommit = log.length > 0 ? log[0] : null;
             results.traceability.changeDetails = {
                 branch: status.current,
                 lastCommit: lastCommit ? {

package/dist/tools/gitIssues.js

@@ -84,9 +84,9 @@ export class GitIssuesTool {
         if (!projectPath)
             throw new MCPError('VALIDATION_ERROR', 'projectPath is required');
         const repoInfo = getRepoInfo(projectPath);
-        const repo = repoInfo.repoName;
-        const githubOwner = repoInfo.githubOwner || process.env.GITHUB_USERNAME;
-        const giteaOwner = repoInfo.giteaOwner || process.env.GITEA_USERNAME;
+        const repo = params.repo || repoInfo.repoName;
+        const githubOwner = params.owner || repoInfo.githubOwner || process.env.GITHUB_USERNAME;
+        const giteaOwner = params.owner || repoInfo.giteaOwner || process.env.GITEA_USERNAME;
         switch (action) {
             case 'create': {
                 if (!params.title)
@@ -174,7 +174,7 @@ export class GitIssuesTool {
                 return results;
             }
             case 'get': {
-                const issue_number = params.issue_number;
+                const issue_number = params.issue_number || params.issueNumber;
                 if (!issue_number)
                     throw new MCPError('VALIDATION_ERROR', 'issue_number is required');
                 if (!repo)
@@ -210,7 +210,7 @@ export class GitIssuesTool {
                 return results;
             }
             case 'update': {
-                const issue_number = params.issue_number;
+                const issue_number = params.issue_number || params.issueNumber;
                 if (!issue_number)
                     throw new MCPError('VALIDATION_ERROR', 'issue_number is required');
                 if (!repo)
@@ -253,7 +253,7 @@ export class GitIssuesTool {
                 return results;
             }
             case 'close': {
-                const issue_number = params.issue_number;
+                const issue_number = params.issue_number || params.issueNumber;
                 if (!issue_number)
                     throw new MCPError('VALIDATION_ERROR', 'issue_number is required');
                 if (!repo)
@@ -290,8 +290,8 @@ export class GitIssuesTool {
                 return results;
             }
             case 'comment': {
-                const issue_number = params.issue_number;
-                const comment_body = params.comment_body;
+                const issue_number = params.issue_number || params.issueNumber;
+                const comment_body = params.comment_body || params.body;
                 if (!issue_number)
                     throw new MCPError('VALIDATION_ERROR', 'issue_number is required');
                 if (!comment_body)