@andrebuzeli/git-mcp 5.5.0 → 5.5.2

package/dist/tools/gitAnalytics.d.ts

@@ -0,0 +1,29 @@
+import { Tool, MCPContext } from '../types';
+export declare class GitAnalyticsTool implements Tool {
+    name: string;
+    description: string;
+    handle(params: Record<string, any>, ctx: MCPContext): Promise<{
+        success: boolean;
+        stats: {
+            totalCommits: number;
+            branches: number;
+            tags: number;
+            latestCommit: (import("simple-git").DefaultLogFields & import("simple-git").ListLogLine) | null;
+        };
+        commits?: undefined;
+        details?: undefined;
+        contributors?: undefined;
+    } | {
+        success: boolean;
+        commits: number;
+        details: readonly (import("simple-git").DefaultLogFields & import("simple-git").ListLogLine)[];
+        stats?: undefined;
+        contributors?: undefined;
+    } | {
+        success: boolean;
+        contributors: any[];
+        stats?: undefined;
+        commits?: undefined;
+        details?: undefined;
+    }>;
+}

package/dist/tools/gitAnalytics.js

@@ -0,0 +1,72 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitAnalyticsTool = void 0;
+const simple_git_1 = __importDefault(require("simple-git"));
+const errors_1 = require("../utils/errors");
+class GitAnalyticsTool {
+    constructor() {
+        this.name = 'git-analytics';
+        this.description = 'Repository analytics and statistics';
+    }
+    async handle(params, ctx) {
+        const action = params.action;
+        const projectPath = params.projectPath;
+        if (!action || !projectPath) {
+            throw new errors_1.MCPError('VALIDATION_ERROR', 'action and projectPath are required');
+        }
+        const git = (0, simple_git_1.default)({ baseDir: projectPath });
+        switch (action) {
+            case 'stats': {
+                const log = await git.log();
+                const branches = await git.branch();
+                const tags = await git.tags();
+                return {
+                    success: true,
+                    stats: {
+                        totalCommits: log.total,
+                        branches: branches.all.length,
+                        tags: tags.all.length,
+                        latestCommit: log.latest,
+                    },
+                };
+            }
+            case 'commits': {
+                const since = params.since;
+                const until = params.until;
+                const log = await git.log({
+                    from: since,
+                    to: until,
+                    maxCount: params.limit || 1000,
+                });
+                return {
+                    success: true,
+                    commits: log.all.length,
+                    details: log.all,
+                };
+            }
+            case 'contributors': {
+                const log = await git.log();
+                const contributors = new Map();
+                log.all.forEach(commit => {
+                    const author = commit.author_name;
+                    if (contributors.has(author)) {
+                        contributors.get(author).count++;
+                    }
+                    else {
+                        contributors.set(author, { name: author, email: commit.author_email, count: 1 });
+                    }
+                });
+                return {
+                    success: true,
+                    contributors: Array.from(contributors.values()).sort((a, b) => b.count - a.count),
+                };
+            }
+            default:
+                throw new errors_1.MCPError('VALIDATION_ERROR', `Unsupported action: ${action}`);
+        }
+    }
+}
+exports.GitAnalyticsTool = GitAnalyticsTool;

package/dist/tools/gitArchive.d.ts

@@ -0,0 +1,6 @@
+import { Tool, MCPContext } from '../types';
+export declare class GitArchiveTool implements Tool {
+    name: string;
+    description: string;
+    handle(params: Record<string, any>, ctx: MCPContext): Promise<void>;
+}

package/dist/tools/gitArchive.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitArchiveTool = void 0;
+const errors_1 = require("../utils/errors");
+class GitArchiveTool {
+    constructor() {
+        this.name = 'git-archive';
+        this.description = 'Repository archive operations';
+    }
+    async handle(params, ctx) {
+        const action = params.action;
+        const projectPath = params.projectPath;
+        if (!action || !projectPath) {
+            throw new errors_1.MCPError('VALIDATION_ERROR', 'action and projectPath are required');
+        }
+        switch (action) {
+            case 'create':
+            case 'extract':
+            case 'list':
+            case 'verify':
+                throw new errors_1.MCPError('NOT_IMPLEMENTED', `Action ${action} not yet fully implemented`);
+            default:
+                throw new errors_1.MCPError('VALIDATION_ERROR', `Unsupported action: ${action}`);
+        }
+    }
+}
+exports.GitArchiveTool = GitArchiveTool;

package/dist/tools/gitBackup.d.ts

@@ -0,0 +1,10 @@
+import { Tool, MCPContext } from '../types';
+export declare class GitBackupTool implements Tool {
+    name: string;
+    description: string;
+    handle(params: Record<string, any>, ctx: MCPContext): Promise<{
+        success: boolean;
+        backupPath: any;
+        message: string;
+    }>;
+}

package/dist/tools/gitBackup.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitBackupTool = void 0;
+const promises_1 = __importDefault(require("fs/promises"));
+const errors_1 = require("../utils/errors");
+class GitBackupTool {
+    constructor() {
+        this.name = 'git-backup';
+        this.description = 'Repository backup and restore operations';
+    }
+    async handle(params, ctx) {
+        const action = params.action;
+        const projectPath = params.projectPath;
+        if (!action || !projectPath) {
+            throw new errors_1.MCPError('VALIDATION_ERROR', 'action and projectPath are required');
+        }
+        switch (action) {
+            case 'backup': {
+                const backupPath = params.backupPath || `${projectPath}-backup-${Date.now()}.tar.gz`;
+                // Simplified: just create a marker file
+                await promises_1.default.writeFile(backupPath, JSON.stringify({
+                    path: projectPath,
+                    timestamp: new Date().toISOString(),
+                }));
+                return { success: true, backupPath, message: 'Backup created (simplified)' };
+            }
+            case 'restore': {
+                throw new errors_1.MCPError('NOT_IMPLEMENTED', 'Restore not yet fully implemented');
+            }
+            case 'list': {
+                throw new errors_1.MCPError('NOT_IMPLEMENTED', 'List not yet fully implemented');
+            }
+            case 'verify': {
+                throw new errors_1.MCPError('NOT_IMPLEMENTED', 'Verify not yet fully implemented');
+            }
+            default:
+                throw new errors_1.MCPError('VALIDATION_ERROR', `Unsupported action: ${action}`);
+        }
+    }
+}
+exports.GitBackupTool = GitBackupTool;

package/dist/tools/gitBranches.d.ts

@@ -0,0 +1,72 @@
+import { Tool, MCPContext } from '../types';
+export declare class GitBranchesTool implements Tool {
+    name: string;
+    description: string;
+    handle(params: Record<string, any>, ctx: MCPContext): Promise<{
+        success: boolean;
+        branch: any;
+        branches?: undefined;
+        current?: undefined;
+        deleted?: undefined;
+        result?: undefined;
+        baseBranch?: undefined;
+        compareBranch?: undefined;
+        commits?: undefined;
+        diff?: undefined;
+    } | {
+        branches: string[];
+        current: string;
+        success?: undefined;
+        branch?: undefined;
+        deleted?: undefined;
+        result?: undefined;
+        baseBranch?: undefined;
+        compareBranch?: undefined;
+        commits?: undefined;
+        diff?: undefined;
+    } | {
+        branch: string;
+        current: boolean;
+        success?: undefined;
+        branches?: undefined;
+        deleted?: undefined;
+        result?: undefined;
+        baseBranch?: undefined;
+        compareBranch?: undefined;
+        commits?: undefined;
+        diff?: undefined;
+    } | {
+        success: boolean;
+        deleted: any;
+        branch?: undefined;
+        branches?: undefined;
+        current?: undefined;
+        result?: undefined;
+        baseBranch?: undefined;
+        compareBranch?: undefined;
+        commits?: undefined;
+        diff?: undefined;
+    } | {
+        success: boolean;
+        result: import("simple-git").MergeResult;
+        branch?: undefined;
+        branches?: undefined;
+        current?: undefined;
+        deleted?: undefined;
+        baseBranch?: undefined;
+        compareBranch?: undefined;
+        commits?: undefined;
+        diff?: undefined;
+    } | {
+        baseBranch: any;
+        compareBranch: any;
+        commits: readonly (import("simple-git").DefaultLogFields & import("simple-git").ListLogLine)[];
+        diff: string;
+        success?: undefined;
+        branch?: undefined;
+        branches?: undefined;
+        current?: undefined;
+        deleted?: undefined;
+        result?: undefined;
+    }>;
+}

package/dist/tools/gitBranches.js

@@ -0,0 +1,97 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitBranchesTool = void 0;
+const simple_git_1 = __importDefault(require("simple-git"));
+const errors_1 = require("../utils/errors");
+const safetyController_1 = require("../utils/safetyController");
+class GitBranchesTool {
+    constructor() {
+        this.name = 'git-branches';
+        this.description = 'Branch management operations';
+    }
+    async handle(params, ctx) {
+        const action = params.action;
+        const projectPath = params.projectPath;
+        if (!action || !projectPath) {
+            throw new errors_1.MCPError('VALIDATION_ERROR', 'action and projectPath are required');
+        }
+        const git = (0, simple_git_1.default)({ baseDir: projectPath });
+        switch (action) {
+            case 'create': {
+                const branchName = params.branchName;
+                if (!branchName)
+                    throw new errors_1.MCPError('VALIDATION_ERROR', 'branchName is required');
+                const sourceBranch = params.sourceBranch;
+                if (sourceBranch) {
+                    await git.checkout(sourceBranch);
+                }
+                await git.checkoutLocalBranch(branchName);
+                if (params.checkout !== false) {
+                    await git.checkout(branchName);
+                }
+                return { success: true, branch: branchName };
+            }
+            case 'list': {
+                const branches = await git.branch();
+                return {
+                    branches: branches.all,
+                    current: branches.current,
+                };
+            }
+            case 'get': {
+                const branchName = params.branchName;
+                if (!branchName)
+                    throw new errors_1.MCPError('VALIDATION_ERROR', 'branchName is required');
+                const branches = await git.branch();
+                const branch = branches.all.find(b => b === branchName);
+                if (!branch) {
+                    throw new errors_1.MCPError('BRANCH_NOT_FOUND', `Branch '${branchName}' not found`, [
+                        'Check if the branch name is correct',
+                        'Use git branch -a to see all available branches',
+                    ]);
+                }
+                return { branch, current: branches.current === branchName };
+            }
+            case 'delete': {
+                (0, safetyController_1.requireConfirmationIfDestructive)('delete', params);
+                const branchName = params.branchName;
+                if (!branchName)
+                    throw new errors_1.MCPError('VALIDATION_ERROR', 'branchName is required');
+                await git.deleteLocalBranch(branchName, params.force);
+                return { success: true, deleted: branchName };
+            }
+            case 'merge': {
+                const branchName = params.branchName;
+                const targetBranch = params.targetBranch;
+                if (!branchName)
+                    throw new errors_1.MCPError('VALIDATION_ERROR', 'branchName is required');
+                if (targetBranch) {
+                    await git.checkout(targetBranch);
+                }
+                const result = await git.merge([branchName]);
+                return { success: true, result };
+            }
+            case 'compare': {
+                const baseBranch = params.baseBranch;
+                const compareBranch = params.compareBranch;
+                if (!baseBranch || !compareBranch) {
+                    throw new errors_1.MCPError('VALIDATION_ERROR', 'baseBranch and compareBranch are required');
+                }
+                const diff = await git.diff([`${baseBranch}...${compareBranch}`]);
+                const log = await git.log({ from: baseBranch, to: compareBranch });
+                return {
+                    baseBranch,
+                    compareBranch,
+                    commits: log.all,
+                    diff,
+                };
+            }
+            default:
+                throw new errors_1.MCPError('VALIDATION_ERROR', `Unsupported action: ${action}`);
+        }
+    }
+}
+exports.GitBranchesTool = GitBranchesTool;

package/dist/tools/gitConfig.d.ts

@@ -0,0 +1,34 @@
+import { Tool, MCPContext } from '../types';
+export declare class GitConfigTool implements Tool {
+    name: string;
+    description: string;
+    handle(params: Record<string, any>, ctx: MCPContext): Promise<{
+        success: boolean;
+        key: any;
+        value: any;
+        message?: undefined;
+        scope?: undefined;
+        configs?: undefined;
+    } | {
+        success: boolean;
+        key: any;
+        message: string;
+        value?: undefined;
+        scope?: undefined;
+        configs?: undefined;
+    } | {
+        success: boolean;
+        scope: string;
+        configs: import("simple-git").ConfigValues;
+        key?: undefined;
+        value?: undefined;
+        message?: undefined;
+    } | {
+        success: boolean;
+        key: any;
+        value: string | null;
+        scope: string | undefined;
+        message?: undefined;
+        configs?: undefined;
+    }>;
+}

package/dist/tools/gitConfig.js

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitConfigTool = void 0;
+const simple_git_1 = __importDefault(require("simple-git"));
+const errors_1 = require("../utils/errors");
+class GitConfigTool {
+    constructor() {
+        this.name = 'git-config';
+        this.description = 'Git configuration management';
+    }
+    async handle(params, ctx) {
+        const action = params.action;
+        const projectPath = params.projectPath;
+        if (!action || !projectPath) {
+            throw new errors_1.MCPError('VALIDATION_ERROR', 'action and projectPath are required');
+        }
+        const git = (0, simple_git_1.default)({ baseDir: projectPath });
+        const scope = params.global ? 'global' : params.system ? 'system' : 'local';
+        switch (action) {
+            case 'get': {
+                const key = params.key;
+                if (!key)
+                    throw new errors_1.MCPError('VALIDATION_ERROR', 'key is required');
+                try {
+                    const value = await git.getConfig(key, scope);
+                    return { success: true, key, value: value.value };
+                }
+                catch (err) {
+                    throw new errors_1.MCPError('CONFIG_NOT_FOUND', `Configuration key '${key}' not found`);
+                }
+            }
+            case 'set': {
+                const key = params.key;
+                const value = params.value;
+                if (!key || value === undefined)
+                    throw new errors_1.MCPError('VALIDATION_ERROR', 'key and value are required');
+                await git.addConfig(key, value, false, scope);
+                return { success: true, key, value };
+            }
+            case 'unset': {
+                const key = params.key;
+                if (!key)
+                    throw new errors_1.MCPError('VALIDATION_ERROR', 'key is required');
+                await git.raw(['config', `--${scope}`, '--unset', key]);
+                return { success: true, key, message: 'Configuration removed' };
+            }
+            case 'list': {
+                const configs = await git.listConfig(scope);
+                return { success: true, scope, configs: configs.all };
+            }
+            case 'show': {
+                const key = params.key;
+                if (!key)
+                    throw new errors_1.MCPError('VALIDATION_ERROR', 'key is required');
+                const value = await git.getConfig(key, scope);
+                return {
+                    success: true,
+                    key,
+                    value: value.value,
+                    scope: params.showScope ? scope : undefined,
+                };
+            }
+            case 'edit':
+                throw new errors_1.MCPError('NOT_IMPLEMENTED', 'Edit action requires manual editing of config file');
+            default:
+                throw new errors_1.MCPError('VALIDATION_ERROR', `Unsupported action: ${action}`);
+        }
+    }
+}
+exports.GitConfigTool = GitConfigTool;

package/dist/tools/gitFiles.d.ts

@@ -0,0 +1,24 @@
+import { Tool } from '../types';
+export declare class GitFilesTool implements Tool {
+    name: string;
+    description: string;
+    handle(params: Record<string, any>): Promise<{
+        path: string;
+        content: string;
+        files?: undefined;
+        matches?: undefined;
+    } | {
+        files: string[];
+        path?: undefined;
+        content?: undefined;
+        matches?: undefined;
+    } | {
+        matches: {
+            file: string;
+            snippet: string;
+        }[];
+        path?: undefined;
+        content?: undefined;
+        files?: undefined;
+    }>;
+}

package/dist/tools/gitFiles.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitFilesTool = void 0;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const errors_1 = require("../utils/errors");
+class GitFilesTool {
+    constructor() {
+        this.name = 'git-files';
+        this.description = 'Read-only file operations for repositories';
+    }
+    async handle(params) {
+        const action = params.action;
+        const projectPath = params.projectPath;
+        if (!action || !projectPath)
+            throw new errors_1.MCPError('VALIDATION_ERROR', 'action and projectPath are required');
+        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 };
+        }
+        if (action === 'list') {
+            const files = await promises_1.default.readdir(projectPath);
+            return { files };
+        }
+        // Blocked operations
+        if (['create', 'update', 'delete'].includes(action)) {
+            throw new errors_1.MCPError('OPERATION_RESTRICTED', 'File modification operations are blocked via MCP.');
+        }
+        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 matches = [];
+            for (const f of files) {
+                try {
+                    const txt = await promises_1.default.readFile(path_1.default.join(projectPath, f), 'utf8');
+                    if (txt.includes(q))
+                        matches.push({ file: f, snippet: txt.substr(txt.indexOf(q), 200) });
+                }
+                catch (e) {
+                    // ignore binary/unreadable
+                }
+            }
+            return { matches };
+        }
+        throw new errors_1.MCPError('VALIDATION_ERROR', `Unsupported action: ${action}`);
+    }
+}
+exports.GitFilesTool = GitFilesTool;

package/dist/tools/gitIssues.d.ts

@@ -0,0 +1,21 @@
+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;
+    }>;
+}