@andrebuzeli/git-mcp 10.0.7 → 10.0.9

package/dist/tools/gitUpload.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';
@@ -42,11 +41,13 @@ export class GitUploadTool {
         if (!projectPath) {
             throw new MCPError('VALIDATION_ERROR', 'projectPath is required');
         }
+        if (!ctx.gitAdapter) {
+            throw new MCPError('INTERNAL_ERROR', 'Git adapter not available');
+        }
         const repoName = params.repoName || getRepoNameFromPath(projectPath);
         const description = params.description || `Project uploaded via git-upload at ${new Date().toISOString()}`;
         const isPrivate = params.private !== undefined ? params.private : true;
         const branch = params.branch || 'master';
-        const git = simpleGit({ baseDir: projectPath });
         // Resultado com rastreabilidade completa
         const results = {
             success: true,
@@ -64,20 +65,16 @@ export class GitUploadTool {
         try {
             // 0. Verificar se é um repositório Git, se não for, inicializar
             try {
-                await git.status();
+                await ctx.gitAdapter.status(projectPath);
             }
             catch (err) {
-                if (err.message.includes('not a git repository')) {
-                    results.traceability.uploadSteps.push({
-                        step: 0,
-                        action: 'init_git_repository',
-                        timestamp: new Date().toISOString(),
-                    });
-                    await git.init();
-                }
-                else {
-                    throw err;
-                }
+                // If status fails, assume not a git repo or other error
+                results.traceability.uploadSteps.push({
+                    step: 0,
+                    action: 'init_git_repository',
+                    timestamp: new Date().toISOString(),
+                });
+                await ctx.gitAdapter.init(projectPath, branch);
             }
             // 1. Verificar status local
             results.traceability.uploadSteps.push({
@@ -85,7 +82,7 @@ export class GitUploadTool {
                 action: 'check_local_status',
                 timestamp: new Date().toISOString(),
             });
-            const status = await git.status();
+            const status = await ctx.gitAdapter.status(projectPath);
             results.traceability.localChanges = {
                 modified: status.modified,
                 created: status.created,
@@ -93,17 +90,17 @@ export class GitUploadTool {
                 renamed: status.renamed,
                 staged: status.staged,
                 conflicted: status.conflicted,
-                isClean: status.isClean(),
+                isClean: status.isClean,
             };
             // 2. Verificar se tem mudanças
-            if (!status.isClean()) {
+            if (!status.isClean) {
                 results.traceability.uploadSteps.push({
                     step: 2,
                     action: 'stage_all_changes',
                     timestamp: new Date().toISOString(),
                     files: [...status.modified, ...status.created, ...status.deleted],
                 });
-                await git.add('.');
+                await ctx.gitAdapter.add(projectPath, ['.']);
             }
             // 3. Commit com rastreabilidade
             const commitMessage = params.commitMessage || `[git-upload] Upload project at ${new Date().toISOString()}`;
@@ -115,7 +112,13 @@ export class GitUploadTool {
             });
             let commitResult;
             try {
-                commitResult = await git.commit(commitMessage);
+                const sha = await ctx.gitAdapter.commit(projectPath, commitMessage);
+                commitResult = {
+                    commit: sha,
+                    summary: { changes: 0, insertions: 0, deletions: 0 },
+                    branch: await ctx.gitAdapter.getCurrentBranch(projectPath),
+                    author: { name: 'unknown', email: 'unknown' }
+                };
                 results.traceability.commit = {
                     hash: commitResult.commit,
                     summary: commitResult.summary,
@@ -124,7 +127,7 @@ export class GitUploadTool {
                 };
             }
             catch (err) {
-                if (err.message.includes('nothing to commit')) {
+                if (err.message.includes('nothing to commit') || (status.isClean && status.staged.length === 0)) {
                     results.traceability.commit = { message: 'No changes to commit' };
                 }
                 else {
@@ -174,12 +177,12 @@ export class GitUploadTool {
                         };
                     }
                     // Adicionar remote se necessário (URL LIMPA sem token)
-                    const remotes = await git.getRemotes(true);
+                    const remotes = await ctx.gitAdapter.listRemotes(projectPath);
                     const githubRemote = remotes.find(r => r.name === 'github');
                     if (!githubRemote) {
                         // Usar URL limpa sem token para segurança
                         const remoteUrl = `https://github.com/${githubOwner}/${repoName}.git`;
-                        await git.addRemote('github', remoteUrl);
+                        await ctx.gitAdapter.addRemote(projectPath, 'github', remoteUrl);
                         results.traceability.uploadSteps.push({
                             step: 5,
                             action: 'add_github_remote',
@@ -195,19 +198,12 @@ export class GitUploadTool {
                         branch,
                     });
                     try {
-                        // Configurar credential helper temporário para este push
-                        await git.addConfig('credential.https://github.com.helper', 'store');
-                        await git.addConfig(`credential.https://github.com.username`, githubOwner);
                         // Push com --set-upstream mas SEM --force (segurança)
-                        await git.push('github', branch, ['--set-upstream']);
-                        // Limpar credential helper após push
-                        await git.addConfig('credential.https://github.com.helper', '');
+                        await ctx.gitAdapter.push(projectPath, 'github', branch, false, true);
                         results.providers.github.pushed = true;
                         results.providers.github.pushStatus = 'success';
                     }
                     catch (pushErr) {
-                        // Limpar credential helper em caso de erro
-                        await git.addConfig('credential.https://github.com.helper', '');
                         results.providers.github.pushed = false;
                         results.providers.github.pushError = pushErr.message;
                         results.traceability.errors.push({
@@ -271,14 +267,14 @@ export class GitUploadTool {
                         };
                     }
                     // Adicionar remote se necessário (URL LIMPA sem token)
-                    const remotes = await git.getRemotes(true);
+                    const remotes = await ctx.gitAdapter.listRemotes(projectPath);
                     const giteaRemote = remotes.find(r => r.name === 'gitea');
                     if (!giteaRemote) {
                         // Usar URL limpa sem token para segurança
                         const baseUrl = ctx.providerManager.giteaBaseUrl;
                         const cleanUrl = baseUrl.replace(/\/$/, ''); // Remover barra final se houver
                         const remoteUrl = `${cleanUrl}/${giteaOwner}/${repoName}.git`;
-                        await git.addRemote('gitea', remoteUrl);
+                        await ctx.gitAdapter.addRemote(projectPath, 'gitea', remoteUrl);
                         results.traceability.uploadSteps.push({
                             step: 8,
                             action: 'add_gitea_remote',
@@ -294,23 +290,12 @@ export class GitUploadTool {
                         branch,
                     });
                     try {
-                        const baseUrl = ctx.providerManager.giteaBaseUrl;
-                        const cleanUrl = baseUrl.replace(/\/$/, '');
-                        // Configurar credential helper temporário
-                        await git.addConfig(`credential.${cleanUrl}.helper`, 'store');
-                        await git.addConfig(`credential.${cleanUrl}.username`, giteaOwner);
                         // Push com --set-upstream mas SEM --force (segurança)
-                        await git.push('gitea', branch, ['--set-upstream']);
-                        // Limpar credential helper após push
-                        await git.addConfig(`credential.${cleanUrl}.helper`, '');
+                        await ctx.gitAdapter.push(projectPath, 'gitea', branch, false, true);
                         results.providers.gitea.pushed = true;
                         results.providers.gitea.pushStatus = 'success';
                     }
                     catch (pushErr) {
-                        // Limpar credential helper em caso de erro
-                        const baseUrl = ctx.providerManager.giteaBaseUrl;
-                        const cleanUrl = baseUrl.replace(/\/$/, '');
-                        await git.addConfig(`credential.${cleanUrl}.helper`, '');
                         results.providers.gitea.pushed = false;
                         results.providers.gitea.pushError = pushErr.message;
                         results.traceability.errors.push({

package/dist/tools/gitWorkflow.js

@@ -1,4 +1,3 @@
-import simpleGit from 'simple-git';
 import { MCPError } from '../utils/errors.js';
 import { normalizeToolParams } from '../utils/repoHelpers.js';
 import axios from 'axios';
@@ -123,7 +122,6 @@ export class GitWorkflowTool {
         if (!action)
             throw new MCPError('VALIDATION_ERROR', 'action is required. You can use either "action" or "command" parameter.');
         const projectPath = params.projectPath;
-        const git = projectPath ? simpleGit({ baseDir: projectPath }) : null;
         // Validação de path para segurança
         if (projectPath) {
             const path = await import('path');
@@ -133,21 +131,24 @@ export class GitWorkflowTool {
                 throw new MCPError('VALIDATION_ERROR', 'Invalid project path provided');
             }
         }
+        if (!ctx.gitAdapter) {
+            throw new MCPError('INTERNAL_ERROR', 'Git adapter not available');
+        }
         switch (action) {
             case 'init': {
-                if (!projectPath || !git)
+                if (!projectPath)
                     throw new MCPError('VALIDATION_ERROR', 'projectPath is required for init');
-                await git.init(params.bare || false);
+                await ctx.gitAdapter.init(projectPath);
                 return { success: true, path: projectPath };
             }
             case 'status': {
-                if (!projectPath || !git)
+                if (!projectPath)
                     throw new MCPError('VALIDATION_ERROR', 'projectPath is required for status');
-                const status = await git.status();
+                const status = await ctx.gitAdapter.status(projectPath);
                 return { success: true, status };
             }
             case 'commit': {
-                if (!projectPath || !git)
+                if (!projectPath)
                     throw new MCPError('VALIDATION_ERROR', 'projectPath is required for commit');
                 const message = params.message;
                 if (!message)
@@ -162,40 +163,26 @@ export class GitWorkflowTool {
                     files = [files];
                 }
                 try {
-                    await git.add(files);
+                    await ctx.gitAdapter.add(projectPath, files);
                 }
                 catch (addErr) {
-                    // If add fails with pathspec error, try adding files individually
-                    if (addErr.message.includes('pathspec') && files.length > 1) {
-                        for (const file of files) {
-                            try {
-                                await git.add(file);
-                            }
-                            catch (singleErr) {
-                                console.warn(`Failed to add ${file}: ${singleErr.message}`);
-                            }
-                        }
-                    }
-                    else {
-                        throw addErr;
-                    }
+                    console.warn(`Failed to add files: ${addErr.message}`);
+                    throw addErr;
                 }
-                const result = await git.commit(message);
+                const result = await ctx.gitAdapter.commit(projectPath, message);
                 return { success: true, commit: result };
             }
             case 'sync': {
-                if (!projectPath || !git)
+                if (!projectPath)
                     throw new MCPError('VALIDATION_ERROR', 'projectPath is required for sync');
                 const remote = params.remote || 'origin';
-                const branch = params.branch;
-                await git.fetch(remote);
-                if (branch) {
-                    await git.pull(remote, branch);
+                let branch = params.branch;
+                if (!branch) {
+                    branch = await ctx.gitAdapter.getCurrentBranch(projectPath);
                 }
-                else {
-                    await git.pull();
-                }
-                await git.push();
+                await ctx.gitAdapter.fetch(projectPath, remote);
+                await ctx.gitAdapter.pull(projectPath, remote, branch);
+                await ctx.gitAdapter.push(projectPath, remote, branch);
                 return { success: true, message: 'Repository synced' };
             }
             case 'backup': {
@@ -445,10 +432,10 @@ export class GitWorkflowTool {
                 return results;
             }
             case 'push': {
-                if (!projectPath || !git)
+                if (!projectPath)
                     throw new MCPError('VALIDATION_ERROR', 'projectPath is required for push');
                 const remote = params.remote || 'origin';
-                const branch = params.branch;
+                let branch = params.branch;
                 const force = params.force || false;
                 const setUpstream = params.setUpstream !== undefined ? params.setUpstream : true;
                 // Segurança: verificar confirmação para operações destrutivas
@@ -460,24 +447,18 @@ export class GitWorkflowTool {
                         'If you must force push, ensure you understand the consequences.',
                     ]);
                 }
-                const pushOptions = [];
-                if (force)
-                    pushOptions.push('--force');
-                if (setUpstream)
-                    pushOptions.push('--set-upstream');
                 try {
-                    const pushResult = await git.push(remote, branch, pushOptions);
+                    if (!branch) {
+                        branch = await ctx.gitAdapter.getCurrentBranch(projectPath);
+                    }
+                    await ctx.gitAdapter.push(projectPath, remote, branch, force, setUpstream);
                     return {
                         success: true,
                         remote,
-                        branch: branch || 'current',
+                        branch,
                         force,
                         setUpstream,
-                        result: {
-                            pushed: pushResult.pushed || [],
-                            remoteMessages: pushResult.remoteMessages?.all || [],
-                            update: pushResult.update,
-                        },
+                        message: 'Push successful'
                     };
                 }
                 catch (err) {

package/dist/utils/gitAdapter.js

@@ -251,6 +251,15 @@ export class IsomorphicGitAdapter {
     // ========================================================================
     async commit(dir, message, providedAuthor) {
         const author = await this.getAuthor(dir, providedAuthor);
+        // Check if HEAD exists to determine if this is the initial commit
+        let parent;
+        try {
+            await git.resolveRef({ fs, dir, ref: 'HEAD' });
+        }
+        catch (err) {
+            // HEAD not found, this is the first commit
+            parent = [];
+        }
         const sha = await git.commit({
             fs,
             dir,
@@ -261,6 +270,7 @@ export class IsomorphicGitAdapter {
                 timestamp: author.timestamp,
                 timezoneOffset: author.timezoneOffset,
             },
+            parent,
         });
         return sha;
     }

package/dist/utils/repoHelpers.js

@@ -28,12 +28,7 @@ export function getGiteaOwner() {
  * Get Gitea base URL from environment
  */
 export function getGiteaUrl() {
-    const raw = process.env.GITEA_URL;
-    if (!raw)
-        return undefined;
-    // Trim whitespace and strip accidental surrounding quotes/backticks
-    const trimmed = raw.trim().replace(/^['"`]+|['"`]+$/g, '');
-    return trimmed;
+    return process.env.GITEA_URL;
 }
 /**
  * Build GitHub repository URL
@@ -50,12 +45,12 @@ export function buildGiteaUrl(owner, repo) {
     if (!baseUrl) {
         throw new Error('GITEA_URL not configured');
     }
-    // Normalize base URL (remove trailing slashes)
-    const normalized = baseUrl.replace(/\/$/, '');
-    // Preserve protocol and embed credentials only if token is provided
-    const hasToken = Boolean(token);
-    const withCreds = hasToken ? normalized.replace(/^https?:\/\//, (proto) => `${proto}${owner}:${token}@`) : normalized;
-    return `${withCreds}/${owner}/${repo}.git`;
+    if (!token) {
+        throw new Error('GITEA_TOKEN not configured');
+    }
+    // Remove protocol from baseUrl
+    const urlWithoutProtocol = baseUrl.replace(/^https?:\/\//, '');
+    return `http://${owner}:${token}@${urlWithoutProtocol}/${owner}/${repo}.git`;
 }
 /**
  * Get repository info from project path and environment

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@andrebuzeli/git-mcp",
-  "version": "10.0.7",
+  "version": "10.0.9",
   "type": "module",
   "description": "Professional MCP server for Git operations - STDIO UNIVERSAL: works in ANY IDE (Cursor, VSCode, Claude Desktop, Trae AI, Kiro.dev). Fully autonomous DUAL execution (GitHub + Gitea APIs) with automatic username detection. Smart parameter normalization handles both 'action' and 'command' formats. All tools execute on BOTH providers simultaneously. No manual parameters needed.",
   "main": "dist/index.js",
@@ -59,8 +59,7 @@
     "axios": "^1.6.0",
     "body-parser": "^1.20.2",
     "express": "^4.18.2",
-    "isomorphic-git": "^1.34.0",
-    "simple-git": "^3.20.0"
+    "isomorphic-git": "^1.34.0"
   },
   "devDependencies": {
     "@semantic-release/commit-analyzer": "^10.0.0",

package/dist/server-new.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/dist/server-new.js

@@ -1,224 +0,0 @@
-#!/usr/bin/env node
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
-import { ProviderManager } from './providers/providerManager.js';
-import { MCPError } from './utils/errors.js';
-import { IsomorphicGitAdapter } from './utils/gitAdapter.js';
-import { GitFilesTool } from './tools/gitFiles.js';
-import { GitWorkflowTool } from './tools/gitWorkflow.js';
-import { GitBranchesTool } from './tools/gitBranches.js';
-import { GitIssuesTool } from './tools/gitIssues.js';
-import { GitPullsTool } from './tools/gitPulls.js';
-import { GitTagsTool } from './tools/gitTags.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 { GitConfigTool } from './tools/gitConfig.js';
-import { GitMonitorTool } from './tools/gitMonitor.js';
-import { GitBackupTool } from './tools/gitBackup.js';
-import { GitArchiveTool } from './tools/gitArchive.js';
-import { GitSyncTool } from './tools/gitSync.js';
-import { GitPackagesTool } from './tools/gitPackages.js';
-import { GitAnalyticsTool } from './tools/gitAnalytics.js';
-import { GitUploadTool } from './tools/gitUpload.js';
-import { GitUpdateTool } from './tools/gitUpdate.js';
-import { GitHistoryTool } from './tools/gitHistory.js';
-import { GitFixTool } from './tools/gitFix.tool.js';
-import { GitIgnoreTool } from './tools/gitIgnore.js';
-import { GIT_PROMPTS } from './prompts/gitPrompts.js';
-import TOOLS_GUIDE from './resources/toolsGuide.js';
-import { Logger, logToolExecution, logSecurityEvent, logPerformanceMetric } from './utils/logger.js';
-async function main() {
-    const providerManager = new ProviderManager();
-    const gitAdapter = new IsomorphicGitAdapter(providerManager);
-    const logger = Logger.getInstance();
-    // Skip validation on startup to prevent hanging (validation happens on first use)
-    // Provider validation moved to lazy initialization
-    // Register all 22 Git tools
-    const tools = [
-        new GitWorkflowTool(),
-        new GitFilesTool(),
-        new GitBranchesTool(),
-        new GitIssuesTool(),
-        new GitPullsTool(),
-        new GitTagsTool(),
-        new GitReleaseTool(),
-        new GitRemoteTool(),
-        new GitResetTool(),
-        new GitStashTool(),
-        new GitConfigTool(),
-        new GitMonitorTool(),
-        new GitBackupTool(),
-        new GitArchiveTool(),
-        new GitSyncTool(),
-        new GitPackagesTool(),
-        new GitAnalyticsTool(),
-        new GitUploadTool(),
-        new GitUpdateTool(),
-        new GitHistoryTool(),
-        new GitFixTool(),
-        new GitIgnoreTool(),
-    ];
-    // Register resources
-    const resources = [
-        TOOLS_GUIDE
-    ];
-    // Silent mode for MCP clients - only log to stderr in debug mode
-    if (process.env.DEBUG) {
-        logger.info(`Registered ${tools.length} Git tools`);
-        logger.info(`Registered ${resources.length} resource(s)`);
-        logger.info(`Registered ${GIT_PROMPTS.length} prompt(s)`);
-    }
-    // Create MCP Server with STDIO transport
-    const server = new Server({
-        name: '@andrebuzeli/git-mcp',
-        version: '10.0.4',
-    });
-    // Register tool list handler
-    server.setRequestHandler(ListToolsRequestSchema, async () => {
-        logger.debug('Listing available tools');
-        return {
-            tools: tools.map(tool => ({
-                name: tool.name,
-                description: tool.description,
-                inputSchema: tool.inputSchema || {
-                    type: 'object',
-                    properties: {},
-                    additionalProperties: true,
-                },
-            })),
-        };
-    });
-    // Register tool execution handler with logging e segurança aprimorados
-    server.setRequestHandler(CallToolRequestSchema, async (request) => {
-        const toolName = request.params.name;
-        const tool = tools.find(t => t.name === toolName);
-        const startTime = Date.now();
-        if (!tool) {
-            logSecurityEvent('TOOL_NOT_FOUND', { toolName });
-            throw new Error(`Tool not found: ${toolName}`);
-        }
-        try {
-            // Validar argumentos contra o schema da ferramenta
-            const args = request.params.arguments ?? {};
-            // Validação básica de segurança
-            if (typeof args !== 'object' || args === null) {
-                logSecurityEvent('INVALID_ARGUMENTS', { toolName, args });
-                throw new MCPError('VALIDATION_ERROR', 'Arguments must be an object');
-            }
-            // Validar projectPath se existir
-            if ('projectPath' in args) {
-                const projectPath = args.projectPath;
-                if (typeof projectPath !== 'string') {
-                    logSecurityEvent('INVALID_PROJECT_PATH_TYPE', { toolName, projectPath });
-                    throw new MCPError('VALIDATION_ERROR', 'projectPath must be a string');
-                }
-                if (!projectPath || projectPath.includes('..')) {
-                    logSecurityEvent('PATH_TRAVERSION_ATTEMPT', { toolName, projectPath });
-                    throw new MCPError('VALIDATION_ERROR', 'Invalid project path');
-                }
-            }
-            // Log da execução
-            logger.info(`Executing tool: ${toolName}`, { args }, toolName);
-            // Executar a ferramenta
-            const result = await tool.handle(args, { providerManager, gitAdapter });
-            const duration = Date.now() - startTime;
-            logPerformanceMetric(`tool_${toolName}`, duration, { success: true });
-            logToolExecution(toolName, args, result);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: typeof result === 'string' ? result : JSON.stringify(result, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            const duration = Date.now() - startTime;
-            logPerformanceMetric(`tool_${toolName}`, duration, { success: false, error: error.message });
-            logToolExecution(toolName, request.params.arguments ?? {}, undefined, error);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `Error: ${error.message || String(error)}`,
-                    },
-                ],
-                isError: true,
-            };
-        }
-    });
-    // Register resource list handler
-    server.setRequestHandler(ListResourcesRequestSchema, async () => {
-        logger.debug('Listing available resources');
-        return {
-            resources: resources.map(resource => ({
-                uri: resource.uri,
-                name: resource.name,
-                description: resource.description,
-                mimeType: resource.mimeType,
-            })),
-        };
-    });
-    // Register resource read handler
-    server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
-        const uri = request.params.uri;
-        const resource = resources.find(r => r.uri === uri);
-        if (!resource) {
-            logger.warn(`Resource not found: ${uri}`);
-            throw new Error(`Resource not found: ${uri}`);
-        }
-        logger.debug(`Reading resource: ${uri}`);
-        return {
-            contents: [
-                {
-                    uri: resource.uri,
-                    mimeType: resource.mimeType,
-                    text: resource.content,
-                },
-            ],
-        };
-    });
-    // Register prompt list handler
-    server.setRequestHandler(ListPromptsRequestSchema, async () => {
-        logger.debug('Listing available prompts');
-        return {
-            prompts: GIT_PROMPTS.map(prompt => ({
-                name: prompt.name,
-                description: prompt.description,
-                arguments: prompt.arguments,
-            })),
-        };
-    });
-    // Register prompt get handler
-    server.setRequestHandler(GetPromptRequestSchema, async (request) => {
-        const promptName = request.params.name;
-        const prompt = GIT_PROMPTS.find(p => p.name === promptName);
-        if (!prompt) {
-            logger.warn(`Prompt not found: ${promptName}`);
-            throw new Error(`Prompt not found: ${promptName}`);
-        }
-        logger.debug(`Generating prompt: ${promptName}`);
-        const result = await prompt.generate(request.params.arguments ?? {}, { providerManager, gitAdapter });
-        return {
-            description: result.description,
-            messages: result.messages,
-        };
-    });
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
-    // Only log in debug mode
-    if (process.env.DEBUG) {
-        logger.info(`✅ git-mcp MCP server running via STDIO`);
-        logger.info(`Tools: ${tools.length} registered`);
-        logger.info(`Resources: ${resources.length} registered`);
-        logger.info(`Prompts: ${GIT_PROMPTS.length} registered`);
-    }
-}
-main().catch(err => {
-    console.error('❌ Failed to start git-mcp:', err);
-    process.exit(1);
-});