@andrebuzeli/git-mcp 10.0.9 → 11.0.0

package/dist/scripts/verify_setup.js

@@ -1,61 +0,0 @@
-import { ProviderManager } from '../providers/providerManager.js';
-import { IsomorphicGitAdapter } from '../utils/gitAdapter.js';
-import * as path from 'path';
-import * as fs from 'fs';
-async function verify() {
-    console.log('🔍 Verifying setup and credentials...');
-    // 1. Check Environment Variables
-    console.log('\n1. Environment Variables:');
-    const vars = ['GITHUB_TOKEN', 'GITHUB_USERNAME', 'GITEA_TOKEN', 'GITEA_URL', 'GITEA_USERNAME'];
-    const missing = [];
-    for (const v of vars) {
-        if (process.env[v]) {
-            console.log(`   ✅ ${v} is set`);
-        }
-        else {
-            console.log(`   ❌ ${v} is MISSING`);
-            missing.push(v);
-        }
-    }
-    // 2. Validate Providers
-    console.log('\n2. Provider Connection:');
-    const providerManager = new ProviderManager();
-    const results = await providerManager.validateConfiguredProviders();
-    if (results.github) {
-        console.log(`   GitHub: ${results.github.ok ? '✅ Connected' : '❌ Failed: ' + results.github.error}`);
-    }
-    else {
-        console.log('   GitHub: ⚠️ Not configured');
-    }
-    if (results.gitea) {
-        console.log(`   Gitea:  ${results.gitea.ok ? '✅ Connected' : '❌ Failed: ' + results.gitea.error}`);
-    }
-    else {
-        console.log('   Gitea:  ⚠️ Not configured');
-    }
-    // 3. Validate GitAdapter
-    console.log('\n3. GitAdapter Initialization:');
-    try {
-        const gitAdapter = new IsomorphicGitAdapter(providerManager);
-        console.log('   ✅ GitAdapter initialized successfully');
-        // Try a simple local operation if we are in a git repo
-        const currentDir = process.cwd();
-        if (fs.existsSync(path.join(currentDir, '.git'))) {
-            try {
-                const branch = await gitAdapter.getCurrentBranch(currentDir);
-                console.log(`   ✅ Local Git check passed (Current branch: ${branch})`);
-            }
-            catch (e) {
-                console.log(`   ❌ Local Git check failed: ${e.message}`);
-            }
-        }
-        else {
-            console.log('   ℹ️ Current directory is not a git repo, skipping local check');
-        }
-    }
-    catch (err) {
-        console.log(`   ❌ GitAdapter initialization failed: ${err.message}`);
-    }
-    console.log('\n🏁 Verification Complete');
-}
-verify().catch(console.error);

package/dist/server.d.ts

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

package/dist/server.js

@@ -1,73 +0,0 @@
-import express from 'express';
-import bodyParser from 'body-parser';
-import Ajv from 'ajv';
-import { createErrorResponse } from './utils/errors.js';
-export function createServer(opts) {
-    const app = express();
-    app.use(bodyParser.json({ limit: '1mb' }));
-    const ajv = new Ajv({ allErrors: true, removeAdditional: false });
-    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(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)
-            return res.status(400).json(createErrorResponse('VALIDATION_ERROR', 'Missing tool name'));
-        const t = toolRegistry.get(tool);
-        if (!t)
-            return res.status(404).json(createErrorResponse('TOOL_NOT_FOUND', `Tool not found: ${tool}`));
-        try {
-            // Validate params via JSON Schema if available
-            if (t.inputSchema) {
-                const validate = ajv.compile(t.inputSchema);
-                const valid = validate(params ?? {});
-                if (!valid) {
-                    const errors = validate.errors?.map(e => `${e.instancePath} ${e.message}`).join(', ') || 'Invalid parameters';
-                    return res.status(400).json(createErrorResponse('VALIDATION_ERROR', `Invalid parameters: ${errors}`));
-                }
-            }
-            const result = await t.handle(params ?? {}, { providerManager: opts.providerManager, gitAdapter: opts.gitAdapter });
-            res.json({ success: true, result });
-        }
-        catch (err) {
-            console.error(`Error in tool ${tool}:`, err);
-            const errorCode = err.status || err.code || 'INTERNAL_ERROR';
-            const errorMsg = err.message || String(err);
-            res.status(500).json(createErrorResponse(errorCode, errorMsg));
-        }
-    });
-    return app;
-}

package/dist/tools/gitAnalytics.d.ts

@@ -1,35 +0,0 @@
-import { Tool, MCPContext } from '../types.js';
-export declare class GitAnalyticsTool implements Tool {
-    name: string;
-    description: string;
-    inputSchema: {
-        type: "object";
-        properties: {
-            projectPath: {
-                type: string;
-                description: string;
-                examples: string[];
-            };
-            action: {
-                type: string;
-                enum: string[];
-                description: string;
-            };
-            limit: {
-                type: string;
-                description: string;
-            };
-            since: {
-                type: string;
-                description: string;
-            };
-            until: {
-                type: string;
-                description: string;
-            };
-        };
-        required: string[];
-        additionalProperties: boolean;
-    };
-    handle(params: Record<string, any>, ctx: MCPContext): Promise<any>;
-}

package/dist/tools/gitAnalytics.js

@@ -1,220 +0,0 @@
-import { MCPError } from '../utils/errors.js';
-import axios from 'axios';
-import { getRepoInfo, normalizeToolParams } from '../utils/repoHelpers.js';
-export class GitAnalyticsTool {
-    constructor() {
-        this.name = 'git-analytics';
-        this.description = 'Repository analytics and statistics - automatic dual-provider execution using GitHub and Gitea APIs';
-        this.inputSchema = {
-            type: "object",
-            properties: {
-                projectPath: {
-                    type: "string",
-                    description: "The absolute path to the Git repository directory on the local filesystem. This should be the root directory containing the .git folder. For example: '/home/user/my-project' on Linux/Mac or 'C:\\Users\\user\\my-project' on Windows.",
-                    examples: ["/home/user/my-repo", "C:\\Users\\user\\my-repo"]
-                },
-                action: {
-                    type: "string",
-                    enum: ["stats", "commits", "contributors"],
-                    description: "The analytics operation to perform: 'stats' for repository statistics, 'commits' for commit history analysis, 'contributors' for contributor statistics."
-                },
-                limit: {
-                    type: "number",
-                    description: "Maximum number of commits to return (optional, default: 100, only used for 'commits' action)"
-                },
-                since: {
-                    type: "string",
-                    description: "Start date for filtering commits/contributors in ISO 8601 format (optional, e.g., '2023-01-01T00:00:00Z')"
-                },
-                until: {
-                    type: "string",
-                    description: "End date for filtering commits/contributors in ISO 8601 format (optional, e.g., '2024-01-01T00:00:00Z')"
-                }
-            },
-            required: ["projectPath", "action"],
-            additionalProperties: true
-        };
-    }
-    async handle(params, ctx) {
-        params = normalizeToolParams(params);
-        const action = params.action;
-        const projectPath = params.projectPath;
-        if (!action)
-            throw new MCPError('VALIDATION_ERROR', 'action is required');
-        if (!projectPath)
-            throw new MCPError('VALIDATION_ERROR', 'projectPath is required');
-        // Auto-extract repo info from projectPath
-        const repoInfo = getRepoInfo(projectPath);
-        const repo = params.repo || repoInfo.repoName;
-        // Each provider uses its own username from env
-        const githubOwner = params.owner || process.env.GITHUB_USERNAME;
-        const giteaOwner = params.owner || process.env.GITEA_USERNAME;
-        switch (action) {
-            case 'stats': {
-                const results = { success: true, providers: {} };
-                // GitHub API
-                if (ctx.providerManager.github && githubOwner) {
-                    try {
-                        const repoData = await ctx.providerManager.github.rest.repos.get({
-                            owner: githubOwner,
-                            repo: repo,
-                        });
-                        const branches = await ctx.providerManager.github.rest.repos.listBranches({
-                            owner: githubOwner,
-                            repo: repo,
-                        });
-                        const tags = await ctx.providerManager.github.rest.repos.listTags({
-                            owner: githubOwner,
-                            repo: repo,
-                        });
-                        const commits = await ctx.providerManager.github.rest.repos.listCommits({
-                            owner: githubOwner,
-                            repo: repo,
-                            per_page: 1,
-                        });
-                        results.providers.github = {
-                            success: true,
-                            stats: {
-                                totalCommits: repoData.data.size,
-                                branches: branches.data.length,
-                                tags: tags.data.length,
-                                defaultBranch: repoData.data.default_branch,
-                                latestCommit: commits.data[0] || null,
-                                size: repoData.data.size,
-                                language: repoData.data.language,
-                                stars: repoData.data.stargazers_count,
-                                forks: repoData.data.forks_count,
-                                openIssues: repoData.data.open_issues_count,
-                            },
-                        };
-                    }
-                    catch (err) {
-                        results.providers.github = { success: false, error: err.message };
-                    }
-                }
-                // Gitea API
-                if (ctx.providerManager.giteaBaseUrl && giteaOwner) {
-                    try {
-                        const repoData = await axios.get(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${giteaOwner}/${repo}`, { headers: { Authorization: `token ${ctx.providerManager.giteaToken}` } });
-                        const branches = await axios.get(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${giteaOwner}/${repo}/branches`, { headers: { Authorization: `token ${ctx.providerManager.giteaToken}` } });
-                        const tags = await axios.get(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${giteaOwner}/${repo}/tags`, { headers: { Authorization: `token ${ctx.providerManager.giteaToken}` } });
-                        const commits = await axios.get(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${giteaOwner}/${repo}/commits`, {
-                            params: { limit: 1 },
-                            headers: { Authorization: `token ${ctx.providerManager.giteaToken}` }
-                        });
-                        results.providers.gitea = {
-                            success: true,
-                            stats: {
-                                totalCommits: repoData.data.size,
-                                branches: branches.data.length,
-                                tags: tags.data.length,
-                                defaultBranch: repoData.data.default_branch,
-                                latestCommit: commits.data[0] || null,
-                                size: repoData.data.size,
-                                language: repoData.data.language,
-                                stars: repoData.data.stars_count,
-                                forks: repoData.data.forks_count,
-                                openIssues: repoData.data.open_issues_count,
-                            },
-                        };
-                    }
-                    catch (err) {
-                        results.providers.gitea = { success: false, error: err.message };
-                    }
-                }
-                return results;
-            }
-            case 'commits': {
-                const results = { success: true, providers: {} };
-                // GitHub API
-                if (ctx.providerManager.github && githubOwner) {
-                    try {
-                        const commits = await ctx.providerManager.github.rest.repos.listCommits({
-                            owner: githubOwner,
-                            repo: repo,
-                            since: params.since,
-                            until: params.until,
-                            per_page: params.limit || 100,
-                        });
-                        results.providers.github = {
-                            success: true,
-                            commits: commits.data.length,
-                            details: commits.data,
-                        };
-                    }
-                    catch (err) {
-                        results.providers.github = { success: false, error: err.message };
-                    }
-                }
-                // Gitea API
-                if (ctx.providerManager.giteaBaseUrl && giteaOwner) {
-                    try {
-                        const commits = await axios.get(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${giteaOwner}/${repo}/commits`, {
-                            params: {
-                                since: params.since,
-                                until: params.until,
-                                limit: params.limit || 100,
-                            },
-                            headers: { Authorization: `token ${ctx.providerManager.giteaToken}` }
-                        });
-                        results.providers.gitea = {
-                            success: true,
-                            commits: commits.data.length,
-                            details: commits.data,
-                        };
-                    }
-                    catch (err) {
-                        results.providers.gitea = { success: false, error: err.message };
-                    }
-                }
-                return results;
-            }
-            case 'contributors': {
-                const results = { success: true, providers: {} };
-                // GitHub API
-                if (ctx.providerManager.github && githubOwner) {
-                    try {
-                        const contributors = await ctx.providerManager.github.rest.repos.listContributors({
-                            owner: githubOwner,
-                            repo: repo,
-                            per_page: 100,
-                        });
-                        results.providers.github = {
-                            success: true,
-                            contributors: contributors.data.map((c) => ({
-                                login: c.login,
-                                name: c.login,
-                                contributions: c.contributions,
-                                avatar_url: c.avatar_url,
-                            })),
-                        };
-                    }
-                    catch (err) {
-                        results.providers.github = { success: false, error: err.message };
-                    }
-                }
-                // Gitea API
-                if (ctx.providerManager.giteaBaseUrl && giteaOwner) {
-                    try {
-                        const contributors = await axios.get(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${giteaOwner}/${repo}/contributors`, { headers: { Authorization: `token ${ctx.providerManager.giteaToken}` } });
-                        results.providers.gitea = {
-                            success: true,
-                            contributors: contributors.data.map((c) => ({
-                                login: c.login,
-                                name: c.name || c.login,
-                                contributions: c.contributions,
-                                avatar_url: c.avatar_url,
-                            })),
-                        };
-                    }
-                    catch (err) {
-                        results.providers.gitea = { success: false, error: err.message };
-                    }
-                }
-                return results;
-            }
-            default:
-                throw new MCPError('VALIDATION_ERROR', `Unsupported action: ${action}`);
-        }
-    }
-}

package/dist/tools/gitArchive.d.ts

@@ -1,119 +0,0 @@
-import { Tool, MCPContext } from '../types.js';
-export declare class GitArchiveTool implements Tool {
-    name: string;
-    description: string;
-    inputSchema: {
-        type: "object";
-        properties: {
-            projectPath: {
-                type: string;
-                description: string;
-            };
-            action: {
-                type: string;
-                enum: string[];
-                description: string;
-            };
-            outputPath: {
-                type: string;
-                description: string;
-            };
-            format: {
-                type: string;
-                enum: string[];
-                description: string;
-            };
-            ref: {
-                type: string;
-                description: string;
-            };
-        };
-        required: string[];
-        additionalProperties: boolean;
-    };
-    handle(params: Record<string, any>, ctx: MCPContext): Promise<{
-        success: boolean;
-        archivePath: string;
-        message: string;
-        archives?: undefined;
-        count?: undefined;
-        archivesDir?: undefined;
-        valid?: undefined;
-        archive?: undefined;
-        error?: undefined;
-        extracted?: undefined;
-        extractTo?: undefined;
-        metadataPath?: undefined;
-        note?: undefined;
-    } | {
-        success: boolean;
-        archives: string[];
-        count: number;
-        archivesDir: any;
-        archivePath?: undefined;
-        message?: undefined;
-        valid?: undefined;
-        archive?: undefined;
-        error?: undefined;
-        extracted?: undefined;
-        extractTo?: undefined;
-        metadataPath?: undefined;
-        note?: undefined;
-    } | {
-        success: boolean;
-        archives: never[];
-        count: number;
-        message: string;
-        archivePath?: undefined;
-        archivesDir?: undefined;
-        valid?: undefined;
-        archive?: undefined;
-        error?: undefined;
-        extracted?: undefined;
-        extractTo?: undefined;
-        metadataPath?: undefined;
-        note?: undefined;
-    } | {
-        success: boolean;
-        valid: boolean;
-        archive: any;
-        message: string;
-        archivePath?: undefined;
-        archives?: undefined;
-        count?: undefined;
-        archivesDir?: undefined;
-        error?: undefined;
-        extracted?: undefined;
-        extractTo?: undefined;
-        metadataPath?: undefined;
-        note?: undefined;
-    } | {
-        success: boolean;
-        valid: boolean;
-        error: any;
-        archivePath?: undefined;
-        message?: undefined;
-        archives?: undefined;
-        count?: undefined;
-        archivesDir?: undefined;
-        archive?: undefined;
-        extracted?: undefined;
-        extractTo?: undefined;
-        metadataPath?: undefined;
-        note?: undefined;
-    } | {
-        success: boolean;
-        extracted: boolean;
-        archivePath: any;
-        extractTo: any;
-        archive: any;
-        metadataPath: string;
-        message: string;
-        note: string;
-        archives?: undefined;
-        count?: undefined;
-        archivesDir?: undefined;
-        valid?: undefined;
-        error?: undefined;
-    }>;
-}

package/dist/tools/gitArchive.js

@@ -1,150 +0,0 @@
-import fs from 'fs/promises';
-import path from 'path';
-import { MCPError } from '../utils/errors.js';
-export class GitArchiveTool {
-    constructor() {
-        this.name = 'git-archive';
-        this.description = 'Repository archive operations';
-        this.inputSchema = {
-            type: "object",
-            properties: {
-                projectPath: {
-                    type: "string",
-                    description: "The absolute path to the Git repository directory on the local filesystem. This should be the root directory containing the .git folder. For example: '/home/user/my-project' on Linux/Mac or 'C:\\Users\\user\\my-project' on Windows."
-                },
-                action: {
-                    type: "string",
-                    enum: ["create", "extract"],
-                    description: "Archive operation to perform: create (create archive), extract (extract archive)"
-                },
-                outputPath: {
-                    type: "string",
-                    description: "Output archive file path (required for create)"
-                },
-                format: {
-                    type: "string",
-                    enum: ["tar", "tar.gz", "zip"],
-                    description: "Archive format (optional for create, default: tar.gz)"
-                },
-                ref: {
-                    type: "string",
-                    description: "Git reference to archive (optional for create, default: HEAD)"
-                }
-            },
-            required: ["projectPath", "action"],
-            additionalProperties: true
-        };
-    }
-    async handle(params, ctx) {
-        const action = params.action;
-        const projectPath = params.projectPath;
-        if (!action || !projectPath) {
-            throw new MCPError('VALIDATION_ERROR', 'action and projectPath are required');
-        }
-        switch (action) {
-            case 'create': {
-                const archiveName = params.archiveName || `archive-${Date.now()}.json`;
-                const outputPath = params.outputPath || path.join(projectPath, '.git-archives');
-                try {
-                    // Criar diretório de archives se não existir
-                    await fs.mkdir(outputPath, { recursive: true });
-                    const archivePath = path.join(outputPath, archiveName);
-                    const archiveData = {
-                        projectPath,
-                        timestamp: new Date().toISOString(),
-                        type: 'git-archive',
-                    };
-                    await fs.writeFile(archivePath, JSON.stringify(archiveData, null, 2));
-                    return {
-                        success: true,
-                        archivePath,
-                        message: 'Archive created successfully',
-                    };
-                }
-                catch (error) {
-                    throw new MCPError('FILE_ERROR', `Failed to create archive: ${error.message}`);
-                }
-            }
-            case 'list': {
-                const archivesDir = params.archivesDir || path.join(projectPath, '.git-archives');
-                try {
-                    const files = await fs.readdir(archivesDir);
-                    const archives = files.filter(f => f.endsWith('.json'));
-                    return {
-                        success: true,
-                        archives,
-                        count: archives.length,
-                        archivesDir,
-                    };
-                }
-                catch (error) {
-                    return {
-                        success: true,
-                        archives: [],
-                        count: 0,
-                        message: 'No archives directory found',
-                    };
-                }
-            }
-            case 'verify': {
-                const archivePath = params.archivePath;
-                if (!archivePath)
-                    throw new MCPError('VALIDATION_ERROR', 'archivePath is required');
-                try {
-                    const content = await fs.readFile(archivePath, 'utf-8');
-                    const archive = JSON.parse(content);
-                    return {
-                        success: true,
-                        valid: true,
-                        archive,
-                        message: 'Archive is valid',
-                    };
-                }
-                catch (error) {
-                    return {
-                        success: false,
-                        valid: false,
-                        error: error.message,
-                    };
-                }
-            }
-            case 'extract': {
-                const archivePath = params.archivePath;
-                const extractTo = params.extractTo || projectPath;
-                if (!archivePath)
-                    throw new MCPError('VALIDATION_ERROR', 'archivePath is required');
-                if (!extractTo)
-                    throw new MCPError('VALIDATION_ERROR', 'extractTo is required');
-                try {
-                    // Ler o arquivo de archive
-                    const content = await fs.readFile(archivePath, 'utf-8');
-                    const archive = JSON.parse(content);
-                    // Verificar se é um archive válido
-                    if (!archive.projectPath || !archive.timestamp) {
-                        throw new MCPError('VALIDATION_ERROR', 'Invalid archive format');
-                    }
-                    // Criar diretório de extração
-                    await fs.mkdir(extractTo, { recursive: true });
-                    // Copiar informações do archive para um arquivo de metadados
-                    const metadataPath = path.join(extractTo, '.archive-metadata.json');
-                    await fs.writeFile(metadataPath, JSON.stringify(archive, null, 2), 'utf-8');
-                    return {
-                        success: true,
-                        extracted: true,
-                        archivePath,
-                        extractTo,
-                        archive,
-                        metadataPath,
-                        message: 'Archive extracted successfully. Metadata saved to .archive-metadata.json',
-                        note: 'This is a simplified extraction. For full restoration, use git commands or backup tools.',
-                    };
-                }
-                catch (error) {
-                    throw new MCPError('EXTRACT_ERROR', `Failed to extract archive: ${error.message}`);
-                }
-            }
-            default:
-                throw new MCPError('VALIDATION_ERROR', `Unsupported action: ${action}`);
-        }
-    }
-}