@andrebuzeli/git-mcp 9.2.0 → 10.0.0

package/dist/tools/gitHistory.js

@@ -1,83 +1,152 @@
+import simpleGit from 'simple-git';
 import { MCPError } from '../utils/errors.js';
 import axios from 'axios';
 import * as fs from 'fs/promises';
 import * as path from 'path';
 import { getRepoNameFromPath } from '../utils/repoHelpers.js';
+/**
+ * Git History Tool - Mantém histórico detalhado de TODAS alterações
+ * Modo DUAL automático - cria issues de histórico em GitHub e Gitea
+ * Rastreabilidade completa de cada mudança local
+ */
 export class GitHistoryTool {
     constructor() {
         this.name = 'git-history';
         this.description = 'Maintain detailed history of all project changes with remote tracking via issues - automatic dual-provider execution';
-        this.inputSchema = {
-            type: 'object',
-            properties: { projectPath: { type: 'string' } },
-            required: ['projectPath'],
-            additionalProperties: true,
-        };
     }
     async handle(params, ctx) {
         const projectPath = params.projectPath;
-        if (!projectPath)
+        if (!projectPath) {
             throw new MCPError('VALIDATION_ERROR', 'projectPath is required');
+        }
         const action = params.action || 'track';
-        const git = ctx.gitAdapter;
+        const git = simpleGit({ baseDir: projectPath });
         switch (action) {
-            case 'record':
-            case 'track':
-                return this.trackChange(git, projectPath, params, ctx);
-            case 'list':
-            case 'report':
-                return this.generateReport(projectPath, params, ctx);
-            case 'get':
-                return this.getHistoryEntry(projectPath, params, ctx);
-            case 'search':
-                return this.searchHistory(projectPath, params, ctx);
-            case 'stats':
-                return this.getStats(projectPath, params, ctx);
-            case 'generate_changelog':
-                return this.generateChangelog(git, projectPath, params, ctx);
+            case 'track': {
+                // Rastrear mudança específica e criar histórico remoto
+                return await this.trackChange(git, projectPath, params, ctx);
+            }
+            case 'list': {
+                // Listar histórico local
+                return await this.listLocalHistory(projectPath);
+            }
+            case 'sync': {
+                // Sincronizar histórico local com remoto
+                return await this.syncHistory(git, projectPath, params, ctx);
+            }
+            case 'report': {
+                // Gerar relatório consolidado
+                return await this.generateReport(projectPath, params, ctx);
+            }
             default:
-                const validActions = ["record", "list", "get", "search", "stats"];
-                throw new MCPError('VALIDATION_ERROR', `Unsupported action: ${action}. Valid actions: ${validActions.join(', ')}`);
+                throw new MCPError('VALIDATION_ERROR', `Unsupported action: ${action}`);
         }
     }
     async trackChange(git, projectPath, params, ctx) {
-        const results = { success: true, timestamp: new Date().toISOString(), projectPath, action: 'track', providers: {}, traceability: { changeDetails: {}, localHistory: null, errors: [] } };
+        const results = {
+            success: true,
+            timestamp: new Date().toISOString(),
+            projectPath,
+            action: 'track',
+            providers: {},
+            traceability: {
+                changeDetails: {},
+                localHistory: null,
+                remoteHistory: {},
+                errors: [],
+            }
+        };
         try {
-            const status = await git.status(projectPath);
-            const log = await git.log(projectPath, { maxCount: 1 });
-            const lastCommit = log[0];
+            // 1. Coletar detalhes da mudança
+            const status = await git.status();
+            const log = await git.log({ maxCount: 1 });
+            const lastCommit = log.latest;
             results.traceability.changeDetails = {
                 branch: status.current,
-                lastCommit: lastCommit || null,
-                currentStatus: { modified: status.modified, created: status.created, deleted: status.deleted, staged: status.modified.concat(status.created, status.deleted), conflicted: status.conflicted },
+                lastCommit: lastCommit ? {
+                    hash: lastCommit.hash,
+                    date: lastCommit.date,
+                    message: lastCommit.message,
+                    author: lastCommit.author_name,
+                    email: lastCommit.author_email,
+                } : null,
+                currentStatus: {
+                    modified: status.modified,
+                    created: status.created,
+                    deleted: status.deleted,
+                    staged: status.staged,
+                    conflicted: status.conflicted,
+                },
                 description: params.description || params.message || 'Change tracked via git-history',
                 tags: params.tags || [],
                 category: params.category || 'general',
             };
-            results.traceability.localHistory = await this.saveLocalHistory(projectPath, results.traceability.changeDetails);
-            const githubOwner = await ctx.providerManager.getGitHubUsername();
-            const giteaOwner = await ctx.providerManager.getGiteaUsername();
+            // 2. Salvar no histórico local
+            const localHistoryFile = await this.saveLocalHistory(projectPath, results.traceability.changeDetails);
+            results.traceability.localHistory = localHistoryFile;
+            // 3. Criar issue de histórico em ambos providers
+            const githubOwner = params.owner || process.env.GITHUB_USERNAME;
+            const giteaOwner = params.owner || process.env.GITEA_USERNAME;
             const repo = params.repo || getRepoNameFromPath(projectPath);
             const historyTitle = params.title || `[${results.traceability.changeDetails.category}] ${results.traceability.changeDetails.description}`;
             const historyBody = this.formatHistoryBody(results.traceability.changeDetails, params);
+            // GITHUB
             if (ctx.providerManager.github) {
                 try {
-                    const issue = await ctx.providerManager.github.rest.issues.create({ owner: githubOwner, repo, title: historyTitle, body: historyBody, labels: ['git-history', results.traceability.changeDetails.category, ...(results.traceability.changeDetails.tags || [])] });
-                    results.providers.github = { success: true, issue: { number: issue.data.number, url: issue.data.html_url, id: issue.data.id } };
+                    const issue = await ctx.providerManager.github.rest.issues.create({
+                        owner: githubOwner,
+                        repo,
+                        title: historyTitle,
+                        body: historyBody,
+                        labels: ['git-history', results.traceability.changeDetails.category, ...results.traceability.changeDetails.tags],
+                    });
+                    results.providers.github = {
+                        success: true,
+                        issue: {
+                            number: issue.data.number,
+                            url: issue.data.html_url,
+                            id: issue.data.id,
+                        }
+                    };
                 }
                 catch (err) {
-                    results.providers.github = { success: false, error: err.message };
-                    results.traceability.errors.push({ provider: 'github', error: err.message, timestamp: new Date().toISOString() });
+                    results.providers.github = {
+                        success: false,
+                        error: err.message,
+                    };
+                    results.traceability.errors.push({
+                        provider: 'github',
+                        error: err.message,
+                        timestamp: new Date().toISOString(),
+                    });
                 }
             }
+            // GITEA
             if (ctx.providerManager.giteaBaseUrl) {
                 try {
-                    const issue = await axios.post(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${giteaOwner}/${repo}/issues`, { title: historyTitle, body: historyBody }, { headers: { Authorization: `token ${ctx.providerManager.giteaToken}` } });
-                    results.providers.gitea = { success: true, issue: { number: issue.data.number, url: issue.data.html_url, id: issue.data.id } };
+                    const issue = await axios.post(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${giteaOwner}/${repo}/issues`, {
+                        title: historyTitle,
+                        body: historyBody,
+                    }, { headers: { Authorization: `token ${ctx.providerManager.giteaToken}` } });
+                    results.providers.gitea = {
+                        success: true,
+                        issue: {
+                            number: issue.data.number,
+                            url: issue.data.html_url,
+                            id: issue.data.id,
+                        }
+                    };
                 }
                 catch (err) {
-                    results.providers.gitea = { success: false, error: err.message };
-                    results.traceability.errors.push({ provider: 'gitea', error: err.message, timestamp: new Date().toISOString() });
+                    results.providers.gitea = {
+                        success: false,
+                        error: err.message,
+                    };
+                    results.traceability.errors.push({
+                        provider: 'gitea',
+                        error: err.message,
+                        timestamp: new Date().toISOString(),
+                    });
                 }
             }
             return results;
@@ -93,38 +162,64 @@ export class GitHistoryTool {
                 await fs.access(historyDir);
             }
             catch {
-                return { success: true, history: [], message: 'No history found' };
+                return {
+                    success: true,
+                    history: [],
+                    message: 'No history found',
+                };
             }
             const files = await fs.readdir(historyDir);
             const historyFiles = files.filter(f => f.startsWith('history-') && f.endsWith('.json'));
-            const history = await Promise.all(historyFiles.map(async (file) => JSON.parse(await fs.readFile(path.join(historyDir, file), 'utf-8'))));
-            return { success: true, count: history.length, history: history.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime()) };
+            const history = await Promise.all(historyFiles.map(async (file) => {
+                const content = await fs.readFile(path.join(historyDir, file), 'utf-8');
+                return JSON.parse(content);
+            }));
+            return {
+                success: true,
+                count: history.length,
+                history: history.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime()),
+            };
         }
         catch (err) {
             throw new MCPError('LIST_ERROR', `Failed to list history: ${err.message}`);
         }
     }
-    async syncHistory(projectPath, params, ctx) {
-        const results = { success: true, timestamp: new Date().toISOString(), action: 'sync', synced: 0, providers: { github: {}, gitea: {} }, errors: [] };
+    async syncHistory(git, projectPath, params, ctx) {
+        const results = {
+            success: true,
+            timestamp: new Date().toISOString(),
+            action: 'sync',
+            synced: 0,
+            providers: { github: {}, gitea: {} },
+            errors: [],
+        };
         try {
             const localHistory = await this.listLocalHistory(projectPath);
-            const githubOwner = await ctx.providerManager.getGitHubUsername();
-            const giteaOwner = await ctx.providerManager.getGiteaUsername();
+            const githubOwner = params.owner || process.env.GITHUB_USERNAME;
+            const giteaOwner = params.owner || process.env.GITEA_USERNAME;
             const repo = params.repo || getRepoNameFromPath(projectPath);
             for (const historyEntry of localHistory.history) {
                 if (!historyEntry.synced) {
                     try {
                         const title = `[history-sync] ${historyEntry.description}`;
                         const body = this.formatHistoryBody(historyEntry, params);
+                        // Sync to GitHub
                         if (ctx.providerManager.github) {
                             try {
-                                await ctx.providerManager.github.rest.issues.create({ owner: githubOwner, repo, title, body, labels: ['git-history', 'synced'] });
+                                await ctx.providerManager.github.rest.issues.create({
+                                    owner: githubOwner,
+                                    repo,
+                                    title,
+                                    body,
+                                    labels: ['git-history', 'synced'],
+                                });
                                 results.synced++;
                             }
                             catch (err) {
                                 results.errors.push({ provider: 'github', error: err.message });
                             }
                         }
+                        // Sync to Gitea
                         if (ctx.providerManager.giteaBaseUrl) {
                             try {
                                 await axios.post(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${giteaOwner}/${repo}/issues`, { title, body }, { headers: { Authorization: `token ${ctx.providerManager.giteaToken}` } });
@@ -149,8 +244,24 @@ export class GitHistoryTool {
     async generateReport(projectPath, params, ctx) {
         try {
             const localHistory = await this.listLocalHistory(projectPath);
-            const report = { success: true, timestamp: new Date().toISOString(), projectPath, summary: { totalChanges: localHistory.count, byCategory: {}, byMonth: {}, recentChanges: localHistory.history.slice(0, 10) } };
-            localHistory.history.forEach((entry) => { const cat = entry.category || 'general'; report.summary.byCategory[cat] = (report.summary.byCategory[cat] || 0) + 1; const month = new Date(entry.timestamp).toISOString().slice(0, 7); report.summary.byMonth[month] = (report.summary.byMonth[month] || 0) + 1; });
+            const report = {
+                success: true,
+                timestamp: new Date().toISOString(),
+                projectPath,
+                summary: {
+                    totalChanges: localHistory.count,
+                    byCategory: {},
+                    byMonth: {},
+                    recentChanges: localHistory.history.slice(0, 10),
+                }
+            };
+            // Agrupar por categoria
+            localHistory.history.forEach((entry) => {
+                const cat = entry.category || 'general';
+                report.summary.byCategory[cat] = (report.summary.byCategory[cat] || 0) + 1;
+                const month = new Date(entry.timestamp).toISOString().slice(0, 7);
+                report.summary.byMonth[month] = (report.summary.byMonth[month] || 0) + 1;
+            });
             return report;
         }
         catch (err) {
@@ -161,151 +272,55 @@ export class GitHistoryTool {
         const historyDir = path.join(projectPath, '.git-mcp-history');
         await fs.mkdir(historyDir, { recursive: true });
         const historyFile = path.join(historyDir, `history-${Date.now()}.json`);
-        const historyEntry = { timestamp: new Date().toISOString(), ...changeDetails, synced: false };
+        const historyEntry = {
+            timestamp: new Date().toISOString(),
+            ...changeDetails,
+            synced: false,
+        };
         await fs.writeFile(historyFile, JSON.stringify(historyEntry, null, 2), 'utf-8');
         return historyFile;
     }
     formatHistoryBody(changeDetails, params) {
-        return `## Git History Entry\n\nTimestamp: ${changeDetails.timestamp || new Date().toISOString()}\nCategory: ${changeDetails.category || 'general'}\nBranch: ${changeDetails.branch || 'N/A'}\n\nDescription:\n${changeDetails.description || 'No description provided'}\n`;
-    }
-    async generateChangelog(git, projectPath, params, ctx) {
-        const outputFile = params.outputFile || 'CHANGELOG.md';
-        const format = params.format || 'keepachangelog';
-        const since = params.since || 'last-tag';
-        const results = { success: true, timestamp: new Date().toISOString(), projectPath, action: 'generate_changelog', outputFile, format, changelog: null };
-        try {
-            let commits = [];
-            if (since === 'last-tag') {
-                const tags = await git.listTags(projectPath);
-                if (tags.length > 0) {
-                    const lastTag = tags[0];
-                    commits = await git.log(projectPath, { ref: 'HEAD', since: lastTag });
-                }
-                else {
-                    commits = await git.log(projectPath);
-                }
-            }
-            else {
-                commits = await git.log(projectPath, { since });
-            }
-            const grouped = this.groupCommitsByType(commits);
-            const changelogContent = format === 'keepachangelog' ? this.formatKeepAChangelog(grouped, params) : this.formatConventionalChangelog(grouped, params);
-            results.changelog = changelogContent;
-            await fs.writeFile(path.join(projectPath, outputFile), changelogContent, 'utf-8');
-            await git.add(projectPath, [outputFile]);
-            results.commitHash = await git.commit(projectPath, 'docs: Update CHANGELOG.md');
-            const remotes = await git.listRemotes(projectPath);
-            const currentBranch = await git.getCurrentBranch(projectPath);
-            for (const remote of remotes) {
-                if (remote.name === 'github' || remote.name === 'gitea' || remote.name === 'origin') {
-                    try {
-                        await git.push(projectPath, remote.name, currentBranch, true);
-                    }
-                    catch (err) { /* ignore push errors for changelog generation */ }
-                }
-            }
-            return results;
-        }
-        catch (err) {
-            throw new MCPError('CHANGELOG_ERROR', `Failed to generate changelog: ${err.message}`);
-        }
-    }
-    groupCommitsByType(commits) { const groups = { added: [], fixed: [], changed: [], removed: [], deprecated: [], security: [], other: [] }; for (const commit of commits) {
-        const message = commit.commit?.message || commit.message || '';
-        const firstLine = message.split('\n')[0].toLowerCase();
-        if (firstLine.includes('feat') || firstLine.includes('add'))
-            groups.added.push(commit);
-        else if (firstLine.includes('fix') || firstLine.includes('bug'))
-            groups.fixed.push(commit);
-        else if (firstLine.includes('change') || firstLine.includes('update') || firstLine.includes('refactor'))
-            groups.changed.push(commit);
-        else if (firstLine.includes('remove') || firstLine.includes('delete'))
-            groups.removed.push(commit);
-        else if (firstLine.includes('deprecate'))
-            groups.deprecated.push(commit);
-        else if (firstLine.includes('security') || firstLine.includes('vuln'))
-            groups.security.push(commit);
-        else
-            groups.other.push(commit);
-    } return groups; }
-    formatKeepAChangelog(grouped, params) { let text = ''; for (const key of Object.keys(grouped)) {
-        if (grouped[key].length > 0) {
-            text += `### ${key}\n`;
-            for (const c of grouped[key]) {
-                const msg = (c.commit?.message || c.message || '').split('\n')[0];
-                text += `- ${msg}\n`;
-            }
-            text += '\n';
-        }
-    } return `# Changelog\n\n${text}`; }
-    formatConventionalChangelog(grouped, params) { return this.formatKeepAChangelog(grouped, params); }
-    async getHistoryEntry(projectPath, params, ctx) {
-        const historyId = params.historyId;
-        if (!historyId)
-            throw new MCPError('VALIDATION_ERROR', 'historyId is required for get action');
-        const historyFile = path.join(projectPath, '.git', 'git-history.json');
-        try {
-            const content = await fs.readFile(historyFile, 'utf-8');
-            const history = JSON.parse(content);
-            const entry = history.find((h) => h.id === historyId);
-            if (!entry) {
-                throw new MCPError('NOT_FOUND', `History entry ${historyId} not found`);
-            }
-            return { success: true, entry };
-        }
-        catch (err) {
-            if (err.code === 'ENOENT') {
-                throw new MCPError('NOT_FOUND', 'No history file found');
-            }
-            throw err;
-        }
-    }
-    async searchHistory(projectPath, params, ctx) {
-        const query = params.query;
-        if (!query)
-            throw new MCPError('VALIDATION_ERROR', 'query is required for search action');
-        const historyFile = path.join(projectPath, '.git', 'git-history.json');
-        try {
-            const content = await fs.readFile(historyFile, 'utf-8');
-            const history = JSON.parse(content);
-            const results = history.filter((entry) => {
-                const searchText = JSON.stringify(entry).toLowerCase();
-                return searchText.includes(query.toLowerCase());
-            });
-            return { success: true, results, count: results.length };
-        }
-        catch (err) {
-            if (err.code === 'ENOENT') {
-                return { success: true, results: [], count: 0 };
-            }
-            throw err;
-        }
-    }
-    async getStats(projectPath, params, ctx) {
-        const historyFile = path.join(projectPath, '.git', 'git-history.json');
-        try {
-            const content = await fs.readFile(historyFile, 'utf-8');
-            const history = JSON.parse(content);
-            const stats = {
-                total: history.length,
-                byCategory: {},
-                byBranch: {},
-                recentChanges: history.slice(-10).reverse()
-            };
-            history.forEach((entry) => {
-                const category = entry.changeDetails?.category || 'unknown';
-                const branch = entry.changeDetails?.branch || 'unknown';
-                stats.byCategory[category] = (stats.byCategory[category] || 0) + 1;
-                stats.byBranch[branch] = (stats.byBranch[branch] || 0) + 1;
-            });
-            return { success: true, stats };
-        }
-        catch (err) {
-            if (err.code === 'ENOENT') {
-                return { success: true, stats: { total: 0, byCategory: {}, byBranch: {}, recentChanges: [] } };
-            }
-            throw err;
-        }
+        return `
+## 📜 Git History Entry
+
+**Timestamp:** ${changeDetails.timestamp || new Date().toISOString()}
+**Category:** ${changeDetails.category || 'general'}
+**Branch:** ${changeDetails.branch || 'N/A'}
+
+### 📝 Description
+${changeDetails.description || 'No description provided'}
+
+### 🔧 Last Commit
+${changeDetails.lastCommit ? `
+- **Hash:** \`${changeDetails.lastCommit.hash}\`
+- **Author:** ${changeDetails.lastCommit.author} (${changeDetails.lastCommit.email})
+- **Date:** ${changeDetails.lastCommit.date}
+- **Message:** ${changeDetails.lastCommit.message}
+` : 'No recent commit'}
+
+### 📊 Current Status
+${changeDetails.currentStatus ? `
+- **Modified:** ${changeDetails.currentStatus.modified?.length || 0} files
+- **Created:** ${changeDetails.currentStatus.created?.length || 0} files
+- **Deleted:** ${changeDetails.currentStatus.deleted?.length || 0} files
+- **Staged:** ${changeDetails.currentStatus.staged?.length || 0} files
+- **Conflicted:** ${changeDetails.currentStatus.conflicted?.length || 0} files
+` : 'No status available'}
+
+${changeDetails.currentStatus?.modified?.length > 0 ? `
+### 📁 Modified Files
+${changeDetails.currentStatus.modified.map((f) => `- ${f}`).join('\n')}
+` : ''}
+
+${changeDetails.tags?.length > 0 ? `
+### 🏷️ Tags
+${changeDetails.tags.map((t) => `\`${t}\``).join(', ')}
+` : ''}
+
+---
+*Generated by git-mcp git-history tool*
+*Tracked at: ${changeDetails.timestamp || new Date().toISOString()}*
+`;
     }
 }
-//# sourceMappingURL=gitHistory.js.map

package/dist/tools/gitIgnore.d.ts

@@ -6,29 +6,6 @@ import { Tool, MCPContext } from '../types.js';
 export declare class GitIgnoreTool implements Tool {
     name: string;
     description: string;
-    inputSchema: {
-        type: "object";
-        properties: {
-            projectPath: {
-                type: string;
-                description: string;
-            };
-            action: {
-                type: string;
-                description: string;
-                enum: string[];
-            };
-            patterns: {
-                type: string;
-                items: {
-                    type: string;
-                };
-                description: string;
-            };
-        };
-        required: string[];
-        additionalProperties: boolean;
-    };
     handle(params: Record<string, any>, ctx: MCPContext): Promise<{
         success: boolean;
         path: string;
@@ -212,4 +189,3 @@ export declare class GitIgnoreTool implements Tool {
     }>;
     private getTemplate;
 }
-//# sourceMappingURL=gitIgnore.d.ts.map