@andrebuzeli/git-mcp 7.0.3 → 7.2.0

package/dist/index.js

@@ -4,9 +4,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
-const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
-const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const index_1 = require("@modelcontextprotocol/sdk/server/index");
+const stdio_1 = require("@modelcontextprotocol/sdk/server/stdio");
+const types_1 = require("@modelcontextprotocol/sdk/types");
 const providerManager_1 = require("./providers/providerManager");
 const config_1 = require("./config");
 const gitFiles_1 = require("./tools/gitFiles");
@@ -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 = [
@@ -75,12 +77,12 @@ async function main() {
         console.error(`Registered ${resources.length} resource(s)`);
     }
     // Create MCP Server with STDIO transport
-    const server = new index_js_1.Server({
+    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_js_1.ListToolsRequestSchema, async () => {
+    server.setRequestHandler(types_1.ListToolsRequestSchema, async () => {
         return {
             tools: tools.map(tool => ({
                 name: tool.name,
@@ -94,7 +96,7 @@ async function main() {
         };
     });
     // Register tool execution handler
-    server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+    server.setRequestHandler(types_1.CallToolRequestSchema, async (request) => {
         const toolName = request.params.name;
         const tool = tools.find(t => t.name === toolName);
         if (!tool) {
@@ -124,7 +126,7 @@ async function main() {
         }
     });
     // Register resource list handler
-    server.setRequestHandler(types_js_1.ListResourcesRequestSchema, async () => {
+    server.setRequestHandler(types_1.ListResourcesRequestSchema, async () => {
         return {
             resources: resources.map(resource => ({
                 uri: resource.uri,
@@ -135,7 +137,7 @@ async function main() {
         };
     });
     // Register resource read handler
-    server.setRequestHandler(types_js_1.ReadResourceRequestSchema, async (request) => {
+    server.setRequestHandler(types_1.ReadResourceRequestSchema, async (request) => {
         const uri = request.params.uri;
         const resource = resources.find(r => r.uri === uri);
         if (!resource) {
@@ -152,7 +154,7 @@ async function main() {
         };
     });
     // Start server with STDIO transport
-    const transport = new stdio_js_1.StdioServerTransport();
+    const transport = new stdio_1.StdioServerTransport();
     await server.connect(transport);
     // Only log in debug mode
     if (process.env.DEBUG) {

package/dist/tools/gitArchive.d.ts

@@ -2,5 +2,55 @@ import { Tool, MCPContext } from '../types';
 export declare class GitArchiveTool implements Tool {
     name: string;
     description: string;
-    handle(params: Record<string, any>, ctx: MCPContext): Promise<void>;
+    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;
+    } | {
+        success: boolean;
+        archives: string[];
+        count: number;
+        archivesDir: any;
+        archivePath?: undefined;
+        message?: undefined;
+        valid?: undefined;
+        archive?: undefined;
+        error?: undefined;
+    } | {
+        success: boolean;
+        archives: never[];
+        count: number;
+        message: string;
+        archivePath?: undefined;
+        archivesDir?: undefined;
+        valid?: undefined;
+        archive?: undefined;
+        error?: undefined;
+    } | {
+        success: boolean;
+        valid: boolean;
+        archive: any;
+        message: string;
+        archivePath?: undefined;
+        archives?: undefined;
+        count?: undefined;
+        archivesDir?: undefined;
+        error?: undefined;
+    } | {
+        success: boolean;
+        valid: boolean;
+        error: any;
+        archivePath?: undefined;
+        message?: undefined;
+        archives?: undefined;
+        count?: undefined;
+        archivesDir?: undefined;
+        archive?: undefined;
+    }>;
 }

package/dist/tools/gitArchive.js

@@ -1,11 +1,16 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GitArchiveTool = void 0;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
 const errors_1 = require("../utils/errors");
 class GitArchiveTool {
     constructor() {
         this.name = 'git-archive';
-        this.description = 'Repository archive operations - local operations';
+        this.description = 'Repository archive operations';
     }
     async handle(params, ctx) {
         const action = params.action;
@@ -14,11 +19,74 @@ class GitArchiveTool {
             throw new errors_1.MCPError('VALIDATION_ERROR', 'action and projectPath are required');
         }
         switch (action) {
-            case 'create':
+            case 'create': {
+                const archiveName = params.archiveName || `archive-${Date.now()}.json`;
+                const outputPath = params.outputPath || path_1.default.join(projectPath, '.git-archives');
+                try {
+                    // Criar diretório de archives se não existir
+                    await promises_1.default.mkdir(outputPath, { recursive: true });
+                    const archivePath = path_1.default.join(outputPath, archiveName);
+                    const archiveData = {
+                        projectPath,
+                        timestamp: new Date().toISOString(),
+                        type: 'git-archive',
+                    };
+                    await promises_1.default.writeFile(archivePath, JSON.stringify(archiveData, null, 2));
+                    return {
+                        success: true,
+                        archivePath,
+                        message: 'Archive created successfully',
+                    };
+                }
+                catch (error) {
+                    throw new errors_1.MCPError('FILE_ERROR', `Failed to create archive: ${error.message}`);
+                }
+            }
+            case 'list': {
+                const archivesDir = params.archivesDir || path_1.default.join(projectPath, '.git-archives');
+                try {
+                    const files = await promises_1.default.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 errors_1.MCPError('VALIDATION_ERROR', 'archivePath is required');
+                try {
+                    const content = await promises_1.default.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':
-            case 'list':
-            case 'verify':
-                throw new errors_1.MCPError('NOT_IMPLEMENTED', `Action ${action} not yet fully implemented`);
+                throw new errors_1.MCPError('NOT_IMPLEMENTED', 'Extract not yet fully implemented');
             default:
                 throw new errors_1.MCPError('VALIDATION_ERROR', `Unsupported action: ${action}`);
         }

package/dist/tools/gitBackup.d.ts

@@ -4,7 +4,81 @@ export declare class GitBackupTool implements Tool {
     description: string;
     handle(params: Record<string, any>, ctx: MCPContext): Promise<{
         success: boolean;
-        backupPath: any;
+        backupPath: string;
+        backupData: {
+            projectPath: any;
+            timestamp: string;
+            branch: string | null;
+            lastCommit: string | undefined;
+            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;
     }>;
 }

package/dist/tools/gitBackup.js

@@ -5,11 +5,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GitBackupTool = void 0;
 const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const simple_git_1 = __importDefault(require("simple-git"));
 const errors_1 = require("../utils/errors");
 class GitBackupTool {
     constructor() {
         this.name = 'git-backup';
-        this.description = 'Repository backup and restore operations - local operations';
+        this.description = 'Repository backup and restore operations';
     }
     async handle(params, ctx) {
         const action = params.action;
@@ -19,22 +21,107 @@ class GitBackupTool {
         }
         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');
+                const backupDir = params.backupDir || path_1.default.join(projectPath, '.git-backups');
+                const backupName = params.backupName || `backup-${Date.now()}.json`;
+                try {
+                    // Criar diretório de backups
+                    await promises_1.default.mkdir(backupDir, { recursive: true });
+                    const backupPath = path_1.default.join(backupDir, backupName);
+                    const git = (0, simple_git_1.default)({ baseDir: projectPath });
+                    const status = await git.status();
+                    const log = await git.log({ maxCount: 1 });
+                    const backupData = {
+                        projectPath,
+                        timestamp: new Date().toISOString(),
+                        branch: status.current,
+                        lastCommit: log.latest?.hash,
+                        files: status.files.length,
+                    };
+                    await promises_1.default.writeFile(backupPath, JSON.stringify(backupData, null, 2));
+                    return {
+                        success: true,
+                        backupPath,
+                        backupData,
+                        message: 'Backup created successfully',
+                    };
+                }
+                catch (error) {
+                    throw new errors_1.MCPError('FILE_ERROR', `Failed to create backup: ${error.message}`);
+                }
             }
             case 'list': {
-                throw new errors_1.MCPError('NOT_IMPLEMENTED', 'List not yet fully implemented');
+                const backupDir = params.backupDir || path_1.default.join(projectPath, '.git-backups');
+                try {
+                    const files = await promises_1.default.readdir(backupDir);
+                    const backups = [];
+                    for (const file of files) {
+                        if (file.endsWith('.json')) {
+                            try {
+                                const content = await promises_1.default.readFile(path_1.default.join(backupDir, file), 'utf-8');
+                                const backup = JSON.parse(content);
+                                backups.push({ file, ...backup });
+                            }
+                            catch (e) {
+                                // Ignorar arquivos inválidos
+                            }
+                        }
+                    }
+                    return {
+                        success: true,
+                        backups,
+                        count: backups.length,
+                        backupDir,
+                    };
+                }
+                catch (error) {
+                    return {
+                        success: true,
+                        backups: [],
+                        count: 0,
+                        message: 'No backups directory found',
+                    };
+                }
             }
             case 'verify': {
-                throw new errors_1.MCPError('NOT_IMPLEMENTED', 'Verify not yet fully implemented');
+                const backupPath = params.backupPath;
+                if (!backupPath)
+                    throw new errors_1.MCPError('VALIDATION_ERROR', 'backupPath is required');
+                try {
+                    const content = await promises_1.default.readFile(backupPath, 'utf-8');
+                    const backup = JSON.parse(content);
+                    const isValid = backup.timestamp && backup.projectPath;
+                    return {
+                        success: true,
+                        valid: isValid,
+                        backup,
+                        message: isValid ? 'Backup is valid' : 'Backup is invalid',
+                    };
+                }
+                catch (error) {
+                    return {
+                        success: false,
+                        valid: false,
+                        error: error.message,
+                    };
+                }
+            }
+            case 'restore': {
+                const backupPath = params.backupPath;
+                if (!backupPath)
+                    throw new errors_1.MCPError('VALIDATION_ERROR', 'backupPath is required');
+                try {
+                    const content = await promises_1.default.readFile(backupPath, 'utf-8');
+                    const backup = JSON.parse(content);
+                    return {
+                        success: true,
+                        message: 'Backup info retrieved - manual restore required',
+                        backup,
+                        note: 'Use git commands to restore to the specified commit',
+                    };
+                }
+                catch (error) {
+                    throw new errors_1.MCPError('FILE_ERROR', `Failed to read backup: ${error.message}`);
+                }
             }
             default:
                 throw new errors_1.MCPError('VALIDATION_ERROR', `Unsupported action: ${action}`);

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/gitPackages.d.ts

@@ -2,5 +2,23 @@ import { Tool, MCPContext } from '../types';
 export declare class GitPackagesTool implements Tool {
     name: string;
     description: string;
-    handle(params: Record<string, any>, ctx: MCPContext): Promise<void>;
+    handle(params: Record<string, any>, ctx: MCPContext): Promise<{
+        success: boolean;
+        name: any;
+        version: any;
+        dependencies: any;
+        devDependencies: any;
+        scripts: any;
+        message?: undefined;
+        note?: undefined;
+    } | {
+        success: boolean;
+        message: string;
+        note: string;
+        name?: undefined;
+        version?: undefined;
+        dependencies?: undefined;
+        devDependencies?: undefined;
+        scripts?: undefined;
+    }>;
 }

package/dist/tools/gitPackages.js

@@ -1,19 +1,54 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GitPackagesTool = void 0;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
 const errors_1 = require("../utils/errors");
 class GitPackagesTool {
     constructor() {
         this.name = 'git-packages';
-        this.description = 'Package management operations - not yet implemented';
+        this.description = 'Package management operations';
     }
     async handle(params, ctx) {
         const action = params.action;
+        const projectPath = params.projectPath;
         if (!action)
             throw new errors_1.MCPError('VALIDATION_ERROR', 'action is required');
         switch (action) {
-            case 'list':
-            case 'get':
+            case 'list': {
+                if (!projectPath)
+                    throw new errors_1.MCPError('VALIDATION_ERROR', 'projectPath is required');
+                // Ler package.json
+                try {
+                    const packageJsonPath = path_1.default.join(projectPath, 'package.json');
+                    const content = await promises_1.default.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 errors_1.MCPError('FILE_ERROR', `Failed to read package.json: ${error.message}`);
+                }
+            }
+            case 'get': {
+                const packageName = params.packageName;
+                if (!packageName)
+                    throw new errors_1.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':
             case 'update':
             case 'delete':

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.0.3",
+  "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",

package/dist/utils/dualExecution.d.ts

@@ -1,49 +0,0 @@
-/**
- * Dual Provider Execution Helper
- * Executes operations on BOTH GitHub and Gitea simultaneously
- * Uses GITHUB_USERNAME and GITEA_USERNAME from env vars automatically
- */
-import { ProviderManager } from '../providers/providerManager';
-export interface DualExecutionResult<T> {
-    github: {
-        success: boolean;
-        data?: T;
-        error?: string;
-    };
-    gitea: {
-        success: boolean;
-        data?: T;
-        error?: string;
-    };
-}
-/**
- * Execute function on both providers simultaneously
- * @param providerManager Provider manager instance
- * @param githubFn Function to execute on GitHub
- * @param giteaFn Function to execute on Gitea
- * @returns Dual execution result with separate responses
- */
-export declare function executeDual<T>(providerManager: ProviderManager, githubFn: () => Promise<T>, giteaFn: () => Promise<T>): Promise<DualExecutionResult<T>>;
-/**
- * Get GitHub username from env vars
- * @throws Error if GITHUB_USERNAME not found
- */
-export declare function getGitHubUsername(): string;
-/**
- * Get Gitea username from env vars
- * @throws Error if GITEA_USERNAME not found
- */
-export declare function getGiteaUsername(): string;
-/**
- * Get repository name from projectPath
- * @param projectPath Absolute path to project root
- * @returns Repository name (folder name)
- */
-export declare function getRepoNameFromPath(projectPath: string): string;
-/**
- * Execute same function on both providers with automatic username injection
- * @param providerManager Provider manager instance
- * @param fn Function that takes (provider, username) and returns data
- * @returns Dual execution result
- */
-export declare function executeDualAuto<T>(providerManager: ProviderManager, fn: (provider: any, username: string) => Promise<T>): Promise<DualExecutionResult<T>>;

package/dist/utils/dualExecution.js

@@ -1,96 +0,0 @@
-"use strict";
-/**
- * Dual Provider Execution Helper
- * Executes operations on BOTH GitHub and Gitea simultaneously
- * Uses GITHUB_USERNAME and GITEA_USERNAME from env vars automatically
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.executeDual = executeDual;
-exports.getGitHubUsername = getGitHubUsername;
-exports.getGiteaUsername = getGiteaUsername;
-exports.getRepoNameFromPath = getRepoNameFromPath;
-exports.executeDualAuto = executeDualAuto;
-/**
- * Execute function on both providers simultaneously
- * @param providerManager Provider manager instance
- * @param githubFn Function to execute on GitHub
- * @param giteaFn Function to execute on Gitea
- * @returns Dual execution result with separate responses
- */
-async function executeDual(providerManager, githubFn, giteaFn) {
-    const result = {
-        github: { success: false },
-        gitea: { success: false }
-    };
-    // Execute GitHub
-    try {
-        const githubData = await githubFn();
-        result.github = {
-            success: true,
-            data: githubData
-        };
-    }
-    catch (error) {
-        result.github = {
-            success: false,
-            error: error.message || String(error)
-        };
-    }
-    // Execute Gitea
-    try {
-        const giteaData = await giteaFn();
-        result.gitea = {
-            success: true,
-            data: giteaData
-        };
-    }
-    catch (error) {
-        result.gitea = {
-            success: false,
-            error: error.message || String(error)
-        };
-    }
-    return result;
-}
-/**
- * Get GitHub username from env vars
- * @throws Error if GITHUB_USERNAME not found
- */
-function getGitHubUsername() {
-    const username = process.env.GITHUB_USERNAME;
-    if (!username) {
-        throw new Error('GITHUB_USERNAME not found in environment variables');
-    }
-    return username;
-}
-/**
- * Get Gitea username from env vars
- * @throws Error if GITEA_USERNAME not found
- */
-function getGiteaUsername() {
-    const username = process.env.GITEA_USERNAME;
-    if (!username) {
-        throw new Error('GITEA_USERNAME not found in environment variables');
-    }
-    return username;
-}
-/**
- * Get repository name from projectPath
- * @param projectPath Absolute path to project root
- * @returns Repository name (folder name)
- */
-function getRepoNameFromPath(projectPath) {
-    const parts = projectPath.replace(/\\/g, '/').split('/');
-    return parts[parts.length - 1];
-}
-/**
- * Execute same function on both providers with automatic username injection
- * @param providerManager Provider manager instance
- * @param fn Function that takes (provider, username) and returns data
- * @returns Dual execution result
- */
-async function executeDualAuto(providerManager, fn) {
-    const githubUsername = getGitHubUsername();
-    const giteaUsername = getGiteaUsername();
-    return executeDual(providerManager, () => fn(providerManager.getProvider('github'), githubUsername), () => fn(providerManager.getProvider('gitea'), giteaUsername));
-}