@andrebuzeli/git-mcp 7.1.0 → 7.2.0

package/dist/index.js

@@ -30,6 +30,7 @@ const gitUpload_1 = require("./tools/gitUpload");
 const gitUpdate_1 = require("./tools/gitUpdate");
 const gitHistory_1 = require("./tools/gitHistory");
 const gitFix_tool_1 = require("./tools/gitFix.tool");
+const gitIgnore_1 = require("./tools/gitIgnore");
 const toolsGuide_1 = __importDefault(require("./resources/toolsGuide"));
 async function main() {
     // Load optional mcp.json configuration (will populate process.env if values present)
@@ -41,7 +42,7 @@ async function main() {
     if (process.env.DEBUG) {
         console.error('Provider validation:', JSON.stringify(validation, null, 2));
     }
-    // Register all 21 Git tools
+    // Register all 22 Git tools
     const tools = [
         new gitWorkflow_1.GitWorkflowTool(),
         new gitFiles_1.GitFilesTool(),
@@ -64,6 +65,7 @@ async function main() {
         new gitUpdate_1.GitUpdateTool(),
         new gitHistory_1.GitHistoryTool(),
         new gitFix_tool_1.GitFixTool(),
+        new gitIgnore_1.GitIgnoreTool(),
     ];
     // Register resources
     const resources = [
@@ -77,7 +79,7 @@ async function main() {
     // Create MCP Server with STDIO transport
     const server = new index_1.Server({
         name: '@andrebuzeli/git-mcp',
-        version: '6.3.2',
+        version: '7.2.0',
     });
     // Register tool list handler
     server.setRequestHandler(types_1.ListToolsRequestSchema, async () => {

package/dist/tools/gitIgnore.d.ts

@@ -0,0 +1,191 @@
+import { Tool, MCPContext } from '../types';
+/**
+ * Git Ignore Tool - Manage .gitignore file
+ * Create, read, add, remove patterns, and ensure .gitignore exists
+ */
+export declare class GitIgnoreTool implements Tool {
+    name: string;
+    description: string;
+    handle(params: Record<string, any>, ctx: MCPContext): Promise<{
+        success: boolean;
+        path: string;
+        exists: boolean;
+        content: string;
+        patterns: string[];
+        lines: number;
+        message?: undefined;
+        created?: undefined;
+        template?: undefined;
+        action?: undefined;
+        added?: undefined;
+        skipped?: undefined;
+        total?: undefined;
+        removed?: undefined;
+        remaining?: undefined;
+        updated?: undefined;
+        cleared?: undefined;
+    } | {
+        success: boolean;
+        path: string;
+        exists: boolean;
+        message: string;
+        content?: undefined;
+        patterns?: undefined;
+        lines?: undefined;
+        created?: undefined;
+        template?: undefined;
+        action?: undefined;
+        added?: undefined;
+        skipped?: undefined;
+        total?: undefined;
+        removed?: undefined;
+        remaining?: undefined;
+        updated?: undefined;
+        cleared?: undefined;
+    } | {
+        success: boolean;
+        message: string;
+        path: string;
+        exists?: undefined;
+        content?: undefined;
+        patterns?: undefined;
+        lines?: undefined;
+        created?: undefined;
+        template?: undefined;
+        action?: undefined;
+        added?: undefined;
+        skipped?: undefined;
+        total?: undefined;
+        removed?: undefined;
+        remaining?: undefined;
+        updated?: undefined;
+        cleared?: undefined;
+    } | {
+        success: boolean;
+        path: string;
+        created: boolean;
+        template: any;
+        lines: number;
+        exists?: undefined;
+        content?: undefined;
+        patterns?: undefined;
+        message?: undefined;
+        action?: undefined;
+        added?: undefined;
+        skipped?: undefined;
+        total?: undefined;
+        removed?: undefined;
+        remaining?: undefined;
+        updated?: undefined;
+        cleared?: undefined;
+    } | {
+        success: boolean;
+        path: string;
+        exists: boolean;
+        action: string;
+        message: string;
+        content?: undefined;
+        patterns?: undefined;
+        lines?: undefined;
+        created?: undefined;
+        template?: undefined;
+        added?: undefined;
+        skipped?: undefined;
+        total?: undefined;
+        removed?: undefined;
+        remaining?: undefined;
+        updated?: undefined;
+        cleared?: undefined;
+    } | {
+        success: boolean;
+        path: string;
+        created: boolean;
+        template: any;
+        action: string;
+        exists?: undefined;
+        content?: undefined;
+        patterns?: undefined;
+        lines?: undefined;
+        message?: undefined;
+        added?: undefined;
+        skipped?: undefined;
+        total?: undefined;
+        removed?: undefined;
+        remaining?: undefined;
+        updated?: undefined;
+        cleared?: undefined;
+    } | {
+        success: boolean;
+        path: string;
+        added: string[];
+        skipped: number;
+        total: number;
+        exists?: undefined;
+        content?: undefined;
+        patterns?: undefined;
+        lines?: undefined;
+        message?: undefined;
+        created?: undefined;
+        template?: undefined;
+        action?: undefined;
+        removed?: undefined;
+        remaining?: undefined;
+        updated?: undefined;
+        cleared?: undefined;
+    } | {
+        success: boolean;
+        path: string;
+        removed: number;
+        remaining: number;
+        exists?: undefined;
+        content?: undefined;
+        patterns?: undefined;
+        lines?: undefined;
+        message?: undefined;
+        created?: undefined;
+        template?: undefined;
+        action?: undefined;
+        added?: undefined;
+        skipped?: undefined;
+        total?: undefined;
+        updated?: undefined;
+        cleared?: undefined;
+    } | {
+        success: boolean;
+        path: string;
+        updated: boolean;
+        lines: any;
+        exists?: undefined;
+        content?: undefined;
+        patterns?: undefined;
+        message?: undefined;
+        created?: undefined;
+        template?: undefined;
+        action?: undefined;
+        added?: undefined;
+        skipped?: undefined;
+        total?: undefined;
+        removed?: undefined;
+        remaining?: undefined;
+        cleared?: undefined;
+    } | {
+        success: boolean;
+        path: string;
+        cleared: boolean;
+        template: any;
+        exists?: undefined;
+        content?: undefined;
+        patterns?: undefined;
+        lines?: undefined;
+        message?: undefined;
+        created?: undefined;
+        action?: undefined;
+        added?: undefined;
+        skipped?: undefined;
+        total?: undefined;
+        removed?: undefined;
+        remaining?: undefined;
+        updated?: undefined;
+    }>;
+    private getTemplate;
+}

package/dist/tools/gitIgnore.js

@@ -0,0 +1,354 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitIgnoreTool = void 0;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const errors_1 = require("../utils/errors");
+/**
+ * Git Ignore Tool - Manage .gitignore file
+ * Create, read, add, remove patterns, and ensure .gitignore exists
+ */
+class GitIgnoreTool {
+    constructor() {
+        this.name = 'git-ignore';
+        this.description = 'Manage .gitignore file - create, add, remove, and update ignore patterns';
+    }
+    async handle(params, ctx) {
+        const projectPath = params.projectPath;
+        if (!projectPath) {
+            throw new errors_1.MCPError('VALIDATION_ERROR', 'projectPath is required');
+        }
+        const action = params.action || 'read';
+        const gitignorePath = path.join(projectPath, '.gitignore');
+        switch (action) {
+            case 'read': {
+                try {
+                    const content = await fs.readFile(gitignorePath, 'utf-8');
+                    const patterns = content.split('\n').filter(l => l.trim() && !l.startsWith('#'));
+                    return {
+                        success: true,
+                        path: gitignorePath,
+                        exists: true,
+                        content,
+                        patterns,
+                        lines: content.split('\n').length,
+                    };
+                }
+                catch (err) {
+                    if (err.code === 'ENOENT') {
+                        return {
+                            success: true,
+                            path: gitignorePath,
+                            exists: false,
+                            message: '.gitignore does not exist',
+                        };
+                    }
+                    throw err;
+                }
+            }
+            case 'create': {
+                const template = params.template || 'default';
+                const content = this.getTemplate(template);
+                try {
+                    await fs.access(gitignorePath);
+                    return {
+                        success: false,
+                        message: '.gitignore already exists. Use "add" to add patterns.',
+                        path: gitignorePath,
+                    };
+                }
+                catch {
+                    await fs.writeFile(gitignorePath, content, 'utf-8');
+                    return {
+                        success: true,
+                        path: gitignorePath,
+                        created: true,
+                        template,
+                        lines: content.split('\n').length,
+                    };
+                }
+            }
+            case 'ensure': {
+                // Create if doesn't exist, otherwise do nothing
+                try {
+                    await fs.access(gitignorePath);
+                    return {
+                        success: true,
+                        path: gitignorePath,
+                        exists: true,
+                        action: 'none',
+                        message: '.gitignore already exists',
+                    };
+                }
+                catch {
+                    const template = params.template || 'default';
+                    const content = this.getTemplate(template);
+                    await fs.writeFile(gitignorePath, content, 'utf-8');
+                    return {
+                        success: true,
+                        path: gitignorePath,
+                        created: true,
+                        template,
+                        action: 'created',
+                    };
+                }
+            }
+            case 'add': {
+                const patterns = params.patterns;
+                if (!patterns || !Array.isArray(patterns) || patterns.length === 0) {
+                    throw new errors_1.MCPError('VALIDATION_ERROR', 'patterns array is required for add action');
+                }
+                let content = '';
+                try {
+                    content = await fs.readFile(gitignorePath, 'utf-8');
+                }
+                catch (err) {
+                    if (err.code === 'ENOENT') {
+                        // Create new file
+                        content = this.getTemplate('minimal');
+                    }
+                    else {
+                        throw err;
+                    }
+                }
+                const existingPatterns = new Set(content.split('\n').map(l => l.trim()).filter(l => l && !l.startsWith('#')));
+                const newPatterns = [];
+                for (const pattern of patterns) {
+                    if (!existingPatterns.has(pattern)) {
+                        newPatterns.push(pattern);
+                        existingPatterns.add(pattern);
+                    }
+                }
+                if (newPatterns.length > 0) {
+                    const comment = params.comment ? `# ${params.comment}\n` : '';
+                    content += `\n${comment}${newPatterns.join('\n')}\n`;
+                    await fs.writeFile(gitignorePath, content, 'utf-8');
+                }
+                return {
+                    success: true,
+                    path: gitignorePath,
+                    added: newPatterns,
+                    skipped: patterns.length - newPatterns.length,
+                    total: existingPatterns.size,
+                };
+            }
+            case 'remove': {
+                const patterns = params.patterns;
+                if (!patterns || !Array.isArray(patterns) || patterns.length === 0) {
+                    throw new errors_1.MCPError('VALIDATION_ERROR', 'patterns array is required for remove action');
+                }
+                let content = '';
+                try {
+                    content = await fs.readFile(gitignorePath, 'utf-8');
+                }
+                catch (err) {
+                    if (err.code === 'ENOENT') {
+                        return {
+                            success: false,
+                            message: '.gitignore does not exist',
+                            path: gitignorePath,
+                        };
+                    }
+                    throw err;
+                }
+                const patternsToRemove = new Set(patterns);
+                const lines = content.split('\n');
+                const filteredLines = lines.filter(line => {
+                    const trimmed = line.trim();
+                    return !patternsToRemove.has(trimmed);
+                });
+                const removed = lines.length - filteredLines.length;
+                const newContent = filteredLines.join('\n');
+                await fs.writeFile(gitignorePath, newContent, 'utf-8');
+                return {
+                    success: true,
+                    path: gitignorePath,
+                    removed,
+                    remaining: filteredLines.filter(l => l.trim() && !l.startsWith('#')).length,
+                };
+            }
+            case 'update': {
+                const content = params.content;
+                if (!content) {
+                    throw new errors_1.MCPError('VALIDATION_ERROR', 'content is required for update action');
+                }
+                await fs.writeFile(gitignorePath, content, 'utf-8');
+                return {
+                    success: true,
+                    path: gitignorePath,
+                    updated: true,
+                    lines: content.split('\n').length,
+                };
+            }
+            case 'clear': {
+                const template = params.template || 'empty';
+                const content = template === 'empty' ? '' : this.getTemplate('minimal');
+                await fs.writeFile(gitignorePath, content, 'utf-8');
+                return {
+                    success: true,
+                    path: gitignorePath,
+                    cleared: true,
+                    template,
+                };
+            }
+            default:
+                throw new errors_1.MCPError('VALIDATION_ERROR', `Unsupported action: ${action}`);
+        }
+    }
+    getTemplate(template) {
+        const templates = {
+            empty: '',
+            minimal: `# Dependencies
+node_modules/
+.pnp
+.pnp.js
+
+# Build output
+dist/
+build/
+*.log
+`,
+            default: `# Dependencies
+node_modules/
+.pnp
+.pnp.js
+bower_components/
+
+# Build output
+dist/
+build/
+out/
+.next/
+.nuxt/
+.cache/
+.parcel-cache/
+
+# Environment
+.env
+.env.local
+.env.*.local
+*.env
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+.DS_Store
+
+# Logs
+logs/
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+lerna-debug.log*
+pnpm-debug.log*
+
+# Testing
+coverage/
+.nyc_output/
+*.lcov
+
+# Temporary
+tmp/
+temp/
+*.tmp
+`,
+            node: `# Node
+node_modules/
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+lerna-debug.log*
+pnpm-debug.log*
+.pnpm-store/
+.npm
+.eslintcache
+.node_repl_history
+*.tgz
+.yarn-integrity
+.env
+.env.test
+.env.production
+.cache
+.next/
+out/
+build/
+dist/
+`,
+            python: `# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+pip-log.txt
+pip-delete-this-directory.txt
+.tox/
+.coverage
+.pytest_cache/
+.mypy_cache/
+.dmypy.json
+dmypy.json
+.env
+.venv
+env/
+venv/
+ENV/
+`,
+        };
+        return templates[template] || templates.default;
+    }
+}
+exports.GitIgnoreTool = GitIgnoreTool;

package/dist/tools/gitUpdate.js

@@ -145,14 +145,107 @@ class GitUpdateTool {
                     throw err;
                 }
             }
-            // 5. Get remotes
+            // 5. Get remotes and ensure repos exist
             const remotes = await git.getRemotes(true);
-            const githubRemote = remotes.find(r => r.name === 'github' || r.name === 'origin');
-            const giteaRemote = remotes.find(r => r.name === 'gitea');
+            let githubRemote = remotes.find(r => r.name === 'github' || r.name === 'origin');
+            let giteaRemote = remotes.find(r => r.name === 'gitea');
+            // Auto-create repos if they don't exist
+            const repoName = params.repoName || path.basename(projectPath);
+            const description = params.description || `Project updated via git-update at ${new Date().toISOString()}`;
+            const isPrivate = params.private !== undefined ? params.private : true;
+            const githubOwner = params.owner || process.env.GITHUB_USERNAME;
+            const giteaOwner = process.env.GITEA_USERNAME;
+            // 5a. Ensure GitHub repo exists
+            if (ctx.providerManager.github && !githubRemote) {
+                results.traceability.updateSteps.push({
+                    step: 5,
+                    action: 'ensure_github_repo',
+                    timestamp: new Date().toISOString(),
+                });
+                try {
+                    // Try to get repo, create if doesn't exist
+                    let repoExists = false;
+                    try {
+                        await ctx.providerManager.github.rest.repos.get({
+                            owner: githubOwner,
+                            repo: repoName
+                        });
+                        repoExists = true;
+                    }
+                    catch { }
+                    if (!repoExists) {
+                        await ctx.providerManager.github.rest.repos.createForAuthenticatedUser({
+                            name: repoName,
+                            description,
+                            private: isPrivate,
+                            auto_init: false,
+                        });
+                        results.traceability.updateSteps.push({
+                            step: 5.1,
+                            action: 'created_github_repo',
+                            timestamp: new Date().toISOString(),
+                            repo: repoName,
+                        });
+                    }
+                    // Add remote
+                    await git.addRemote('github', `https://github.com/${githubOwner}/${repoName}.git`);
+                    githubRemote = { name: 'github', refs: { push: `https://github.com/${githubOwner}/${repoName}.git`, fetch: '' } };
+                }
+                catch (err) {
+                    results.traceability.errors.push({
+                        provider: 'github',
+                        action: 'ensure_repo',
+                        error: err.message,
+                        timestamp: new Date().toISOString(),
+                    });
+                }
+            }
+            // 5b. Ensure Gitea repo exists
+            if (ctx.providerManager.giteaBaseUrl && !giteaRemote) {
+                results.traceability.updateSteps.push({
+                    step: 5.5,
+                    action: 'ensure_gitea_repo',
+                    timestamp: new Date().toISOString(),
+                });
+                try {
+                    // Try to get repo, create if doesn't exist
+                    let repoExists = false;
+                    try {
+                        await axios_1.default.get(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${giteaOwner}/${repoName}`, { headers: { Authorization: `token ${ctx.providerManager.giteaToken}` } });
+                        repoExists = true;
+                    }
+                    catch { }
+                    if (!repoExists) {
+                        await axios_1.default.post(`${ctx.providerManager.giteaBaseUrl}/api/v1/user/repos`, {
+                            name: repoName,
+                            description,
+                            private: isPrivate,
+                            auto_init: false,
+                        }, { headers: { Authorization: `token ${ctx.providerManager.giteaToken}` } });
+                        results.traceability.updateSteps.push({
+                            step: 5.6,
+                            action: 'created_gitea_repo',
+                            timestamp: new Date().toISOString(),
+                            repo: repoName,
+                        });
+                    }
+                    // Add remote
+                    await git.addRemote('gitea', `${ctx.providerManager.giteaBaseUrl}/${giteaOwner}/${repoName}.git`);
+                    giteaRemote = { name: 'gitea', refs: { push: `${ctx.providerManager.giteaBaseUrl}/${giteaOwner}/${repoName}.git`, fetch: '' } };
+                }
+                catch (err) {
+                    results.traceability.errors.push({
+                        provider: 'gitea',
+                        action: 'ensure_repo',
+                        error: err.message,
+                        timestamp: new Date().toISOString(),
+                    });
+                }
+            }
             // 6. Push to GITHUB
             if (githubRemote && ctx.providerManager.github) {
                 results.traceability.updateSteps.push({
-                    step: 5,
+                    step: 6,
                     action: 'push_to_github',
                     timestamp: new Date().toISOString(),
                     remote: githubRemote.name,
@@ -204,7 +297,7 @@ class GitUpdateTool {
             // 7. Push to GITEA
             if (giteaRemote && ctx.providerManager.giteaBaseUrl) {
                 results.traceability.updateSteps.push({
-                    step: 6,
+                    step: 7,
                     action: 'push_to_gitea',
                     timestamp: new Date().toISOString(),
                     remote: giteaRemote.name,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@andrebuzeli/git-mcp",
-  "version": "7.1.0",
+  "version": "7.2.0",
   "description": "Professional MCP server for Git operations - STDIO UNIVERSAL: works in ANY IDE (Cursor, VSCode, Claude Desktop). Fully autonomous DUAL execution (GitHub + Gitea APIs) with automatic username detection. All tools execute on BOTH providers simultaneously. No manual parameters needed.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",