@andrebuzeli/git-mcp 5.5.2 → 5.8.0

package/dist/server.d.ts

@@ -1,6 +1,7 @@
 import { ProviderManager } from './providers/providerManager';
-import { Tool } from './types';
+import { Tool, Resource } from './types';
 export declare function createServer(opts: {
     tools: Tool[];
     providerManager: ProviderManager;
+    resources?: Resource[];
 }): import("express-serve-static-core").Express;

package/dist/server.js

@@ -13,6 +13,39 @@ function createServer(opts) {
     const toolRegistry = new Map();
     for (const t of opts.tools)
         toolRegistry.set(t.name, t);
+    const resourceRegistry = new Map();
+    if (opts.resources) {
+        for (const r of opts.resources)
+            resourceRegistry.set(r.uri, r);
+    }
+    // List all available resources
+    app.get('/resources', (req, res) => {
+        const resources = Array.from(resourceRegistry.values()).map(r => ({
+            uri: r.uri,
+            name: r.name,
+            description: r.description,
+            mimeType: r.mimeType
+        }));
+        res.json({ success: true, resources });
+    });
+    // Get specific resource
+    app.get('/resources/:uri(*)', (req, res) => {
+        const uri = req.params.uri;
+        const resource = resourceRegistry.get(uri);
+        if (!resource) {
+            return res.status(404).json((0, errors_1.createErrorResponse)('RESOURCE_NOT_FOUND', `Resource not found: ${uri}`));
+        }
+        res.json({
+            success: true,
+            resource: {
+                uri: resource.uri,
+                name: resource.name,
+                description: resource.description,
+                mimeType: resource.mimeType,
+                content: resource.content
+            }
+        });
+    });
     app.post('/call', async (req, res) => {
         const { tool, params } = req.body ?? {};
         if (!tool)

package/dist/tools/gitBranches.d.ts

@@ -25,9 +25,9 @@ export declare class GitBranchesTool implements Tool {
         commits?: undefined;
         diff?: undefined;
     } | {
+        success: boolean;
         branch: string;
         current: boolean;
-        success?: undefined;
         branches?: undefined;
         deleted?: undefined;
         result?: undefined;
@@ -58,11 +58,11 @@ export declare class GitBranchesTool implements Tool {
         commits?: undefined;
         diff?: undefined;
     } | {
+        success: boolean;
         baseBranch: any;
         compareBranch: any;
         commits: readonly (import("simple-git").DefaultLogFields & import("simple-git").ListLogLine)[];
         diff: string;
-        success?: undefined;
         branch?: undefined;
         branches?: undefined;
         current?: undefined;

package/dist/tools/gitBranches.js

@@ -53,7 +53,7 @@ class GitBranchesTool {
                         'Use git branch -a to see all available branches',
                     ]);
                 }
-                return { branch, current: branches.current === branchName };
+                return { success: true, branch, current: branches.current === branchName };
             }
             case 'delete': {
                 (0, safetyController_1.requireConfirmationIfDestructive)('delete', params);
@@ -83,6 +83,7 @@ class GitBranchesTool {
                 const diff = await git.diff([`${baseBranch}...${compareBranch}`]);
                 const log = await git.log({ from: baseBranch, to: compareBranch });
                 return {
+                    success: true,
                     baseBranch,
                     compareBranch,
                     commits: log.all,

package/dist/tools/gitFiles.d.ts

@@ -3,20 +3,26 @@ export declare class GitFilesTool implements Tool {
     name: string;
     description: string;
     handle(params: Record<string, any>): Promise<{
+        success: boolean;
         path: string;
         content: string;
         files?: undefined;
         matches?: undefined;
+        count?: undefined;
     } | {
+        success: boolean;
         files: string[];
         path?: undefined;
         content?: undefined;
         matches?: undefined;
+        count?: undefined;
     } | {
+        success: boolean;
         matches: {
             file: string;
             snippet: string;
         }[];
+        count: number;
         path?: undefined;
         content?: undefined;
         files?: undefined;

package/dist/tools/gitFiles.js

@@ -20,11 +20,12 @@ class GitFilesTool {
         const fullPath = path_1.default.resolve(projectPath, params.filePath ?? '');
         if (action === 'read') {
             const content = await promises_1.default.readFile(fullPath, 'utf8');
-            return { path: fullPath, content };
+            return { success: true, path: fullPath, content };
         }
         if (action === 'list') {
-            const files = await promises_1.default.readdir(projectPath);
-            return { files };
+            const dirPath = params.directoryPath ? path_1.default.join(projectPath, params.directoryPath) : projectPath;
+            const files = await promises_1.default.readdir(dirPath);
+            return { success: true, files };
         }
         // Blocked operations
         if (['create', 'update', 'delete'].includes(action)) {
@@ -32,20 +33,21 @@ class GitFilesTool {
         }
         if (action === 'search') {
             // Simple string search within files in projectPath (non-recursive)
-            const files = await promises_1.default.readdir(projectPath);
-            const q = params.query ?? '';
+            const searchPath = params.searchPath ? path_1.default.join(projectPath, params.searchPath) : projectPath;
+            const files = await promises_1.default.readdir(searchPath);
+            const q = params.searchText ?? params.query ?? '';
             const matches = [];
             for (const f of files) {
                 try {
-                    const txt = await promises_1.default.readFile(path_1.default.join(projectPath, f), 'utf8');
+                    const txt = await promises_1.default.readFile(path_1.default.join(searchPath, f), 'utf8');
                     if (txt.includes(q))
-                        matches.push({ file: f, snippet: txt.substr(txt.indexOf(q), 200) });
+                        matches.push({ file: f, snippet: txt.substring(txt.indexOf(q), txt.indexOf(q) + 200) });
                 }
                 catch (e) {
                     // ignore binary/unreadable
                 }
             }
-            return { matches };
+            return { success: true, matches, count: matches.length };
         }
         throw new errors_1.MCPError('VALIDATION_ERROR', `Unsupported action: ${action}`);
     }

package/dist/tools/gitHistory.d.ts

@@ -0,0 +1,17 @@
+import { Tool, MCPContext } from '../types';
+/**
+ * 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 declare class GitHistoryTool implements Tool {
+    name: string;
+    description: string;
+    handle(params: Record<string, any>, ctx: MCPContext): Promise<any>;
+    private trackChange;
+    private listLocalHistory;
+    private syncHistory;
+    private generateReport;
+    private saveLocalHistory;
+    private formatHistoryBody;
+}

package/dist/tools/gitHistory.js

@@ -0,0 +1,365 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitHistoryTool = void 0;
+const simple_git_1 = __importDefault(require("simple-git"));
+const errors_1 = require("../utils/errors");
+const axios_1 = __importDefault(require("axios"));
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+/**
+ * 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
+ */
+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';
+    }
+    async handle(params, ctx) {
+        const projectPath = params.projectPath;
+        if (!projectPath) {
+            throw new errors_1.MCPError('VALIDATION_ERROR', 'projectPath is required');
+        }
+        const action = params.action || 'track';
+        const git = (0, simple_git_1.default)({ baseDir: projectPath });
+        switch (action) {
+            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:
+                throw new errors_1.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,
+                remoteHistory: {},
+                errors: [],
+            }
+        };
+        try {
+            // 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 ? {
+                    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',
+            };
+            // 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 || path.basename(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,
+                        }
+                    };
+                }
+                catch (err) {
+                    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_1.default.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(),
+                    });
+                }
+            }
+            return results;
+        }
+        catch (err) {
+            throw new errors_1.MCPError('TRACK_ERROR', `Failed to track change: ${err.message}`);
+        }
+    }
+    async listLocalHistory(projectPath) {
+        try {
+            const historyDir = path.join(projectPath, '.git-mcp-history');
+            try {
+                await fs.access(historyDir);
+            }
+            catch {
+                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) => {
+                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 errors_1.MCPError('LIST_ERROR', `Failed to list history: ${err.message}`);
+        }
+    }
+    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 = params.owner || process.env.GITHUB_USERNAME;
+            const giteaOwner = params.owner || process.env.GITEA_USERNAME;
+            const repo = params.repo || path.basename(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'],
+                                });
+                                results.synced++;
+                            }
+                            catch (err) {
+                                results.errors.push({ provider: 'github', error: err.message });
+                            }
+                        }
+                        // Sync to Gitea
+                        if (ctx.providerManager.giteaBaseUrl) {
+                            try {
+                                await axios_1.default.post(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${giteaOwner}/${repo}/issues`, { title, body }, { headers: { Authorization: `token ${ctx.providerManager.giteaToken}` } });
+                                results.synced++;
+                            }
+                            catch (err) {
+                                results.errors.push({ provider: 'gitea', error: err.message });
+                            }
+                        }
+                    }
+                    catch (err) {
+                        results.errors.push({ entry: historyEntry.timestamp, error: err.message });
+                    }
+                }
+            }
+            return results;
+        }
+        catch (err) {
+            throw new errors_1.MCPError('SYNC_ERROR', `Failed to sync history: ${err.message}`);
+        }
+    }
+    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),
+                }
+            };
+            // 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) {
+            throw new errors_1.MCPError('REPORT_ERROR', `Failed to generate report: ${err.message}`);
+        }
+    }
+    async saveLocalHistory(projectPath, changeDetails) {
+        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,
+        };
+        await fs.writeFile(historyFile, JSON.stringify(historyEntry, null, 2), 'utf-8');
+        return historyFile;
+    }
+    formatHistoryBody(changeDetails, params) {
+        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()}*
+`;
+    }
+}
+exports.GitHistoryTool = GitHistoryTool;

package/dist/tools/gitIssues.d.ts

@@ -2,20 +2,5 @@ import { Tool, MCPContext } from '../types';
 export declare class GitIssuesTool implements Tool {
     name: string;
     description: string;
-    handle(params: Record<string, any>, ctx: MCPContext): Promise<{
-        success: boolean;
-        issue: any;
-        issues?: undefined;
-        comment?: undefined;
-    } | {
-        success: boolean;
-        issues: any;
-        issue?: undefined;
-        comment?: undefined;
-    } | {
-        success: boolean;
-        comment: any;
-        issue?: undefined;
-        issues?: undefined;
-    }>;
+    handle(params: Record<string, any>, ctx: MCPContext): Promise<any>;
 }