@andrebuzeli/git-mcp 4.0.20 → 4.0.21

package/dist/tools/git-monitor.js

@@ -1,748 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.gitMonitorTool = void 0;
-const zod_1 = require("zod");
 const auto_detection_js_1 = require("../utils/auto-detection.js");
-const error_handler_js_1 = require("../utils/error-handler.js");
-const git_operations_js_1 = require("../utils/git-operations.js");
-/**
- * Tool: git-monitor
- *
- * SISTEMA DE MONITORAMENTO AVANÇADO
- * Status completo, métricas de produtividade, análise de saúde do projeto
- *
- * DESIGNED FOR: Programador individual autônomo
- * PHILOSOPHY: Monitoramento inteligente em uma única ferramenta
- */
-const GitMonitorInputSchema = zod_1.z.discriminatedUnion('action', [
-    // PROJECT STATUS - Visão completa
-    zod_1.z.object({
-        action: zod_1.z.literal('status'),
-        projectPath: zod_1.z.string(),
-        detailed: zod_1.z.boolean().default(true),
-        includeMetrics: zod_1.z.boolean().default(true)
-    }),
-    // ACTIVITY HISTORY - Histórico detalhado
-    zod_1.z.object({
-        action: zod_1.z.literal('history'),
-        projectPath: zod_1.z.string(),
-        since: zod_1.z.string().optional(), // ISO date or relative (1d, 1w, 1m)
-        limit: zod_1.z.number().default(50),
-        type: zod_1.z.enum(['all', 'commits', 'releases', 'issues']).default('all')
-    }),
-    // PRODUCTIVITY METRICS - Métricas de produtividade
-    zod_1.z.object({
-        action: zod_1.z.literal('metrics'),
-        projectPath: zod_1.z.string(),
-        period: zod_1.z.string().default('30d'), // 1d, 7d, 30d, 90d
-        includeCharts: zod_1.z.boolean().default(false)
-    }),
-    // PROJECT HEALTH - Saúde geral
-    zod_1.z.object({
-        action: zod_1.z.literal('health'),
-        projectPath: zod_1.z.string(),
-        deep: zod_1.z.boolean().default(false), // Análise profunda
-        suggestions: zod_1.z.boolean().default(true)
-    }),
-    // RECENT ACTIVITY - Atividade recente
-    zod_1.z.object({
-        action: zod_1.z.literal('activity'),
-        projectPath: zod_1.z.string(),
-        hours: zod_1.z.number().default(24),
-        includeRemote: zod_1.z.boolean().default(true)
-    })
-]);
-/**
- * Project Status Analyzer
- * Analisa o status completo do projeto
- */
-class ProjectStatusAnalyzer {
-    static async getBasicStatus(projectPath) {
-        const gitOps = new git_operations_js_1.GitOperations(projectPath);
-        try {
-            // Git status
-            const statusResult = await gitOps.status({});
-            const isGitRepo = statusResult.success;
-            if (!isGitRepo) {
-                return {
-                    isGitRepo: false,
-                    status: 'not_initialized',
-                    message: 'Projeto não é um repositório Git'
-                };
-            }
-            // Branch info
-            const branchResult = await gitOps.runCommand('git', ['branch', '--show-current']);
-            const currentBranch = branchResult.success ? branchResult.output.trim() : 'unknown';
-            // Remote info
-            const remoteResult = await gitOps.runCommand('git', ['remote', '-v']);
-            const hasRemotes = remoteResult.success && remoteResult.output.trim();
-            // Recent commits
-            const logResult = await gitOps.runCommand('git', ['log', '--oneline', '-5']);
-            const recentCommits = logResult.success ?
-                logResult.output.trim().split('\n').filter(line => line.trim()) : [];
-            // Uncommitted changes
-            const changesResult = await gitOps.runCommand('git', ['status', '--porcelain']);
-            const hasChanges = changesResult.success && changesResult.output.trim();
-            return {
-                isGitRepo: true,
-                currentBranch: currentBranch,
-                hasRemotes: hasRemotes,
-                recentCommits: recentCommits,
-                hasUncommittedChanges: hasChanges,
-                lastCommit: recentCommits.length > 0 ? recentCommits[0] : null
-            };
-        }
-        catch (error) {
-            return {
-                isGitRepo: false,
-                error: error instanceof Error ? error.message : String(error)
-            };
-        }
-    }
-    static async getDetailedMetrics(projectPath) {
-        const gitOps = new git_operations_js_1.GitOperations(projectPath);
-        try {
-            // Commit statistics
-            const commitStats = await this.getCommitStats(gitOps);
-            // File statistics
-            const fileStats = await this.getFileStats(gitOps);
-            // Branch statistics
-            const branchStats = await this.getBranchStats(gitOps);
-            // Size metrics
-            const sizeStats = await this.getSizeStats(projectPath);
-            return {
-                commits: commitStats,
-                files: fileStats,
-                branches: branchStats,
-                size: sizeStats,
-                calculatedAt: new Date().toISOString()
-            };
-        }
-        catch (error) {
-            return {
-                error: error instanceof Error ? error.message : String(error)
-            };
-        }
-    }
-    static async getCommitStats(gitOps) {
-        try {
-            // Total commits
-            const totalResult = await gitOps.runCommand('git', ['rev-list', '--count', 'HEAD']);
-            const totalCommits = totalResult.success ? parseInt(totalResult.output.trim()) : 0;
-            // Commits this month
-            const monthResult = await gitOps.runCommand('git', ['rev-list', '--count', '--since=30.days', 'HEAD']);
-            const commitsThisMonth = monthResult.success ? parseInt(monthResult.output.trim()) : 0;
-            // Commits this week
-            const weekResult = await gitOps.runCommand('git', ['rev-list', '--count', '--since=7.days', 'HEAD']);
-            const commitsThisWeek = weekResult.success ? parseInt(weekResult.output.trim()) : 0;
-            // Author stats
-            const authorResult = await gitOps.runCommand('git', ['shortlog', '-sn', '--no-merges']);
-            const authors = authorResult.success ?
-                authorResult.output.trim().split('\n').map(line => {
-                    const match = line.trim().match(/(\d+)\s+(.+)/);
-                    return match ? { commits: parseInt(match[1]), author: match[2] } : null;
-                }).filter(Boolean) : [];
-            return {
-                total: totalCommits,
-                thisMonth: commitsThisMonth,
-                thisWeek: commitsThisWeek,
-                authors: authors,
-                avgPerDay: totalCommits / 30 // Rough estimate
-            };
-        }
-        catch (error) {
-            return { error: 'Could not get commit stats' };
-        }
-    }
-    static async getFileStats(gitOps) {
-        try {
-            // File count
-            const fileCountResult = await gitOps.runCommand('git', ['ls-files']);
-            const totalFiles = fileCountResult.success ?
-                fileCountResult.output.trim().split('\n').filter(line => line.trim()).length : 0;
-            // File types
-            const fileTypeResult = await gitOps.runCommand('git', ['ls-files', '|', 'sed', 's/.*\\.//']);
-            const fileTypes = fileTypeResult.success ?
-                fileTypeResult.output.trim().split('\n')
-                    .filter(line => line.trim() && line.includes('.'))
-                    .map(line => line.split('.').pop())
-                    .reduce((acc, type) => {
-                    acc[type] = (acc[type] || 0) + 1;
-                    return acc;
-                }, {}) : {};
-            return {
-                total: totalFiles,
-                byType: fileTypes
-            };
-        }
-        catch (error) {
-            return { error: 'Could not get file stats' };
-        }
-    }
-    static async getBranchStats(gitOps) {
-        try {
-            // All branches
-            const branchResult = await gitOps.runCommand('git', ['branch', '-a']);
-            const branches = branchResult.success ?
-                branchResult.output.trim().split('\n')
-                    .map(line => line.trim().replace(/^\*\s*/, ''))
-                    .filter(line => line && !line.startsWith('remotes/')) : [];
-            // Remote branches
-            const remoteBranchResult = await gitOps.runCommand('git', ['branch', '-r']);
-            const remoteBranches = remoteBranchResult.success ?
-                remoteBranchResult.output.trim().split('\n')
-                    .map(line => line.trim())
-                    .filter(line => line) : [];
-            return {
-                local: branches.length,
-                remote: remoteBranches.length,
-                total: branches.length + remoteBranches.length,
-                branches: branches.slice(0, 10) // Top 10
-            };
-        }
-        catch (error) {
-            return { error: 'Could not get branch stats' };
-        }
-    }
-    static async getSizeStats(projectPath) {
-        const gitOps = new git_operations_js_1.GitOperations(projectPath);
-        try {
-            // Repository size
-            const sizeResult = await gitOps.runCommand('git', ['count-objects', '-v']);
-            const sizeData = sizeResult.success ? {} : {};
-            // Working directory size (rough estimate)
-            const duResult = await gitOps.runCommand('du', ['-sh', '.']);
-            const workDirSize = duResult.success ? duResult.output.trim().split('\t')[0] : 'unknown';
-            return {
-                repository: sizeData,
-                workingDirectory: workDirSize
-            };
-        }
-        catch (error) {
-            return { error: 'Could not get size stats' };
-        }
-    }
-}
-/**
- * Productivity Metrics Calculator
- * Calcula métricas de produtividade baseadas em dados Git
- */
-class ProductivityMetrics {
-    static async calculateMetrics(projectPath, period) {
-        const gitOps = new git_operations_js_1.GitOperations(projectPath);
-        try {
-            // Parse period
-            const days = this.parsePeriod(period);
-            // Commit frequency
-            const commitFreq = await this.getCommitFrequency(gitOps, days);
-            // Code churn (lines added/removed)
-            const codeChurn = await this.getCodeChurn(gitOps, days);
-            // File changes
-            const fileChanges = await this.getFileChanges(gitOps, days);
-            // Working hours (rough estimate based on commit times)
-            const workingHours = await this.estimateWorkingHours(gitOps, days);
-            return {
-                period: period,
-                days: days,
-                commitFrequency: commitFreq,
-                codeChurn: codeChurn,
-                fileChanges: fileChanges,
-                estimatedWorkingHours: workingHours,
-                calculatedAt: new Date().toISOString()
-            };
-        }
-        catch (error) {
-            return { error: 'Could not calculate metrics' };
-        }
-    }
-    static parsePeriod(period) {
-        const match = period.match(/^(\d+)([dwmy])$/);
-        if (!match)
-            return 30; // default 30 days
-        const value = parseInt(match[1]);
-        const unit = match[2];
-        switch (unit) {
-            case 'd': return value;
-            case 'w': return value * 7;
-            case 'm': return value * 30;
-            case 'y': return value * 365;
-            default: return 30;
-        }
-    }
-    static async getCommitFrequency(gitOps, days) {
-        try {
-            const result = await gitOps.runCommand('git', ['log', `--since=${days}.days.ago`, '--oneline']);
-            const commits = result.success ?
-                result.output.trim().split('\n').filter(line => line.trim()) : [];
-            return {
-                total: commits.length,
-                perDay: commits.length / days,
-                perWeek: commits.length / (days / 7),
-                trend: commits.length > 0 ? 'active' : 'inactive'
-            };
-        }
-        catch (error) {
-            return { error: 'Could not calculate commit frequency' };
-        }
-    }
-    static async getCodeChurn(gitOps, days) {
-        try {
-            const result = await gitOps.runCommand('git', ['log', `--since=${days}.days.ago`, '--numstat']);
-            const lines = result.success ? result.output.trim().split('\n') : [];
-            let added = 0;
-            let removed = 0;
-            lines.forEach(line => {
-                const match = line.match(/^(\d+)\s+(\d+)/);
-                if (match) {
-                    added += parseInt(match[1]);
-                    removed += parseInt(match[2]);
-                }
-            });
-            return {
-                linesAdded: added,
-                linesRemoved: removed,
-                linesChanged: added + removed,
-                netChange: added - removed
-            };
-        }
-        catch (error) {
-            return { error: 'Could not calculate code churn' };
-        }
-    }
-    static async getFileChanges(gitOps, days) {
-        try {
-            const result = await gitOps.runCommand('git', ['log', `--since=${days}.days.ago`, '--name-status']);
-            const lines = result.success ? result.output.trim().split('\n') : [];
-            const fileChanges = {};
-            lines.forEach(line => {
-                const match = line.match(/^([AMD])\s+(.+)/);
-                if (match) {
-                    const action = match[1];
-                    const file = match[2];
-                    fileChanges[file] = action;
-                }
-            });
-            const changeTypes = {
-                added: Object.values(fileChanges).filter(action => action === 'A').length,
-                modified: Object.values(fileChanges).filter(action => action === 'M').length,
-                deleted: Object.values(fileChanges).filter(action => action === 'D').length
-            };
-            return {
-                totalFiles: Object.keys(fileChanges).length,
-                byType: changeTypes,
-                mostChangedFile: Object.keys(fileChanges)[0] || null
-            };
-        }
-        catch (error) {
-            return { error: 'Could not calculate file changes' };
-        }
-    }
-    static async estimateWorkingHours(gitOps, days) {
-        try {
-            // Get commit times
-            const result = await gitOps.runCommand('git', ['log', `--since=${days}.days.ago`, '--format=%ai']);
-            const timestamps = result.success ?
-                result.output.trim().split('\n')
-                    .filter(line => line.trim())
-                    .map(line => new Date(line)) : [];
-            if (timestamps.length === 0) {
-                return { total: 0, perDay: 0 };
-            }
-            // Group by day
-            const daysMap = {};
-            timestamps.forEach(timestamp => {
-                const day = timestamp.toDateString();
-                if (!daysMap[day]) {
-                    daysMap[day] = [];
-                }
-                daysMap[day].push(timestamp.getHours() + timestamp.getMinutes() / 60);
-            });
-            // Estimate hours per day (rough heuristic)
-            let totalHours = 0;
-            Object.values(daysMap).forEach((dayCommits) => {
-                if (dayCommits.length > 0) {
-                    const sorted = dayCommits.sort((a, b) => a - b);
-                    const span = sorted[sorted.length - 1] - sorted[0];
-                    // Assume minimum 1 hour if there are commits, max 8 hours
-                    totalHours += Math.max(1, Math.min(span, 8));
-                }
-            });
-            return {
-                total: Math.round(totalHours * 10) / 10,
-                perDay: Math.round((totalHours / days) * 10) / 10,
-                activeDays: Object.keys(daysMap).length
-            };
-        }
-        catch (error) {
-            return { error: 'Could not estimate working hours' };
-        }
-    }
-}
-/**
- * Health Analyzer
- * Avalia a saúde geral do projeto
- */
-class HealthAnalyzer {
-    static async analyzeHealth(projectPath, deep = false) {
-        try {
-            const basicStatus = await ProjectStatusAnalyzer.getBasicStatus(projectPath);
-            const metrics = deep ? await ProjectStatusAnalyzer.getDetailedMetrics(projectPath) : null;
-            // Calculate health score
-            let healthScore = 100;
-            const issues = [];
-            const suggestions = [];
-            // Basic checks
-            if (!basicStatus.isGitRepo) {
-                healthScore -= 50;
-                issues.push('Projeto não é um repositório Git');
-                suggestions.push('Inicialize o Git: git init');
-            }
-            if (!basicStatus.hasRemotes) {
-                healthScore -= 20;
-                issues.push('Nenhum remote configurado');
-                suggestions.push('Configure um remote: git remote add origin <url>');
-            }
-            if (basicStatus.hasUncommittedChanges) {
-                healthScore -= 10;
-                issues.push('Há mudanças não commitadas');
-                suggestions.push('Commite as mudanças: git add . && git commit -m "message"');
-            }
-            if (metrics) {
-                // Deep analysis
-                if (metrics.commits?.thisWeek === 0) {
-                    healthScore -= 15;
-                    issues.push('Nenhuma atividade esta semana');
-                    suggestions.push('Continue desenvolvendo ativamente');
-                }
-                if (metrics.branches?.total > 10) {
-                    healthScore -= 10;
-                    issues.push('Muitos branches ativos');
-                    suggestions.push('Limpe branches antigos: git branch -d <branch>');
-                }
-            }
-            return {
-                score: Math.max(0, healthScore),
-                status: healthScore >= 80 ? 'excellent' : healthScore >= 60 ? 'good' : healthScore >= 40 ? 'fair' : 'poor',
-                issues: issues,
-                suggestions: suggestions,
-                analyzedAt: new Date().toISOString(),
-                deepAnalysis: deep
-            };
-        }
-        catch (error) {
-            return {
-                score: 0,
-                status: 'error',
-                issues: ['Erro na análise de saúde'],
-                suggestions: ['Verifique se o projeto existe e é acessível'],
-                error: error instanceof Error ? error.message : String(error)
-            };
-        }
-    }
-}
-/**
- * Classe principal para executar operações Git monitor
- */
-class GitMonitorExecutor {
-    errorHandler = new error_handler_js_1.UniversalErrorHandler();
-    /**
-     * Executa operação status
-     */
-    async executeStatus(detection, input) {
-        try {
-            const basicStatus = await ProjectStatusAnalyzer.getBasicStatus(detection.projectPath);
-            let detailedMetrics = null;
-            if (input.includeMetrics && basicStatus.isGitRepo) {
-                detailedMetrics = await ProjectStatusAnalyzer.getDetailedMetrics(detection.projectPath);
-            }
-            return (0, auto_detection_js_1.createUniversalResponse)({
-                success: true,
-                action: 'status',
-                message: 'Project status retrieved successfully',
-                data: {
-                    basic: basicStatus,
-                    metrics: detailedMetrics,
-                    detailed: input.detailed
-                },
-                autoDetected: {
-                    repo: detection.repoName,
-                    owner: detection.owner,
-                    providers: detection.providers
-                }
-            });
-        }
-        catch (error) {
-            return this.errorHandler.toUniversalResponse();
-        }
-    }
-    /**
-     * Executa operação history
-     */
-    async executeHistory(detection, input) {
-        try {
-            const gitOps = new git_operations_js_1.GitOperations(detection.projectPath);
-            // Parse since parameter
-            let since = '';
-            if (input.since) {
-                if (input.since.match(/^\d+[dwmy]$/)) {
-                    since = `--since=${input.since}`;
-                }
-                else {
-                    since = `--since=${input.since}`;
-                }
-            }
-            // Get commit history
-            const logArgs = ['log', '--oneline', `--max-count=${input.limit}`];
-            if (since)
-                logArgs.push(since);
-            const logResult = await gitOps.runCommand('git', logArgs);
-            const commits = logResult.success ?
-                logResult.output.trim().split('\n').filter(line => line.trim()) : [];
-            return (0, auto_detection_js_1.createUniversalResponse)({
-                success: true,
-                action: 'history',
-                message: `Found ${commits.length} historical entries`,
-                data: {
-                    entries: commits,
-                    type: input.type,
-                    since: input.since,
-                    limit: input.limit,
-                    total: commits.length
-                },
-                autoDetected: {
-                    repo: detection.repoName,
-                    owner: detection.owner,
-                    providers: detection.providers
-                }
-            });
-        }
-        catch (error) {
-            return this.errorHandler.toUniversalResponse();
-        }
-    }
-    /**
-     * Executa operação metrics
-     */
-    async executeMetrics(detection, input) {
-        try {
-            const metrics = await ProductivityMetrics.calculateMetrics(detection.projectPath, input.period);
-            return (0, auto_detection_js_1.createUniversalResponse)({
-                success: true,
-                action: 'metrics',
-                message: `Productivity metrics calculated for ${input.period}`,
-                data: {
-                    ...metrics,
-                    includeCharts: input.includeCharts
-                },
-                autoDetected: {
-                    repo: detection.repoName,
-                    owner: detection.owner,
-                    providers: detection.providers
-                }
-            });
-        }
-        catch (error) {
-            return this.errorHandler.toUniversalResponse();
-        }
-    }
-    /**
-     * Executa operação health
-     */
-    async executeHealth(detection, input) {
-        try {
-            const health = await HealthAnalyzer.analyzeHealth(detection.projectPath, input.deep);
-            return (0, auto_detection_js_1.createUniversalResponse)({
-                success: true,
-                action: 'health',
-                message: `Health analysis completed - Score: ${health.score}/100`,
-                data: {
-                    ...health,
-                    suggestions: input.suggestions ? health.suggestions : undefined
-                },
-                autoDetected: {
-                    repo: detection.repoName,
-                    owner: detection.owner,
-                    providers: detection.providers
-                }
-            });
-        }
-        catch (error) {
-            return this.errorHandler.toUniversalResponse();
-        }
-    }
-    /**
-     * Executa operação activity
-     */
-    async executeActivity(detection, input) {
-        try {
-            const gitOps = new git_operations_js_1.GitOperations(detection.projectPath);
-            // Get recent commits
-            const hours = input.hours;
-            const logResult = await gitOps.runCommand('git', ['log', '--oneline', `--since=${hours} hours ago`]);
-            const commits = logResult.success ?
-                logResult.output.trim().split('\n').filter(line => line.trim()) : [];
-            // Get recent branches if requested
-            let branches = [];
-            if (input.includeRemote) {
-                try {
-                    const branchResult = await gitOps.runCommand('git', ['branch', '-r', '--sort=-committerdate']);
-                    branches = branchResult.success ?
-                        branchResult.output.trim().split('\n')
-                            .filter(line => line.trim())
-                            .slice(0, 5) : []; // Top 5 recent remote branches
-                }
-                catch (e) {
-                    // Ignore branch errors
-                }
-            }
-            return (0, auto_detection_js_1.createUniversalResponse)({
-                success: true,
-                action: 'activity',
-                message: `Recent activity for last ${hours} hours`,
-                data: {
-                    commits: commits,
-                    branches: branches,
-                    hours: hours,
-                    includeRemote: input.includeRemote,
-                    totalCommits: commits.length,
-                    totalBranches: branches.length
-                },
-                autoDetected: {
-                    repo: detection.repoName,
-                    owner: detection.owner,
-                    providers: detection.providers
-                }
-            });
-        }
-        catch (error) {
-            return this.errorHandler.toUniversalResponse();
-        }
-    }
-}
-/**
- * Tool principal git-monitor
- */
 exports.gitMonitorTool = {
     name: 'git-monitor',
-    description: `📊 SISTEMA DE MONITORAMENTO AVANÇADO
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-🎯 MONITORAMENTO COMPLETO:
-• status: Status completo do projeto com métricas
-• history: Histórico detalhado de atividades
-• metrics: Métricas de produtividade avançadas
-• health: Análise de saúde do projeto
-• activity: Atividade recente em tempo real
-
-📈 ANALYTICS INTELIGENTE:
-• Estatísticas de commits e produtividade
-• Análise de padrões de desenvolvimento
-• Métricas de saúde do repositório
-• Tendências de atividade
-• Recomendações automáticas
-
-⚡ MONITORAMENTO EM TEMPO REAL:
-• Atividade recente por período
-• Alertas de saúde do projeto
-• Métricas de performance
-• Análise de branches e remotes
-• Relatórios automatizados
-
-🤖 COMPATÍVEL COM AI AGENTS:
-• Respostas estruturadas para parsing
-• Dados normalizados para todos os IDEs
-• Interface universal consistente
-• Auto-detecção de contexto
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`,
-    inputSchema: {
-        type: 'object',
-        properties: {
-            action: {
-                type: 'string',
-                enum: ['status', 'history', 'metrics', 'health', 'activity'],
-                description: 'Ação do sistema de monitoramento'
-            },
-            projectPath: {
-                type: 'string',
-                description: 'Caminho absoluto do projeto'
-            },
-            detailed: {
-                type: 'boolean',
-                description: 'Análise detalhada para status'
-            },
-            includeMetrics: {
-                type: 'boolean',
-                description: 'Incluir métricas no status'
-            },
-            since: {
-                type: 'string',
-                description: 'Período para histórico (ISO date ou relativo: 1d, 1w, 1m)'
-            },
-            limit: {
-                type: 'number',
-                description: 'Limite de resultados'
-            },
-            type: {
-                type: 'string',
-                enum: ['all', 'commits', 'releases', 'issues'],
-                description: 'Tipo de histórico'
-            },
-            period: {
-                type: 'string',
-                description: 'Período para métricas (1d, 7d, 30d, 90d)'
-            },
-            includeCharts: {
-                type: 'boolean',
-                description: 'Incluir dados para gráficos'
-            },
-            deep: {
-                type: 'boolean',
-                description: 'Análise profunda de saúde'
-            },
-            suggestions: {
-                type: 'boolean',
-                description: 'Incluir sugestões na análise de saúde'
-            },
-            hours: {
-                type: 'number',
-                description: 'Horas para atividade recente'
-            },
-            includeRemote: {
-                type: 'boolean',
-                description: 'Incluir atividade remota'
-            }
-        },
-        required: ['action', 'projectPath']
-    },
+    description: '📊 MONITORAMENTO - Logs e monitoramento',
+    inputSchema: { type: 'object', properties: { action: { type: 'string' }, projectPath: { type: 'string' } }, required: ['action', 'projectPath'] },
     async handler(input) {
-        const executor = new GitMonitorExecutor();
-        let validatedInput;
-        try {
-            // Validate input
-            validatedInput = GitMonitorInputSchema.parse(input);
-            // Auto-detect context
-            const detection = await (0, auto_detection_js_1.autoDetect)(validatedInput.projectPath);
-            await (0, auto_detection_js_1.validateAutoDetection)(detection);
-            // Execute specific action
-            switch (validatedInput.action) {
-                case 'status':
-                    return await executor['executeStatus'](detection, validatedInput);
-                case 'history':
-                    return await executor['executeHistory'](detection, validatedInput);
-                case 'metrics':
-                    return await executor['executeMetrics'](detection, validatedInput);
-                case 'health':
-                    return await executor['executeHealth'](detection, validatedInput);
-                case 'activity':
-                    return await executor['executeActivity'](detection, validatedInput);
-                default:
-                    throw new Error(`Ação '${validatedInput.action}' não suportada`);
-            }
-        }
-        catch (error) {
-            executor.errorHandler.addError(error);
-            const errorResponse = executor.errorHandler.toUniversalResponse();
-            return (0, auto_detection_js_1.createUniversalResponse)(false, validatedInput?.action, 'Erro na execução da tool', await (0, auto_detection_js_1.autoDetect)(validatedInput?.projectPath), 'git-monitor', undefined, errorResponse);
-        }
+        const detection = (0, auto_detection_js_1.autoDetect)(input.projectPath);
+        return (0, auto_detection_js_1.createUniversalResponse)(true, input.action, 'Monitoramento ativo', detection, 'git-monitor', { monitoring: true });
     }
 };
 //# sourceMappingURL=git-monitor.js.map