@andrebuzeli/git-mcp 10.0.8 → 11.0.0

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}`);
-        }
-    }
-}

package/dist/tools/gitBackup.d.ts

@@ -1,116 +0,0 @@
-import { Tool, MCPContext } from '../types.js';
-export declare class GitBackupTool implements Tool {
-    name: string;
-    description: string;
-    inputSchema: {
-        type: "object";
-        properties: {
-            projectPath: {
-                type: string;
-                description: string;
-            };
-            action: {
-                type: string;
-                enum: string[];
-                description: string;
-            };
-            backupPath: {
-                type: string;
-                description: string;
-            };
-            compress: {
-                type: string;
-                description: string;
-            };
-            confirm: {
-                type: string;
-                description: string;
-            };
-            name: {
-                type: string;
-                description: string;
-            };
-        };
-        required: string[];
-        additionalProperties: boolean;
-    };
-    handle(params: Record<string, any>, ctx: MCPContext): Promise<{
-        success: boolean;
-        backupPath: string;
-        backupData: {
-            projectPath: any;
-            timestamp: string;
-            branch: string;
-            lastCommit: string | null;
-            files: number;
-        };
-        message: string;
-        backups?: undefined;
-        count?: undefined;
-        backupDir?: undefined;
-        valid?: undefined;
-        backup?: undefined;
-        error?: undefined;
-        note?: undefined;
-    } | {
-        success: boolean;
-        backups: any[];
-        count: number;
-        backupDir: any;
-        backupPath?: undefined;
-        backupData?: undefined;
-        message?: undefined;
-        valid?: undefined;
-        backup?: undefined;
-        error?: undefined;
-        note?: undefined;
-    } | {
-        success: boolean;
-        backups: never[];
-        count: number;
-        message: string;
-        backupPath?: undefined;
-        backupData?: undefined;
-        backupDir?: undefined;
-        valid?: undefined;
-        backup?: undefined;
-        error?: undefined;
-        note?: undefined;
-    } | {
-        success: boolean;
-        valid: any;
-        backup: any;
-        message: string;
-        backupPath?: undefined;
-        backupData?: undefined;
-        backups?: undefined;
-        count?: undefined;
-        backupDir?: undefined;
-        error?: undefined;
-        note?: undefined;
-    } | {
-        success: boolean;
-        valid: boolean;
-        error: any;
-        backupPath?: undefined;
-        backupData?: undefined;
-        message?: undefined;
-        backups?: undefined;
-        count?: undefined;
-        backupDir?: undefined;
-        backup?: undefined;
-        note?: undefined;
-    } | {
-        success: boolean;
-        message: string;
-        backup: any;
-        note: string;
-        backupPath?: undefined;
-        backupData?: undefined;
-        backups?: undefined;
-        count?: undefined;
-        backupDir?: undefined;
-        valid?: undefined;
-        error?: undefined;
-    }>;
-}