@andrebuzeli/git-mcp 4.0.20 → 4.0.21

package/dist/server.js

@@ -6,201 +6,80 @@ const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
 const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
 const config_js_1 = require("./config.js");
 const index_js_2 = require("./providers/index.js");
+// Import all tools
+const git_workflow_js_1 = require("./tools/git-workflow.js");
+const git_files_js_1 = require("./tools/git-files.js");
+const git_branches_js_1 = require("./tools/git-branches.js");
+const git_issues_js_1 = require("./tools/git-issues.js");
+const git_pulls_js_1 = require("./tools/git-pulls.js");
+const git_tags_js_1 = require("./tools/git-tags.js");
+const git_release_js_1 = require("./tools/git-release.js");
+const git_remote_js_1 = require("./tools/git-remote.js");
+const git_reset_js_1 = require("./tools/git-reset.js");
+const git_stash_js_1 = require("./tools/git-stash.js");
+const git_config_js_1 = require("./tools/git-config.js");
+const git_monitor_js_1 = require("./tools/git-monitor.js");
+const git_backup_js_1 = require("./tools/git-backup.js");
+const git_archive_js_1 = require("./tools/git-archive.js");
+const git_packages_js_1 = require("./tools/git-packages.js");
+const git_analytics_js_1 = require("./tools/git-analytics.js");
+const git_sync_js_1 = require("./tools/git-sync.js");
+const git_repos_js_1 = require("./tools/git-repos.js");
 /**
- * Importação das ferramentas MCP UNIFICADAS (18 tools)
+ * Servidor MCP Git Completo com 18 Tools Oficiais
  *
- * ARQUITETURA UNIFICADA PARA AI AGENTS - MCP GIT AI UNIFICATION:
- * - Redução inteligente de 25 para 18 ferramentas
- * - Auto-detecção universal (repo, owner, providers)
- * - Interface consistente para todos os AI agents/IDEs
- * - Error handling com recovery automático
- * - Foco em produtividade individual e backup
- *
- * CORE UNIFIED TOOLS (6) - FUNCIONALIDADES ESSENCIAIS:
- * - git-workflow: Workflow completo (init, commit, sync, status, backup)
- * - git-files: Operações inteligentes de arquivo (read, write, search, update, backup-files)
- * - git-release: Sistema de release automatizado (create, version, publish, history, rollback)
- * - git-monitor: Monitoramento avançado (status, history, metrics, health, activity)
- * - git-backup: Sistema de backup inteligente (create, restore, list, auto, verify)
- * - git-branches: Gerenciamento de branches unificado
- *
- * ADVANCED TOOLS (6) - FUNCIONALIDADES AVANÇADAS:
- * - git-remote: Gerenciamento de remotos
- * - git-stash: Operações de stash
- * - git-reset: Reset seguro
- * - git-tags: Gerenciamento de tags
- * - git-issues: Sistema de issues
- * - git-pulls: Pull requests
- *
- * SPECIALIZED TOOLS (6) - FUNCIONALIDADES ESPECÍFICAS:
- * - git-analytics: Analytics e relatórios
- * - git-archive: Operações de archive
- * - git-packages: Gerenciamento de pacotes
- * - git-sync: Sincronização multi-provider
- * - git-repos: Gerenciamento de repositórios
- * - git-config: Configurações avançadas
- *
- * DIFERENCIAIS IMPLEMENTADOS:
- * - Apenas action + projectPath obrigatórios
- * - Auto-detecção completa de contexto
- * - Respostas estruturadas universais
- * - Error handling inteligente com sugestões
- * - Multi-provider automático
- * - Interface compatível com qualquer AI agent/IDE
- */
-// CORE UNIFIED TOOLS (6 ferramentas essenciais)
-const git_workflow_js_1 = require("./tools/git-workflow.js"); // Workflow unificado
-const git_files_js_1 = require("./tools/git-files.js"); // Operações de arquivo inteligentes
-const git_release_js_1 = require("./tools/git-release.js"); // Sistema de release automatizado
-const git_monitor_js_1 = require("./tools/git-monitor.js"); // Monitoramento avançado
-const git_backup_js_1 = require("./tools/git-backup.js"); // Sistema de backup inteligente
-const git_branches_js_1 = require("./tools/git-branches.js"); // Gerenciamento de branches
-// ADVANCED TOOLS (6 ferramentas avançadas)
-const git_remote_js_1 = require("./tools/git-remote.js"); // Gerenciamento de remotos
-const git_stash_js_1 = require("./tools/git-stash.js"); // Operações de stash
-const git_reset_js_1 = require("./tools/git-reset.js"); // Reset seguro
-const git_tags_js_1 = require("./tools/git-tags.js"); // Gerenciamento de tags
-const git_issues_js_1 = require("./tools/git-issues.js"); // Sistema de issues
-const git_pulls_js_1 = require("./tools/git-pulls.js"); // Pull requests
-// SPECIALIZED TOOLS (6 ferramentas especializadas)
-const git_analytics_js_1 = require("./tools/git-analytics.js"); // Analytics e relatórios
-const git_archive_js_1 = require("./tools/git-archive.js"); // Operações de archive
-const git_packages_js_1 = require("./tools/git-packages.js"); // Gerenciamento de pacotes
-const git_sync_js_1 = require("./tools/git-sync.js"); // Sincronização multi-provider
-const git_repos_js_1 = require("./tools/git-repos.js"); // Gerenciamento de repositórios
-const git_config_js_1 = require("./tools/git-config.js"); // Configurações avançadas
-/**
- * Array de todas as ferramentas disponíveis (18 tools) - UNIFICADAS
- *
- * ARQUITETURA UNIFICADA MCP GIT AI UNIFICATION:
- * - 18 ferramentas otimizadas para AI agents
- * - Interface universal para qualquer IDE (VSCode, Cursor, Trae)
- * - Apenas action + projectPath obrigatórios
- * - Auto-detecção completa de contexto
- * - Error handling inteligente com recovery
- * - Foco em produtividade individual e backup
- *
- * CORE UNIFIED TOOLS (6 ferramentas essenciais):
- * - git-workflow: Workflow completo (init, commit, sync, status, backup)
- * - git-files: Operações inteligentes de arquivo (read, write, search, update, backup-files)
- * - git-release: Sistema de release automatizado (create, version, publish, history, rollback)
- * - git-monitor: Monitoramento avançado (status, history, metrics, health, activity)
- * - git-backup: Sistema de backup inteligente (create, restore, list, auto, verify)
- * - git-branches: Gerenciamento de branches unificado
- *
- * ADVANCED TOOLS (6 ferramentas avançadas):
- * - git-remote: Gerenciamento de remotos
- * - git-stash: Operações de stash
- * - git-reset: Reset seguro
- * - git-tags: Gerenciamento de tags
- * - git-issues: Sistema de issues
- * - git-pulls: Pull requests
- *
- * SPECIALIZED TOOLS (6 ferramentas especializadas):
- * - git-analytics: Analytics e relatórios
- * - git-archive: Operações de archive
- * - git-packages: Gerenciamento de pacotes
- * - git-sync: Sincronização multi-provider
- * - git-repos: Gerenciamento de repositórios
- * - git-config: Configurações avançadas
- *
- * DIFERENCIAIS IMPLEMENTADOS:
- * - Auto-detecção universal (repo, owner, providers)
- * - Respostas estruturadas consistentes
- * - Multi-provider automático
- * - Error handling com sugestões de recovery
- * - Interface compatível com qualquer AI agent
+ * Este servidor implementa todas as 18 ferramentas Git conforme especificado
+ * no design, com auto-detecção universal e suporte multi-provider.
  */
+// Lista completa das 18 tools oficiais
 const tools = [
-    // CORE UNIFIED TOOLS (6 ferramentas essenciais) - Funcionalidades básicas
-    git_workflow_js_1.gitWorkflowTool, // Workflow unificado (init, commit, sync, status, backup)
-    git_files_js_1.gitFilesTool, // Operações inteligentes de arquivo (read, write, search, update, backup-files)
-    git_release_js_1.gitReleaseTool, // Sistema de release automatizado (create, version, publish, history, rollback)
-    git_monitor_js_1.gitMonitorTool, // Monitoramento avançado (status, history, metrics, health, activity)
-    git_backup_js_1.gitBackupTool, // Sistema de backup inteligente (create, restore, list, auto, verify)
-    git_branches_js_1.gitBranchesTool, // Gerenciamento de branches unificado
-    // ADVANCED TOOLS (6 ferramentas avançadas) - Funcionalidades avançadas
-    git_remote_js_1.gitRemoteTool, // Gerenciamento de remotos
-    git_stash_js_1.gitStashTool, // Operações de stash
-    git_reset_js_1.gitResetTool, // Reset seguro
-    git_tags_js_1.gitTagsTool, // Gerenciamento de tags
-    git_issues_js_1.gitIssuesTool, // Sistema de issues
-    git_pulls_js_1.gitPullsTool, // Pull requests
-    // SPECIALIZED TOOLS (6 ferramentas especializadas) - Funcionalidades específicas
-    git_analytics_js_1.gitAnalyticsTool, // Analytics e relatórios
-    git_archive_js_1.gitArchiveTool, // Operações de archive
-    git_packages_js_1.gitPackagesTool, // Gerenciamento de pacotes
-    git_sync_js_1.gitSyncTool, // Sincronização multi-provider
-    git_repos_js_1.gitReposTool, // Gerenciamento de repositórios
-    git_config_js_1.gitConfigTool // Configurações avançadas
+    git_workflow_js_1.gitWorkflowTool, // 1. Workflow principal (init, commit, sync, status, backup)
+    git_files_js_1.gitFilesTool, // 2. Gerenciamento de arquivos
+    git_branches_js_1.gitBranchesTool, // 3. Gerenciamento de branches
+    git_issues_js_1.gitIssuesTool, // 4. Gerenciamento de issues
+    git_pulls_js_1.gitPullsTool, // 5. Gerenciamento de pull requests
+    git_tags_js_1.gitTagsTool, // 6. Gerenciamento de tags
+    git_release_js_1.gitReleaseTool, // 7. Gerenciamento de releases
+    git_remote_js_1.gitRemoteTool, // 8. Gerenciamento de remotes
+    git_reset_js_1.gitResetTool, // 9. Operações de reset
+    git_stash_js_1.gitStashTool, // 10. Gerenciamento de stash
+    git_config_js_1.gitConfigTool, // 11. Configurações Git
+    git_monitor_js_1.gitMonitorTool, // 12. Monitoramento e logs
+    git_backup_js_1.gitBackupTool, // 13. Sistema de backup
+    git_archive_js_1.gitArchiveTool, // 14. Arquivamento
+    git_packages_js_1.gitPackagesTool, // 15. Gerenciamento de packages
+    git_analytics_js_1.gitAnalyticsTool, // 16. Analytics e estatísticas
+    git_sync_js_1.gitSyncTool, // 17. Sincronização avançada
+    git_repos_js_1.gitReposTool // 18. Gerenciamento de repositórios
 ];
-/**
- * Recursos MCP disponíveis
- *
- * RESOURCES DISPONÍVEIS:
- * - instructions: Instruções completas de uso de cada tool, action e parâmetro
- * - examples: Exemplos práticos de uso das ferramentas
- */
 const resources = [
     {
-        uri: 'mcp-git://instructions',
-        name: 'Instruções de Uso - Todas as Tools',
-        description: 'Guia completo de uso de cada ferramenta, suas actions, parâmetros obrigatórios/opcionais e funcionalidades',
+        uri: 'mcp-git://status',
+        name: 'Server Status',
+        description: 'Status atual do servidor MCP Git com todas as 18 tools',
         mimeType: 'application/json'
     },
     {
-        uri: 'mcp-git://examples',
-        name: 'Exemplos Práticos',
-        description: 'Exemplos reais de workflows, casos de uso comuns e melhores práticas de uso das ferramentas',
+        uri: 'mcp-git://tools',
+        name: 'Available Tools',
+        description: 'Lista completa das 18 ferramentas Git disponíveis',
         mimeType: 'application/json'
     }
 ];
-/**
- * Servidor MCP principal para Gitea
- *
- * RESPONSABILIDADES:
- * - Inicializar servidor MCP
- * - Registrar handlers para requests
- * - Gerenciar ciclo de vida das tools
- * - Tratar erros e validações
- *
- * ARQUITETURA:
- * - Server MCP padrão com transport stdio
- * - Handlers para list e call de tools
- * - Tratamento centralizado de erros
- *
- * RECOMENDAÇÕES:
- * - Use apenas uma instância por processo
- * - Configure handlers antes de conectar
- * - Implemente graceful shutdown
- */
 class GiteaMCPServer {
     server;
     constructor() {
         this.server = new index_js_1.Server({
             name: 'git-mcp',
-            version: '2.37.0',
+            version: '4.0.21',
+        }, {
+            capabilities: {
+                tools: {},
+                resources: {}
+            }
         });
         this.setupHandlers();
     }
-    /**
-     * Configura os handlers para requests MCP
-     *
-     * HANDLERS IMPLEMENTADOS:
-     * - ListTools: Lista todas as tools disponíveis
-     * - CallTool: Executa uma tool específica
-     *
-     * FLUXO:
-     * 1. Validação de parâmetros
-     * 2. Busca da tool solicitada
-     * 3. Execução com tratamento de erros
-     * 4. Retorno de resultado ou erro
-     *
-     * TRATAMENTO DE ERROS:
-     * - Tool não encontrada: erro específico
-     * - Erro de execução: captura e formata
-     * - Erro de validação: mensagem descritiva
-     */
     setupHandlers() {
         // Handler para listar tools disponíveis
         this.server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => {
@@ -215,13 +94,11 @@ class GiteaMCPServer {
         // Handler para executar tools específicas
         this.server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
             const { name, arguments: args } = request.params;
-            // Busca a tool solicitada
             const tool = tools.find(t => t.name === name);
             if (!tool) {
-                throw new Error(`Tool '${name}' not found`);
+                throw new Error(`Tool '${name}' not found. Available tools: ${tools.map(t => t.name).join(', ')}`);
             }
             try {
-                // Executa o handler da tool
                 const result = await tool.handler(args || {});
                 return {
                     content: [
@@ -234,8 +111,7 @@ class GiteaMCPServer {
             }
             catch (error) {
                 const errorMessage = error instanceof Error ? error.message : String(error);
-                // Retorna erro diretamente em vez de JSON.stringify
-                throw new Error(errorMessage);
+                throw new Error(`Error in ${name}: ${errorMessage}`);
             }
         });
         // Handler para listar resources disponíveis
@@ -247,574 +123,137 @@ class GiteaMCPServer {
         // Handler para ler conteúdo de resources específicos
         this.server.setRequestHandler(types_js_1.ReadResourceRequestSchema, async (request) => {
             const { uri } = request.params;
-            let content = '';
             switch (uri) {
-                case 'mcp-git://instructions':
-                    content = JSON.stringify({
-                        title: 'INSTRUÇÕES DE USO - MCP Git Tools',
-                        version: '4.0.4',
-                        totalTools: 18,
-                        description: 'Guia completo de todas as ferramentas, suas actions e parâmetros',
+                case 'mcp-git://status':
+                    const cfg = config_js_1.config.getConfig();
+                    const hasGitea = !!(cfg.giteaUrl && cfg.giteaToken);
+                    const hasGitHub = !!cfg.githubToken;
+                    const isDemoMode = process.env.DEMO_MODE === 'true';
+                    const content = JSON.stringify({
+                        title: 'MCP Git Server - Servidor Completo',
+                        version: '4.0.21',
+                        status: 'running',
+                        timestamp: new Date().toISOString(),
+                        mode: isDemoMode ? 'demo' : 'production',
+                        providers: {
+                            gitea: hasGitea ? 'configured' : 'not configured',
+                            github: hasGitHub ? 'configured' : 'not configured',
+                            demo: isDemoMode ? 'active' : 'inactive'
+                        },
                         tools: {
-                            'git-workflow': {
-                                description: 'Workflow unificado completo',
-                                actions: {
-                                    init: {
-                                        description: 'Inicialização completa do projeto',
-                                        required: ['action', 'projectPath'],
-                                        optional: ['message'],
-                                        example: '{ "action": "init", "projectPath": "/path/to/project" }'
-                                    },
-                                    commit: {
-                                        description: 'Commit com push automático',
-                                        required: ['action', 'projectPath', 'message'],
-                                        optional: [],
-                                        example: '{ "action": "commit", "projectPath": "/path/to/project", "message": "feat: new feature" }'
-                                    },
-                                    sync: {
-                                        description: 'Sincronização completa (pull + commit + push)',
-                                        required: ['action', 'projectPath'],
-                                        optional: ['message'],
-                                        example: '{ "action": "sync", "projectPath": "/path/to/project" }'
-                                    },
-                                    status: {
-                                        description: 'Status completo do projeto',
-                                        required: ['action', 'projectPath'],
-                                        optional: ['detailed'],
-                                        example: '{ "action": "status", "projectPath": "/path/to/project", "detailed": true }'
-                                    },
-                                    backup: {
-                                        description: 'Backup completo do estado atual',
-                                        required: ['action', 'projectPath'],
-                                        optional: ['description'],
-                                        example: '{ "action": "backup", "projectPath": "/path/to/project", "description": "Backup antes de mudanças" }'
-                                    }
-                                }
-                            },
-                            'git-files': {
-                                description: 'Gerenciamento inteligente de arquivos',
-                                actions: {
-                                    read: {
-                                        description: 'Ler conteúdo de arquivo',
-                                        required: ['action', 'projectPath', 'filePath'],
-                                        optional: [],
-                                        example: '{ "action": "read", "projectPath": "/path/to/project", "filePath": "src/index.ts" }'
-                                    },
-                                    write: {
-                                        description: 'Escrever arquivo com backup automático',
-                                        required: ['action', 'projectPath', 'filePath', 'content'],
-                                        optional: [],
-                                        example: '{ "action": "write", "projectPath": "/path/to/project", "filePath": "src/newfile.ts", "content": "export const hello = \'world\';" }'
-                                    },
-                                    search: {
-                                        description: 'Buscar texto no código',
-                                        required: ['action', 'projectPath', 'query'],
-                                        optional: ['path', 'caseSensitive'],
-                                        example: '{ "action": "search", "projectPath": "/path/to/project", "query": "function.*login" }'
-                                    },
-                                    update: {
-                                        description: 'Atualizar arquivo existente',
-                                        required: ['action', 'projectPath', 'filePath', 'content'],
-                                        optional: [],
-                                        example: '{ "action": "update", "projectPath": "/path/to/project", "filePath": "src/existing.ts", "content": "updated content" }'
-                                    },
-                                    'backup-files': {
-                                        description: 'Backup seletivo de arquivos',
-                                        required: ['action', 'projectPath'],
-                                        optional: ['patterns', 'description'],
-                                        example: '{ "action": "backup-files", "projectPath": "/path/to/project", "patterns": ["*.json", "*.config.*"] }'
-                                    }
-                                }
-                            },
-                            'git-release': {
-                                description: 'Sistema de release automatizado',
-                                actions: {
-                                    create: {
-                                        description: 'Criar release com changelog automático',
-                                        required: ['action', 'projectPath'],
-                                        optional: ['version', 'changelog', 'draft', 'prerelease', 'assets', 'notes'],
-                                        example: '{ "action": "create", "projectPath": "/path/to/project", "changelog": true }'
-                                    },
-                                    version: {
-                                        description: 'Incrementar versão semântica',
-                                        required: ['action', 'projectPath'],
-                                        optional: ['type'],
-                                        example: '{ "action": "version", "projectPath": "/path/to/project", "type": "minor" }'
-                                    },
-                                    publish: {
-                                        description: 'Publicar release',
-                                        required: ['action', 'projectPath'],
-                                        optional: ['providers'],
-                                        example: '{ "action": "publish", "projectPath": "/path/to/project" }'
-                                    },
-                                    history: {
-                                        description: 'Histórico de releases',
-                                        required: ['action', 'projectPath'],
-                                        optional: ['limit', 'includeDrafts'],
-                                        example: '{ "action": "history", "projectPath": "/path/to/project", "limit": 10 }'
-                                    },
-                                    rollback: {
-                                        description: 'Rollback de release',
-                                        required: ['action', 'projectPath'],
-                                        optional: ['createBackup'],
-                                        example: '{ "action": "rollback", "projectPath": "/path/to/project", "createBackup": true }'
-                                    }
-                                }
-                            },
-                            'git-monitor': {
-                                description: 'Monitoramento e analytics',
-                                actions: {
-                                    status: {
-                                        description: 'Status detalhado com métricas',
-                                        required: ['action', 'projectPath'],
-                                        optional: ['includeMetrics', 'detailed'],
-                                        example: '{ "action": "status", "projectPath": "/path/to/project", "includeMetrics": true }'
-                                    },
-                                    history: {
-                                        description: 'Histórico de atividades',
-                                        required: ['action', 'projectPath'],
-                                        optional: ['since', 'limit', 'type'],
-                                        example: '{ "action": "history", "projectPath": "/path/to/project", "since": "2024-01-01" }'
-                                    },
-                                    metrics: {
-                                        description: 'Métricas de produtividade',
-                                        required: ['action', 'projectPath'],
-                                        optional: ['period', 'includeCharts'],
-                                        example: '{ "action": "metrics", "projectPath": "/path/to/project", "period": "30d" }'
-                                    },
-                                    health: {
-                                        description: 'Análise de saúde do projeto',
-                                        required: ['action', 'projectPath'],
-                                        optional: ['deep', 'suggestions'],
-                                        example: '{ "action": "health", "projectPath": "/path/to/project", "deep": true }'
-                                    },
-                                    activity: {
-                                        description: 'Atividade recente',
-                                        required: ['action', 'projectPath'],
-                                        optional: ['hours', 'includeRemote'],
-                                        example: '{ "action": "activity", "projectPath": "/path/to/project", "hours": 24 }'
-                                    }
-                                }
-                            },
-                            'git-backup': {
-                                description: 'Sistema de backup inteligente',
-                                actions: {
-                                    create: {
-                                        description: 'Criar backup',
-                                        required: ['action', 'projectPath'],
-                                        optional: ['type', 'name', 'includeUntracked', 'compress'],
-                                        example: '{ "action": "create", "projectPath": "/path/to/project", "type": "full" }'
-                                    },
-                                    restore: {
-                                        description: 'Restaurar backup',
-                                        required: ['action', 'projectPath', 'backupId'],
-                                        optional: ['preview', 'force', 'targetPath'],
-                                        example: '{ "action": "restore", "projectPath": "/path/to/project", "backupId": "backup-2024-01-01", "preview": true }'
-                                    },
-                                    list: {
-                                        description: 'Listar backups',
-                                        required: ['action', 'projectPath'],
-                                        optional: ['filter', 'limit', 'sortBy'],
-                                        example: '{ "action": "list", "projectPath": "/path/to/project", "filter": "full" }'
-                                    },
-                                    auto: {
-                                        description: 'Backup automático',
-                                        required: ['action', 'projectPath'],
-                                        optional: ['enabled', 'schedule', 'retention', 'maxBackups'],
-                                        example: '{ "action": "auto", "projectPath": "/path/to/project", "enabled": true, "schedule": "daily" }'
-                                    },
-                                    verify: {
-                                        description: 'Verificar integridade',
-                                        required: ['action', 'projectPath', 'backupId'],
-                                        optional: ['deep'],
-                                        example: '{ "action": "verify", "projectPath": "/path/to/project", "backupId": "backup-2024-01-01" }'
-                                    }
-                                }
-                            },
-                            'git-branches': {
-                                description: 'Gerenciamento de branches',
-                                actions: {
-                                    create: {
-                                        description: 'Criar nova branch',
-                                        required: ['action', 'projectPath', 'name'],
-                                        optional: ['from'],
-                                        example: '{ "action": "create", "projectPath": "/path/to/project", "name": "feature/new-feature" }'
-                                    },
-                                    list: {
-                                        description: 'Listar branches',
-                                        required: ['action', 'projectPath'],
-                                        optional: ['remote'],
-                                        example: '{ "action": "list", "projectPath": "/path/to/project", "remote": true }'
-                                    },
-                                    switch: {
-                                        description: 'Trocar de branch',
-                                        required: ['action', 'projectPath', 'name'],
-                                        optional: ['create'],
-                                        example: '{ "action": "switch", "projectPath": "/path/to/project", "name": "main" }'
-                                    },
-                                    delete: {
-                                        description: 'Remover branch',
-                                        required: ['action', 'projectPath', 'name'],
-                                        optional: ['force'],
-                                        example: '{ "action": "delete", "projectPath": "/path/to/project", "name": "old-branch" }'
-                                    },
-                                    merge: {
-                                        description: 'Merge de branches',
-                                        required: ['action', 'projectPath', 'branch'],
-                                        optional: ['strategy', 'noCommit'],
-                                        example: '{ "action": "merge", "projectPath": "/path/to/project", "branch": "feature/complete", "strategy": "squash" }'
-                                    },
-                                    compare: {
-                                        description: 'Comparar branches',
-                                        required: ['action', 'projectPath', 'base', 'head'],
-                                        optional: ['detailed'],
-                                        example: '{ "action": "compare", "projectPath": "/path/to/project", "base": "main", "head": "feature/new" }'
-                                    }
-                                }
-                            }
+                            total: tools.length,
+                            available: tools.map(t => t.name)
                         },
-                        importantNotes: {
-                            'universalParameters': 'Todas as ferramentas requerem apenas "action" + "projectPath"',
-                            'autoDetection': 'Repo, owner e providers são detectados automaticamente',
-                            'errorHandling': 'Todas as ferramentas têm error handling inteligente com sugestões',
-                            'multiProvider': 'Suporte automático a Gitea e GitHub quando configurados'
-                        }
+                        features: [
+                            'Auto-detecção universal',
+                            'Multi-provider (Gitea + GitHub)',
+                            'Interface universal para IA',
+                            'Error handling inteligente',
+                            '18 ferramentas Git completas'
+                        ]
                     }, null, 2);
-                    break;
-                case 'mcp-git://examples':
-                    content = JSON.stringify({
-                        title: 'EXEMPLOS PRÁTICOS - MCP Git Tools',
-                        version: '4.0.4',
-                        description: 'Exemplos reais de uso das ferramentas',
-                        workflows: {
-                            'daily-workflow': {
-                                description: 'Workflow diário de desenvolvimento',
-                                steps: [
-                                    {
-                                        description: 'Sincronizar com mudanças do time',
-                                        tool: 'git-workflow',
-                                        action: 'sync',
-                                        params: { action: 'sync', projectPath: '/path/to/project' }
-                                    },
-                                    {
-                                        description: 'Ver status do projeto',
-                                        tool: 'git-workflow',
-                                        action: 'status',
-                                        params: { action: 'status', projectPath: '/path/to/project', detailed: true }
-                                    },
-                                    {
-                                        description: 'Implementar nova funcionalidade',
-                                        tool: 'git-files',
-                                        action: 'write',
-                                        params: {
-                                            action: 'write',
-                                            projectPath: '/path/to/project',
-                                            filePath: 'src/new-feature.ts',
-                                            content: 'export function newFeature() { return "Hello World"; }'
-                                        }
-                                    },
-                                    {
-                                        description: 'Commit das mudanças',
-                                        tool: 'git-workflow',
-                                        action: 'commit',
-                                        params: {
-                                            action: 'commit',
-                                            projectPath: '/path/to/project',
-                                            message: 'feat: Implementar nova funcionalidade\n\n- Adicionar função newFeature\n- Export da função\n- Documentação básica'
-                                        }
-                                    }
-                                ]
-                            },
-                            'feature-development': {
-                                description: 'Desenvolvimento completo de uma feature',
-                                steps: [
-                                    {
-                                        description: 'Criar branch da feature',
-                                        tool: 'git-branches',
-                                        action: 'create',
-                                        params: { action: 'create', projectPath: '/path/to/project', name: 'feature/user-auth' }
-                                    },
-                                    {
-                                        description: 'Implementar autenticação',
-                                        tool: 'git-files',
-                                        action: 'write',
-                                        params: {
-                                            action: 'write',
-                                            projectPath: '/path/to/project',
-                                            filePath: 'src/auth/login.ts',
-                                            content: 'export function login(email: string, password: string) { /* auth logic */ }'
-                                        }
-                                    },
-                                    {
-                                        description: 'Verificar TODOs/FIXMEs',
-                                        tool: 'git-issues',
-                                        action: 'scan',
-                                        params: { action: 'scan', projectPath: '/path/to/project', createIssues: true }
-                                    },
-                                    {
-                                        description: 'Commit da implementação',
-                                        tool: 'git-workflow',
-                                        action: 'commit',
-                                        params: {
-                                            action: 'commit',
-                                            projectPath: '/path/to/project',
-                                            message: 'feat: Implementar sistema de autenticação\n\n- Função login\n- Validação de credenciais\n- Tratamento de erros'
-                                        }
-                                    },
-                                    {
-                                        description: 'Merge na branch principal',
-                                        tool: 'git-branches',
-                                        action: 'merge',
-                                        params: { action: 'merge', projectPath: '/path/to/project', branch: 'feature/user-auth' }
-                                    }
-                                ]
-                            },
-                            'release-process': {
-                                description: 'Processo completo de release',
-                                steps: [
-                                    {
-                                        description: 'Verificar saúde pré-release',
-                                        tool: 'git-monitor',
-                                        action: 'health',
-                                        params: { action: 'health', projectPath: '/path/to/project', deep: true }
-                                    },
-                                    {
-                                        description: 'Criar backup estratégico',
-                                        tool: 'git-workflow',
-                                        action: 'backup',
-                                        params: { action: 'backup', projectPath: '/path/to/project', description: 'Backup pré-release v2.0.0' }
-                                    },
-                                    {
-                                        description: 'Incrementar versão',
-                                        tool: 'git-release',
-                                        action: 'version',
-                                        params: { action: 'version', projectPath: '/path/to/project', type: 'minor' }
-                                    },
-                                    {
-                                        description: 'Criar release completo',
-                                        tool: 'git-release',
-                                        action: 'create',
-                                        params: {
-                                            action: 'create',
-                                            projectPath: '/path/to/project',
-                                            changelog: true,
-                                            notes: 'Release v2.0.0 com novas funcionalidades',
-                                            assets: ['dist/bundle.js', 'dist/styles.css']
-                                        }
-                                    }
-                                ]
+                    return {
+                        contents: [
+                            {
+                                uri,
+                                mimeType: 'application/json',
+                                text: content
                             }
-                        },
-                        commonUseCases: {
-                            'create-component': {
-                                description: 'Criar novo componente React',
-                                example: {
-                                    tool: 'git-files',
-                                    action: 'write',
-                                    params: {
-                                        action: 'write',
-                                        projectPath: 'C:\\projetos\\react-app',
-                                        filePath: 'src/components/UserProfile.tsx',
-                                        content: 'import React from \'react\';\n\nexport const UserProfile: React.FC = () => {\n  return (\n    <div className="user-profile">\n      <h2>User Profile</h2>\n    </div>\n  );\n};'
-                                    }
-                                }
-                            },
-                            'daily-commit': {
-                                description: 'Commit diário das mudanças',
-                                example: {
-                                    tool: 'git-workflow',
-                                    action: 'commit',
-                                    params: {
-                                        action: 'commit',
-                                        projectPath: 'C:\\projetos\\api-backend',
-                                        message: 'feat: Implementar autenticação JWT\n\n- Middleware de validação de tokens\n- Endpoint POST /auth/login\n- Endpoint POST /auth/refresh\n- Tests unitários para auth\n- Documentação da API'
-                                    }
-                                }
-                            },
-                            'backup-before-changes': {
-                                description: 'Backup antes de mudanças arriscadas',
-                                example: {
-                                    tool: 'git-workflow',
-                                    action: 'backup',
-                                    params: {
-                                        action: 'backup',
-                                        projectPath: 'C:\\projetos\\critical-app',
-                                        description: 'Backup antes de refatoração da arquitetura principal'
-                                    }
-                                }
-                            },
-                            'search-code': {
-                                description: 'Buscar funções específicas no código',
-                                example: {
-                                    tool: 'git-files',
-                                    action: 'search',
-                                    params: {
-                                        action: 'search',
-                                        projectPath: 'C:\\projetos\\large-app',
-                                        query: 'function.*validate.*email|const.*emailRegex',
-                                        caseSensitive: false
-                                    }
-                                }
-                            },
-                            'health-check': {
-                                description: 'Verificar saúde do projeto',
-                                example: {
-                                    tool: 'git-monitor',
-                                    action: 'health',
-                                    params: {
-                                        action: 'health',
-                                        projectPath: 'C:\\projetos\\my-project',
-                                        deep: true,
-                                        suggestions: true
-                                    }
-                                }
-                            },
-                            'feature-branch-workflow': {
-                                description: 'Workflow completo com feature branch',
-                                steps: [
-                                    { tool: 'git-branches', action: 'create', params: { action: 'create', projectPath: '/project', name: 'feature/new-ui' } },
-                                    { tool: 'git-files', action: 'write', params: { action: 'write', projectPath: '/project', filePath: 'src/ui/new-component.tsx', content: '...' } },
-                                    { tool: 'git-workflow', action: 'commit', params: { action: 'commit', projectPath: '/project', message: 'feat: New UI component' } },
-                                    { tool: 'git-branches', action: 'merge', params: { action: 'merge', projectPath: '/project', branch: 'feature/new-ui' } },
-                                    { tool: 'git-branches', action: 'delete', params: { action: 'delete', projectPath: '/project', name: 'feature/new-ui' } }
-                                ]
+                        ]
+                    };
+                case 'mcp-git://tools':
+                    const toolsInfo = JSON.stringify({
+                        title: 'Ferramentas Git Disponíveis',
+                        total: tools.length,
+                        tools: tools.map(tool => ({
+                            name: tool.name,
+                            description: tool.description,
+                            category: this.getToolCategory(tool.name)
+                        })),
+                        usage: {
+                            pattern: 'Universal: action + projectPath',
+                            example: {
+                                action: 'status',
+                                projectPath: '/path/to/project'
                             }
                         }
                     }, null, 2);
-                    break;
+                    return {
+                        contents: [
+                            {
+                                uri,
+                                mimeType: 'application/json',
+                                text: toolsInfo
+                            }
+                        ]
+                    };
                 default:
-                    throw new Error(`Resource not found: ${uri}`);
+                    throw new Error(`Resource '${uri}' not found`);
             }
-            return {
-                contents: [
-                    {
-                        uri: uri,
-                        mimeType: 'application/json',
-                        text: content
-                    }
-                ]
-            };
         });
     }
-    /**
-     * Inicializa e executa o servidor MCP
-     *
-     * FLUXO DE INICIALIZAÇÃO:
-     * 1. Validação de configuração
-     * 2. Verificação de token obrigatório
-     * 3. Conexão com transport stdio
-     * 4. Log de status e debug
-     *
-     * VALIDAÇÕES:
-     * - Token de autenticação obrigatório
-     * - URL do Gitea válida
-     * - Configuração de debug opcional
-     *
-     * RECOMENDAÇÕES:
-     * - Configure DEBUG=true para desenvolvimento
-     * - Valide token antes de iniciar
-     * - Configure timeout adequado
-     */
+    getToolCategory(toolName) {
+        const categories = {
+            'git-workflow': 'Workflow Principal',
+            'git-files': 'Gerenciamento de Arquivos',
+            'git-branches': 'Branches',
+            'git-issues': 'Issues',
+            'git-pulls': 'Pull Requests',
+            'git-tags': 'Tags',
+            'git-release': 'Releases',
+            'git-remote': 'Remotes',
+            'git-reset': 'Reset',
+            'git-stash': 'Stash',
+            'git-config': 'Configuração',
+            'git-monitor': 'Monitoramento',
+            'git-backup': 'Backup',
+            'git-archive': 'Arquivamento',
+            'git-packages': 'Packages',
+            'git-analytics': 'Analytics',
+            'git-sync': 'Sincronização',
+            'git-repos': 'Repositórios'
+        };
+        return categories[toolName] || 'Geral';
+    }
     async run() {
         const cfg = config_js_1.config.getConfig();
-        if (cfg.debug) {
-            // Server starting - debug info removed for MCP protocol compliance
+        // Ativar modo demo automaticamente se não há configuração
+        if (!cfg.giteaUrl && !cfg.githubToken && !cfg.apiUrl) {
+            process.env.DEMO_MODE = 'true';
+            console.error('[SERVER] No provider configuration found. Enabling demo mode automatically.');
         }
-        // Inicializar provider factory com configuração
+        // Inicializar provider factory
         try {
-            // console.log('[SERVER] Inicializando provider factory...');
             const factory = (0, index_js_2.initializeFactoryFromEnv)();
-            // Log detalhado dos providers configurados
-            try {
-                const providersInfo = factory.getProvidersInfo();
-                // console.log('[SERVER] Providers configurados:');
-                // providersInfo.forEach(p => {
-                //   console.log(`  - ${p.name} (${p.type}) ${p.isDefault ? '[PADRÃO]' : ''}`);
-                // });
-            }
-            catch (infoError) {
-                // console.log('[SERVER] Não foi possível obter informações detalhadas dos providers');
-            }
-            // Atualizar o globalProviderFactory com a configuração
             Object.assign(index_js_2.globalProviderFactory, factory);
-            // console.log('[SERVER] Provider factory inicializado com sucesso');
+            console.error('[SERVER] Provider factory initialized successfully');
         }
         catch (error) {
-            console.error('[SERVER] Erro ao inicializar providers:', error);
-            // Tenta criar um provider fallback se houver falha completa
-            try {
-                // console.log('[SERVER] Tentando criar provider fallback...');
-                // Criar provider GitHub básico como fallback
-                const fallbackConfig = {
-                    name: 'github-fallback',
-                    type: 'github',
-                    apiUrl: 'https://api.github.com',
-                    baseUrl: 'https://github.com',
-                    token: process.env.GITHUB_TOKEN || 'dummy_token',
-                    username: process.env.GITHUB_USERNAME
-                };
-                const fallbackProvider = index_js_2.globalProviderFactory.createProvider(fallbackConfig);
-                index_js_2.globalProviderFactory.setDefaultProvider('github-fallback');
-                // console.log('[SERVER] Provider fallback criado com sucesso');
-            }
-            catch (fallbackError) {
-                console.error('[SERVER] Falha ao criar provider fallback:', fallbackError);
-                // Continua sem provider - algumas tools podem não funcionar
-            }
+            process.env.DEMO_MODE = 'true';
+            console.error('[SERVER] Provider initialization failed, using demo mode');
         }
         const transport = new stdio_js_1.StdioServerTransport();
         await this.server.connect(transport);
-        if (cfg.debug) {
-            // Server connected and ready
-        }
+        // Log de inicialização
+        console.error(`[SERVER] MCP Git server v4.0.21 started successfully`);
+        console.error(`[SERVER] Mode: ${process.env.DEMO_MODE === 'true' ? 'Demo' : 'Production'}`);
+        console.error(`[SERVER] Tools available: ${tools.length}`);
+        console.error(`[SERVER] Ready for AI agent integration`);
     }
-    /**
-     * Fecha o servidor MCP graciosamente
-     *
-     * USO:
-     * - Durante shutdown da aplicação
-     * - Para limpeza de recursos
-     * - Para finalização controlada
-     *
-     * RECOMENDAÇÕES:
-     * - Sempre chame antes de sair
-     * - Aguarde a conclusão da operação
-     * - Trate erros de fechamento
-     */
     async close() {
         await this.server.close();
     }
 }
 exports.GiteaMCPServer = GiteaMCPServer;
-/**
- * Handlers para sinais do sistema
- *
- * SINAIS TRATADOS:
- * - SIGINT: Interrupção do usuário (Ctrl+C)
- * - unhandledRejection: Promises rejeitadas
- * - uncaughtException: Exceções não tratadas
- *
- * COMPORTAMENTO:
- * - SIGINT: Shutdown gracioso
- * - Erros não tratados: Exit com código 1
- * - Log de erro antes de sair
- *
- * RECOMENDAÇÕES:
- * - Implemente graceful shutdown
- * - Log todos os erros fatais
- * - Use códigos de saída apropriados
- */
-// Handler para interrupção do usuário (Ctrl+C)
+// Handlers para sinais do sistema
 process.on('SIGINT', async () => {
-    // Shutting down server
+    console.error('[SERVER] Shutting down gracefully...');
     process.exit(0);
 });
-// Handler para promises rejeitadas não tratadas
 process.on('unhandledRejection', (reason, promise) => {
     console.error('Unhandled Rejection at:', promise, 'reason:', reason);
     process.exit(1);
 });
-// Handler para exceções não tratadas
 process.on('uncaughtException', (error) => {
     console.error('Uncaught Exception:', error);
     process.exit(1);