@andrebuzeli/git-mcp 10.0.9 → 11.0.0

package/dist/tools/gitMonitor.js

@@ -1,284 +0,0 @@
-import { MCPError } from '../utils/errors.js';
-import { getRepoInfo } from '../utils/repoHelpers.js';
-import axios from 'axios';
-export class GitMonitorTool {
-    constructor() {
-        this.name = 'git-monitor';
-        this.description = 'Repository monitoring and status operations - automatic dual-provider execution for remote queries';
-        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: ["log", "status", "commits", "contributors"],
-                    description: "Monitor operation to perform: log (get activity log), status (get repo status), commits (get commit activity), contributors (get contributor activity)"
-                },
-                since: {
-                    type: "string",
-                    description: "Start date for activity query (ISO 8601, optional)"
-                },
-                until: {
-                    type: "string",
-                    description: "End date for activity query (ISO 8601, optional)"
-                }
-            },
-            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');
-        }
-        const git = ctx.gitAdapter;
-        switch (action) {
-            case 'log': {
-                const options = {
-                    maxCount: params.limit || 10,
-                };
-                if (params.since)
-                    options.from = params.since; // Note: GitAdapter log doesn't support 'from' date filtering natively yet, but we pass it anyway or ignore
-                // GitAdapter log supports 'ref' and 'maxCount'. Date filtering would need to be done manually if not supported.
-                // For now, we'll just get the log and filter if needed, or rely on maxCount.
-                const logEntries = await git.log(projectPath, options);
-                const results = {
-                    success: true,
-                    local: {
-                        commits: logEntries,
-                        total: logEntries.length,
-                    },
-                    providers: {}
-                };
-                // Also query remote APIs
-                const repoInfo = getRepoInfo(projectPath);
-                const repo = params.repo || repoInfo.repoName;
-                const githubOwner = params.owner || process.env.GITHUB_USERNAME;
-                const giteaOwner = params.owner || process.env.GITEA_USERNAME;
-                // GitHub
-                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 || 10,
-                        });
-                        results.providers.github = {
-                            success: true,
-                            commits: commits.data.map((c) => ({
-                                sha: c.sha,
-                                message: c.commit.message,
-                                author: c.commit.author.name,
-                                email: c.commit.author.email,
-                                date: c.commit.author.date,
-                                url: c.html_url,
-                            })),
-                        };
-                    }
-                    catch (err) {
-                        results.providers.github = { success: false, error: err.message };
-                    }
-                }
-                // Gitea
-                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 || 10,
-                            },
-                            headers: { Authorization: `token ${ctx.providerManager.giteaToken}` }
-                        });
-                        results.providers.gitea = {
-                            success: true,
-                            commits: commits.data.map((c) => ({
-                                sha: c.sha,
-                                message: c.commit.message,
-                                author: c.commit.author.name,
-                                email: c.commit.author.email,
-                                date: c.commit.author.date,
-                                url: c.html_url,
-                            })),
-                        };
-                    }
-                    catch (err) {
-                        results.providers.gitea = { success: false, error: err.message };
-                    }
-                }
-                return results;
-            }
-            case 'status': {
-                const status = await git.status(projectPath);
-                const detailed = params.detailed ? {
-                    branch: status.current,
-                    ahead: status.ahead,
-                    behind: status.behind,
-                    staged: status.staged,
-                    modified: status.modified,
-                    deleted: status.deleted,
-                    created: status.created,
-                    renamed: status.renamed,
-                    conflicted: status.conflicted,
-                    not_added: status.not_added,
-                } : status;
-                return { success: true, local: { status: detailed } };
-            }
-            case 'commits': {
-                const branch = params.branch;
-                const options = {
-                    maxCount: params.limit || 50,
-                    ref: branch
-                };
-                const logEntries = await git.log(projectPath, options);
-                const results = {
-                    success: true,
-                    local: {
-                        commits: logEntries.map(c => ({
-                            hash: c.hash,
-                            date: c.date,
-                            message: c.message,
-                            author: c.author_name,
-                            email: c.author_email,
-                        })),
-                    },
-                    providers: {}
-                };
-                // Also query remote APIs
-                const repoInfo = getRepoInfo(projectPath);
-                const repo = params.repo || repoInfo.repoName;
-                const githubOwner = params.owner || process.env.GITHUB_USERNAME;
-                const giteaOwner = params.owner || process.env.GITEA_USERNAME;
-                // GitHub
-                if (ctx.providerManager.github && githubOwner) {
-                    try {
-                        const commits = await ctx.providerManager.github.rest.repos.listCommits({
-                            owner: githubOwner,
-                            repo: repo,
-                            sha: branch,
-                            since: params.since,
-                            per_page: params.limit || 50,
-                        });
-                        results.providers.github = {
-                            success: true,
-                            commits: commits.data.map((c) => ({
-                                sha: c.sha,
-                                message: c.commit.message,
-                                author: c.commit.author.name,
-                                email: c.commit.author.email,
-                                date: c.commit.author.date,
-                            })),
-                        };
-                    }
-                    catch (err) {
-                        results.providers.github = { success: false, error: err.message };
-                    }
-                }
-                // Gitea
-                if (ctx.providerManager.giteaBaseUrl && giteaOwner) {
-                    try {
-                        const commits = await axios.get(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${giteaOwner}/${repo}/commits`, {
-                            params: {
-                                sha: branch,
-                                since: params.since,
-                                limit: params.limit || 50,
-                            },
-                            headers: { Authorization: `token ${ctx.providerManager.giteaToken}` }
-                        });
-                        results.providers.gitea = {
-                            success: true,
-                            commits: commits.data.map((c) => ({
-                                sha: c.sha,
-                                message: c.commit.message,
-                                author: c.commit.author.name,
-                                email: c.commit.author.email,
-                                date: c.commit.author.date,
-                            })),
-                        };
-                    }
-                    catch (err) {
-                        results.providers.gitea = { success: false, error: err.message };
-                    }
-                }
-                return results;
-            }
-            case 'contributors': {
-                const logEntries = await git.log(projectPath);
-                const contributors = new Map();
-                logEntries.forEach(commit => {
-                    const key = commit.author_email;
-                    if (contributors.has(key)) {
-                        contributors.get(key).commits++;
-                    }
-                    else {
-                        contributors.set(key, {
-                            name: commit.author_name,
-                            email: commit.author_email,
-                            commits: 1,
-                        });
-                    }
-                });
-                const sorted = Array.from(contributors.values()).sort((a, b) => b.commits - a.commits);
-                const results = {
-                    success: true,
-                    local: { contributors: sorted },
-                    providers: {}
-                };
-                // Also query remote APIs
-                const repoInfo = getRepoInfo(projectPath);
-                const repo = params.repo || repoInfo.repoName;
-                const githubOwner = params.owner || process.env.GITHUB_USERNAME;
-                const giteaOwner = params.owner || process.env.GITEA_USERNAME;
-                // GitHub
-                if (ctx.providerManager.github && githubOwner) {
-                    try {
-                        const contributors = await ctx.providerManager.github.rest.repos.listContributors({
-                            owner: githubOwner,
-                            repo: repo,
-                        });
-                        results.providers.github = {
-                            success: true,
-                            contributors: contributors.data.map((c) => ({
-                                login: c.login,
-                                contributions: c.contributions,
-                                avatar_url: c.avatar_url,
-                                url: c.html_url,
-                            })),
-                        };
-                    }
-                    catch (err) {
-                        results.providers.github = { success: false, error: err.message };
-                    }
-                }
-                // Gitea
-                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/gitPackages.d.ts

@@ -1,180 +0,0 @@
-import { Tool, MCPContext } from '../types.js';
-export declare class GitPackagesTool implements Tool {
-    name: string;
-    description: string;
-    inputSchema: {
-        type: "object";
-        properties: {
-            projectPath: {
-                type: string;
-                description: string;
-            };
-            action: {
-                type: string;
-                enum: string[];
-                description: string;
-            };
-            confirm: {
-                type: string;
-                description: string;
-            };
-            packageName: {
-                type: string;
-                description: string;
-            };
-            packageType: {
-                type: string;
-                enum: string[];
-                description: string;
-            };
-        };
-        required: string[];
-    };
-    handle(params: Record<string, any>, ctx: MCPContext): Promise<{
-        success: boolean;
-        name: any;
-        version: any;
-        dependencies: any;
-        devDependencies: any;
-        scripts: any;
-        message?: undefined;
-        note?: undefined;
-        created?: undefined;
-        path?: undefined;
-        package?: undefined;
-        updated?: undefined;
-        deleted?: undefined;
-        instructions?: undefined;
-        projectPath?: undefined;
-    } | {
-        success: boolean;
-        message: string;
-        note: string;
-        name?: undefined;
-        version?: undefined;
-        dependencies?: undefined;
-        devDependencies?: undefined;
-        scripts?: undefined;
-        created?: undefined;
-        path?: undefined;
-        package?: undefined;
-        updated?: undefined;
-        deleted?: undefined;
-        instructions?: undefined;
-        projectPath?: undefined;
-    } | {
-        success: boolean;
-        created: boolean;
-        path: string;
-        package: any;
-        name?: undefined;
-        version?: undefined;
-        dependencies?: undefined;
-        devDependencies?: undefined;
-        scripts?: undefined;
-        message?: undefined;
-        note?: undefined;
-        updated?: undefined;
-        deleted?: undefined;
-        instructions?: undefined;
-        projectPath?: undefined;
-    } | {
-        success: boolean;
-        updated: boolean;
-        path: string;
-        package: any;
-        name?: undefined;
-        version?: undefined;
-        dependencies?: undefined;
-        devDependencies?: undefined;
-        scripts?: undefined;
-        message?: undefined;
-        note?: undefined;
-        created?: undefined;
-        deleted?: undefined;
-        instructions?: undefined;
-        projectPath?: undefined;
-    } | {
-        success: boolean;
-        deleted: boolean;
-        path: string;
-        name?: undefined;
-        version?: undefined;
-        dependencies?: undefined;
-        devDependencies?: undefined;
-        scripts?: undefined;
-        message?: undefined;
-        note?: undefined;
-        created?: undefined;
-        package?: undefined;
-        updated?: undefined;
-        instructions?: undefined;
-        projectPath?: undefined;
-    } | {
-        success: boolean;
-        message: string;
-        path: string;
-        name?: undefined;
-        version?: undefined;
-        dependencies?: undefined;
-        devDependencies?: undefined;
-        scripts?: undefined;
-        note?: undefined;
-        created?: undefined;
-        package?: undefined;
-        updated?: undefined;
-        deleted?: undefined;
-        instructions?: undefined;
-        projectPath?: undefined;
-    } | {
-        success: boolean;
-        message: string;
-        instructions: {
-            command: string;
-            registry: any;
-            access: any;
-            tag: any;
-            note: string;
-            package?: undefined;
-            version?: undefined;
-            destination?: undefined;
-        };
-        projectPath: any;
-        name?: undefined;
-        version?: undefined;
-        dependencies?: undefined;
-        devDependencies?: undefined;
-        scripts?: undefined;
-        note?: undefined;
-        created?: undefined;
-        path?: undefined;
-        package?: undefined;
-        updated?: undefined;
-        deleted?: undefined;
-    } | {
-        success: boolean;
-        message: string;
-        instructions: {
-            command: string;
-            package: any;
-            version: any;
-            destination: any;
-            note: string;
-            registry?: undefined;
-            access?: undefined;
-            tag?: undefined;
-        };
-        name?: undefined;
-        version?: undefined;
-        dependencies?: undefined;
-        devDependencies?: undefined;
-        scripts?: undefined;
-        note?: undefined;
-        created?: undefined;
-        path?: undefined;
-        package?: undefined;
-        updated?: undefined;
-        deleted?: undefined;
-        projectPath?: undefined;
-    }>;
-}

package/dist/tools/gitPackages.js

@@ -1,214 +0,0 @@
-import fs from 'fs/promises';
-import path from 'path';
-import { MCPError } from '../utils/errors.js';
-import { normalizeToolParams } from '../utils/repoHelpers.js';
-export class GitPackagesTool {
-    constructor() {
-        this.name = 'git-packages';
-        this.description = 'Package management operations - automatic dual-provider execution';
-        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: ["list", "get", "delete", "versions"],
-                    description: "Package operation to perform: list (list packages), get (get package details), delete (delete package), versions (list package versions)"
-                },
-                confirm: {
-                    type: "boolean",
-                    description: "Confirm destructive operations (optional for delete)"
-                },
-                packageName: {
-                    type: "string",
-                    description: "Package name (required for get/delete/versions)"
-                },
-                packageType: {
-                    type: "string",
-                    enum: ["npm", "container", "maven", "nuget", "rubygems"],
-                    description: "Package type (required for operations)"
-                }
-            },
-            required: ["projectPath", "action"]
-        };
-    }
-    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');
-        switch (action) {
-            case 'list': {
-                if (!projectPath)
-                    throw new MCPError('VALIDATION_ERROR', 'projectPath is required');
-                // Ler package.json
-                try {
-                    const packageJsonPath = path.join(projectPath, 'package.json');
-                    const content = await fs.readFile(packageJsonPath, 'utf-8');
-                    const pkg = JSON.parse(content);
-                    return {
-                        success: true,
-                        name: pkg.name,
-                        version: pkg.version,
-                        dependencies: pkg.dependencies || {},
-                        devDependencies: pkg.devDependencies || {},
-                        scripts: pkg.scripts || {},
-                    };
-                }
-                catch (error) {
-                    throw new MCPError('FILE_ERROR', `Failed to read package.json: ${error.message}`);
-                }
-            }
-            case 'get': {
-                const packageName = params.packageName;
-                if (!packageName)
-                    throw new MCPError('VALIDATION_ERROR', 'packageName is required');
-                return {
-                    success: true,
-                    message: `Package info for ${packageName}`,
-                    note: 'Use npm view or yarn info for detailed package information',
-                };
-            }
-            case 'create': {
-                if (!projectPath)
-                    throw new MCPError('VALIDATION_ERROR', 'projectPath is required');
-                const packageJsonPath = path.join(projectPath, 'package.json');
-                const packageData = {
-                    name: params.name || path.basename(projectPath),
-                    version: params.version || '1.0.0',
-                    description: params.description || '',
-                    main: params.main || 'index.js',
-                    scripts: params.scripts || {},
-                    keywords: params.keywords || [],
-                    author: params.author || '',
-                    license: params.license || 'MIT',
-                };
-                if (params.dependencies)
-                    packageData.dependencies = params.dependencies;
-                if (params.devDependencies)
-                    packageData.devDependencies = params.devDependencies;
-                try {
-                    await fs.writeFile(packageJsonPath, JSON.stringify(packageData, null, 2), 'utf-8');
-                    return {
-                        success: true,
-                        created: true,
-                        path: packageJsonPath,
-                        package: packageData,
-                    };
-                }
-                catch (error) {
-                    throw new MCPError('FILE_ERROR', `Failed to create package.json: ${error.message}`);
-                }
-            }
-            case 'update': {
-                if (!projectPath)
-                    throw new MCPError('VALIDATION_ERROR', 'projectPath is required');
-                const packageJsonPath = path.join(projectPath, 'package.json');
-                try {
-                    const content = await fs.readFile(packageJsonPath, 'utf-8');
-                    const pkg = JSON.parse(content);
-                    // Update fields if provided
-                    if (params.name)
-                        pkg.name = params.name;
-                    if (params.version)
-                        pkg.version = params.version;
-                    if (params.description)
-                        pkg.description = params.description;
-                    if (params.main)
-                        pkg.main = params.main;
-                    if (params.scripts)
-                        pkg.scripts = { ...pkg.scripts, ...params.scripts };
-                    if (params.keywords)
-                        pkg.keywords = params.keywords;
-                    if (params.author)
-                        pkg.author = params.author;
-                    if (params.license)
-                        pkg.license = params.license;
-                    if (params.dependencies)
-                        pkg.dependencies = { ...pkg.dependencies, ...params.dependencies };
-                    if (params.devDependencies)
-                        pkg.devDependencies = { ...pkg.devDependencies, ...params.devDependencies };
-                    await fs.writeFile(packageJsonPath, JSON.stringify(pkg, null, 2), 'utf-8');
-                    return {
-                        success: true,
-                        updated: true,
-                        path: packageJsonPath,
-                        package: pkg,
-                    };
-                }
-                catch (error) {
-                    throw new MCPError('FILE_ERROR', `Failed to update package.json: ${error.message}`);
-                }
-            }
-            case 'delete': {
-                if (!projectPath)
-                    throw new MCPError('VALIDATION_ERROR', 'projectPath is required');
-                const packageJsonPath = path.join(projectPath, 'package.json');
-                try {
-                    await fs.unlink(packageJsonPath);
-                    return {
-                        success: true,
-                        deleted: true,
-                        path: packageJsonPath,
-                    };
-                }
-                catch (error) {
-                    if (error.code === 'ENOENT') {
-                        return {
-                            success: false,
-                            message: 'package.json not found',
-                            path: packageJsonPath,
-                        };
-                    }
-                    throw new MCPError('FILE_ERROR', `Failed to delete package.json: ${error.message}`);
-                }
-            }
-            case 'publish': {
-                if (!projectPath)
-                    throw new MCPError('VALIDATION_ERROR', 'projectPath is required');
-                const registry = params.registry || 'https://registry.npmjs.org';
-                const access = params.access || 'public'; // public or restricted
-                const tag = params.tag || 'latest';
-                const dryRun = params.dryRun || false;
-                return {
-                    success: true,
-                    message: 'To publish, run: npm publish in your terminal',
-                    instructions: {
-                        command: dryRun ? 'npm publish --dry-run' : 'npm publish',
-                        registry,
-                        access,
-                        tag,
-                        note: 'Make sure you are logged in with: npm login',
-                    },
-                    projectPath,
-                };
-            }
-            case 'download': {
-                const packageName = params.packageName;
-                const version = params.version || 'latest';
-                const destination = params.destination || projectPath;
-                if (!packageName)
-                    throw new MCPError('VALIDATION_ERROR', 'packageName is required');
-                if (!destination)
-                    throw new MCPError('VALIDATION_ERROR', 'destination is required');
-                return {
-                    success: true,
-                    message: `To download ${packageName}@${version}, run: npm install ${packageName}@${version} in your terminal`,
-                    instructions: {
-                        command: `npm install ${packageName}@${version}`,
-                        package: packageName,
-                        version,
-                        destination,
-                        note: 'Run this command in your project directory',
-                    },
-                };
-            }
-            default:
-                throw new MCPError('VALIDATION_ERROR', `Unsupported action: ${action}`);
-        }
-    }
-}