@andrebuzeli/git-mcp 9.2.0 → 10.0.1

package/dist/tools/gitUpload.js

@@ -1,5 +1,8 @@
+import simpleGit from 'simple-git';
 import { MCPError } from '../utils/errors.js';
 import axios from 'axios';
+import * as fs from 'fs/promises';
+import * as path from 'path';
 import { getRepoNameFromPath } from '../utils/repoHelpers.js';
 /**
  * Git Upload Tool - Envia projeto completo para GitHub e Gitea automaticamente
@@ -18,15 +21,23 @@ export class GitUploadTool {
                 },
                 repoName: {
                     type: "string",
-                    description: "Repository name (auto-detected from folder if not provided)"
+                    description: "Repository name (optional, auto-detected from projectPath)"
                 },
                 description: {
                     type: "string",
-                    description: "Repository description"
+                    description: "Repository description (optional, defaults to timestamp-based message)"
                 },
                 private: {
                     type: "boolean",
-                    description: "Make repository private (default: true)"
+                    description: "Make repository private (optional, default: true)"
+                },
+                branch: {
+                    type: "string",
+                    description: "Branch to upload (optional, default: 'master')"
+                },
+                commitMessage: {
+                    type: "string",
+                    description: "Commit message (optional, defaults to timestamp-based message)"
                 }
             },
             required: ["projectPath"],
@@ -42,7 +53,7 @@ export class GitUploadTool {
         const description = params.description || `Project uploaded via git-upload at ${new Date().toISOString()}`;
         const isPrivate = params.private !== undefined ? params.private : true;
         const branch = params.branch || 'master';
-        const git = ctx.gitAdapter;
+        const git = simpleGit({ baseDir: projectPath });
         // Resultado com rastreabilidade completa
         const results = {
             success: true,
@@ -60,16 +71,16 @@ export class GitUploadTool {
         try {
             // 0. Verificar se é um repositório Git, se não for, inicializar
             try {
-                await git.status(projectPath);
+                await git.status();
             }
             catch (err) {
-                if (err.message.includes('not a git repository') || err.message.includes('ENOENT')) {
+                if (err.message.includes('not a git repository')) {
                     results.traceability.uploadSteps.push({
                         step: 0,
                         action: 'init_git_repository',
                         timestamp: new Date().toISOString(),
                     });
-                    await git.init(projectPath, branch);
+                    await git.init();
                 }
                 else {
                     throw err;
@@ -81,24 +92,25 @@ export class GitUploadTool {
                 action: 'check_local_status',
                 timestamp: new Date().toISOString(),
             });
-            const status = await git.status(projectPath);
+            const status = await git.status();
             results.traceability.localChanges = {
                 modified: status.modified,
                 created: status.created,
                 deleted: status.deleted,
                 renamed: status.renamed,
+                staged: status.staged,
                 conflicted: status.conflicted,
-                isClean: status.isClean,
+                isClean: status.isClean(),
             };
             // 2. Verificar se tem mudanças
-            if (!status.isClean) {
+            if (!status.isClean()) {
                 results.traceability.uploadSteps.push({
                     step: 2,
                     action: 'stage_all_changes',
                     timestamp: new Date().toISOString(),
                     files: [...status.modified, ...status.created, ...status.deleted],
                 });
-                await git.add(projectPath, ['.']);
+                await git.add('.');
             }
             // 3. Commit com rastreabilidade
             const commitMessage = params.commitMessage || `[git-upload] Upload project at ${new Date().toISOString()}`;
@@ -110,12 +122,12 @@ export class GitUploadTool {
             });
             let commitResult;
             try {
-                const commitHash = await git.commit(projectPath, commitMessage);
-                const currentBranch = await git.getCurrentBranch(projectPath);
+                commitResult = await git.commit(commitMessage);
                 results.traceability.commit = {
-                    hash: commitHash,
-                    summary: commitMessage,
-                    branch: currentBranch,
+                    hash: commitResult.commit,
+                    summary: commitResult.summary,
+                    branch: commitResult.branch,
+                    author: commitResult.author,
                 };
             }
             catch (err) {
@@ -128,8 +140,8 @@ export class GitUploadTool {
             }
             // 4. Criar repositórios remotos em ambos providers
             // Nota: Cada provider precisa usar seu próprio username (Gitea é case-sensitive)
-            const githubOwner = await ctx.providerManager.getGitHubUsername();
-            const giteaOwner = await ctx.providerManager.getGiteaUsername();
+            const githubOwner = process.env.GITHUB_USERNAME;
+            const giteaOwner = process.env.GITEA_USERNAME;
             // GITHUB
             if (ctx.providerManager.github) {
                 results.traceability.uploadSteps.push({
@@ -169,10 +181,10 @@ export class GitUploadTool {
                         };
                     }
                     // Adicionar remote se necessário
-                    const remotes = await git.listRemotes(projectPath);
+                    const remotes = await git.getRemotes(true);
                     const githubRemote = remotes.find(r => r.name === 'github');
                     if (!githubRemote) {
-                        await git.addRemote(projectPath, 'github', `https://github.com/${githubOwner}/${repoName}.git`);
+                        await git.addRemote('github', `https://github.com/${githubOwner}/${repoName}.git`);
                         results.traceability.uploadSteps.push({
                             step: 5,
                             action: 'add_github_remote',
@@ -188,7 +200,7 @@ export class GitUploadTool {
                         branch,
                     });
                     try {
-                        await git.push(projectPath, 'github', branch, true);
+                        await git.push('github', branch, ['--set-upstream', '--force']);
                         results.providers.github.pushed = true;
                         results.providers.github.pushStatus = 'success';
                     }
@@ -256,11 +268,11 @@ export class GitUploadTool {
                         };
                     }
                     // Adicionar remote se necessário
-                    const remotes = await git.listRemotes(projectPath);
+                    const remotes = await git.getRemotes(true);
                     const giteaRemote = remotes.find(r => r.name === 'gitea');
                     if (!giteaRemote) {
                         const giteaUrl = `${ctx.providerManager.giteaBaseUrl}/${giteaOwner}/${repoName}.git`;
-                        await git.addRemote(projectPath, 'gitea', giteaUrl);
+                        await git.addRemote('gitea', giteaUrl);
                         results.traceability.uploadSteps.push({
                             step: 8,
                             action: 'add_gitea_remote',
@@ -276,7 +288,7 @@ export class GitUploadTool {
                         branch,
                     });
                     try {
-                        await git.push(projectPath, 'gitea', branch, true);
+                        await git.push('gitea', branch, ['--set-upstream', '--force']);
                         results.providers.gitea.pushed = true;
                         results.providers.gitea.pushStatus = 'success';
                     }
@@ -305,11 +317,35 @@ export class GitUploadTool {
                     });
                 }
             }
+            // 5. Salvar histórico local
+            await this.saveUploadHistory(projectPath, results);
             return results;
         }
         catch (err) {
             throw new MCPError('UPLOAD_ERROR', `Failed to upload project: ${err.message}`);
         }
     }
+    async saveUploadHistory(projectPath, results) {
+        try {
+            const historyDir = path.join(projectPath, '.git-mcp-history');
+            await fs.mkdir(historyDir, { recursive: true });
+            const historyFile = path.join(historyDir, `upload-${Date.now()}.json`);
+            await fs.writeFile(historyFile, JSON.stringify(results, null, 2), 'utf-8');
+            // Também manter um log consolidado
+            const logFile = path.join(historyDir, 'upload-log.jsonl');
+            const logEntry = JSON.stringify({
+                timestamp: results.timestamp,
+                repoName: results.repoName,
+                branch: results.branch,
+                github: results.providers.github?.success || false,
+                gitea: results.providers.gitea?.success || false,
+                errors: results.traceability.errors.length,
+            }) + '\n';
+            await fs.appendFile(logFile, logEntry, 'utf-8');
+        }
+        catch (err) {
+            // Não falhar se não conseguir salvar histórico
+            console.warn('Failed to save upload history:', err);
+        }
+    }
 }
-//# sourceMappingURL=gitUpload.js.map

package/dist/tools/gitWorkflow.d.ts

@@ -11,6 +11,7 @@ export declare class GitWorkflowTool implements Tool {
             };
             action: {
                 type: string;
+                enum: string[];
                 description: string;
             };
             message: {
@@ -24,10 +25,85 @@ export declare class GitWorkflowTool implements Tool {
                 };
                 description: string;
             };
+            remote: {
+                type: string;
+                description: string;
+            };
+            branch: {
+                type: string;
+                description: string;
+            };
+            backupPath: {
+                type: string;
+                description: string;
+            };
+            name: {
+                type: string;
+                description: string;
+            };
+            owner: {
+                type: string;
+                description: string;
+            };
+            repo: {
+                type: string;
+                description: string;
+            };
+            description: {
+                type: string;
+                description: string;
+            };
+            private: {
+                type: string;
+                description: string;
+            };
+            has_issues: {
+                type: string;
+                description: string;
+            };
+            has_projects: {
+                type: string;
+                description: string;
+            };
+            has_wiki: {
+                type: string;
+                description: string;
+            };
+            organization: {
+                type: string;
+                description: string;
+            };
+            query: {
+                type: string;
+                description: string;
+            };
+            sort: {
+                type: string;
+                description: string;
+            };
+            order: {
+                type: string;
+                description: string;
+            };
+            limit: {
+                type: string;
+                description: string;
+            };
+            force: {
+                type: string;
+                description: string;
+            };
+            setUpstream: {
+                type: string;
+                description: string;
+            };
+            bare: {
+                type: string;
+                description: string;
+            };
         };
         required: string[];
         additionalProperties: boolean;
     };
     handle(params: Record<string, any>, ctx: MCPContext): Promise<any>;
 }
-//# sourceMappingURL=gitWorkflow.d.ts.map

package/dist/tools/gitWorkflow.js

@@ -1,3 +1,4 @@
+import simpleGit from 'simple-git';
 import { MCPError } from '../utils/errors.js';
 import { normalizeToolParams } from '../utils/repoHelpers.js';
 import axios from 'axios';
@@ -14,7 +15,8 @@ export class GitWorkflowTool {
                 },
                 action: {
                     type: "string",
-                    description: "Action to perform: init, status, commit, sync, backup, create, list, get, update, delete, fork, search, push"
+                    enum: ["init", "status", "commit", "sync", "backup", "create", "list", "get", "update", "delete", "fork", "search", "push"],
+                    description: "Action to perform: init (initialize repo), status (get repo status), commit (commit changes), sync (fetch/pull/push), backup (create backup), create (create repo on providers), list (list user repos), get (get repo details), update (update repo settings), delete (delete repo), fork (fork repo), search (search repos), push (push to remote)"
                 },
                 message: {
                     type: "string",
@@ -23,7 +25,83 @@ export class GitWorkflowTool {
                 files: {
                     type: "array",
                     items: { type: "string" },
-                    description: "Files to add (default: ['.'])"
+                    description: "Files to add (optional for commit, default: ['.'])"
+                },
+                remote: {
+                    type: "string",
+                    description: "Remote name (optional for sync/push, default: 'origin')"
+                },
+                branch: {
+                    type: "string",
+                    description: "Branch name (optional for sync/push)"
+                },
+                backupPath: {
+                    type: "string",
+                    description: "Path for backup file (optional for backup)"
+                },
+                name: {
+                    type: "string",
+                    description: "Repository name (required for create)"
+                },
+                owner: {
+                    type: "string",
+                    description: "Repository owner (optional for create/get/update/delete/fork, uses env vars if not provided)"
+                },
+                repo: {
+                    type: "string",
+                    description: "Repository name (required for get/update/delete/fork)"
+                },
+                description: {
+                    type: "string",
+                    description: "Repository description (optional for create/update)"
+                },
+                private: {
+                    type: "boolean",
+                    description: "Make repository private (optional for create/update, default: true)"
+                },
+                has_issues: {
+                    type: "boolean",
+                    description: "Enable issues (optional for update)"
+                },
+                has_projects: {
+                    type: "boolean",
+                    description: "Enable projects (optional for update)"
+                },
+                has_wiki: {
+                    type: "boolean",
+                    description: "Enable wiki (optional for update)"
+                },
+                organization: {
+                    type: "string",
+                    description: "Organization for fork (optional for fork)"
+                },
+                query: {
+                    type: "string",
+                    description: "Search query (required for search)"
+                },
+                sort: {
+                    type: "string",
+                    description: "Sort field (optional for search)"
+                },
+                order: {
+                    type: "string",
+                    description: "Sort order (optional for search)"
+                },
+                limit: {
+                    type: "number",
+                    description: "Result limit (optional for search, default: 30)"
+                },
+                force: {
+                    type: "boolean",
+                    description: "Force push (optional for push, default: false)"
+                },
+                setUpstream: {
+                    type: "boolean",
+                    description: "Set upstream (optional for push, default: false)"
+                },
+                bare: {
+                    type: "boolean",
+                    description: "Initialize as bare repo (optional for init, default: false)"
                 }
             },
             required: ["projectPath", "action"],
@@ -37,63 +115,44 @@ export class GitWorkflowTool {
         if (!action)
             throw new MCPError('VALIDATION_ERROR', 'action is required. You can use either "action" or "command" parameter.');
         const projectPath = params.projectPath;
-        const git = ctx.gitAdapter;
+        const git = projectPath ? simpleGit({ baseDir: projectPath }) : null;
         switch (action) {
             case 'init': {
-                if (!projectPath)
+                if (!projectPath || !git)
                     throw new MCPError('VALIDATION_ERROR', 'projectPath is required for init');
-                await git.init(projectPath, params.defaultBranch || 'master');
+                await git.init(params.bare || false);
                 return { success: true, path: projectPath };
             }
             case 'status': {
-                if (!projectPath)
+                if (!projectPath || !git)
                     throw new MCPError('VALIDATION_ERROR', 'projectPath is required for status');
-                const status = await git.status(projectPath);
+                const status = await git.status();
                 return { success: true, status };
             }
             case 'commit': {
-                if (!projectPath)
+                if (!projectPath || !git)
                     throw new MCPError('VALIDATION_ERROR', 'projectPath is required for commit');
                 const message = params.message;
                 if (!message)
                     throw new MCPError('VALIDATION_ERROR', 'Commit message is required');
                 const files = params.files || ['.'];
-                await git.add(projectPath, files);
-                const result = await git.commit(projectPath, message);
-                // Push automático com force para todos os remotes configurados
-                const remotes = await git.listRemotes(projectPath);
-                const pushResults = {};
-                for (const remote of remotes) {
-                    try {
-                        const currentBranch = await git.getCurrentBranch(projectPath);
-                        await git.push(projectPath, remote.name, currentBranch, true);
-                        pushResults[remote.name] = {
-                            success: true,
-                            branch: currentBranch,
-                        };
-                    }
-                    catch (err) {
-                        pushResults[remote.name] = {
-                            success: false,
-                            error: err.message,
-                        };
-                    }
-                }
-                return {
-                    success: true,
-                    commit: result,
-                    pushed: pushResults,
-                    message: 'Commit created and pushed with --force to all remotes',
-                };
+                await git.add(files);
+                const result = await git.commit(message);
+                return { success: true, commit: result };
             }
             case 'sync': {
-                if (!projectPath)
+                if (!projectPath || !git)
                     throw new MCPError('VALIDATION_ERROR', 'projectPath is required for sync');
                 const remote = params.remote || 'origin';
-                const branch = params.branch || await git.getCurrentBranch(projectPath);
-                await git.fetch(projectPath, remote);
-                await git.pull(projectPath, remote, branch);
-                await git.push(projectPath, remote, branch);
+                const branch = params.branch;
+                await git.fetch(remote);
+                if (branch) {
+                    await git.pull(remote, branch);
+                }
+                else {
+                    await git.pull();
+                }
+                await git.push();
                 return { success: true, message: 'Repository synced' };
             }
             case 'backup': {
@@ -104,8 +163,8 @@ export class GitWorkflowTool {
                 const name = params.name;
                 if (!name)
                     throw new MCPError('VALIDATION_ERROR', 'name is required');
-                const githubOwner = await ctx.providerManager.getGitHubUsername();
-                const giteaOwner = await ctx.providerManager.getGiteaUsername();
+                const githubOwner = params.owner || process.env.GITHUB_USERNAME;
+                const giteaOwner = params.owner || process.env.GITEA_USERNAME;
                 const results = { success: true, providers: {} };
                 // GitHub
                 if (ctx.providerManager.github) {
@@ -162,11 +221,11 @@ export class GitWorkflowTool {
                 return results;
             }
             case 'get': {
-                const githubOwner = await ctx.providerManager.getGitHubUsername();
-                const giteaOwner = await ctx.providerManager.getGiteaUsername();
+                const githubOwner = params.owner || process.env.GITHUB_USERNAME;
+                const giteaOwner = params.owner || process.env.GITEA_USERNAME;
                 const repo = params.repo;
-                if (!repo) {
-                    throw new MCPError('VALIDATION_ERROR', 'repo is required');
+                if (!githubOwner || !repo) {
+                    throw new MCPError('VALIDATION_ERROR', 'owner and repo are required');
                 }
                 const results = { success: true, providers: {} };
                 // GitHub
@@ -192,11 +251,11 @@ export class GitWorkflowTool {
                 return results;
             }
             case 'update': {
-                const githubOwner = await ctx.providerManager.getGitHubUsername();
-                const giteaOwner = await ctx.providerManager.getGiteaUsername();
+                const githubOwner = params.owner || process.env.GITHUB_USERNAME;
+                const giteaOwner = params.owner || process.env.GITEA_USERNAME;
                 const repo = params.repo;
-                if (!repo) {
-                    throw new MCPError('VALIDATION_ERROR', 'repo is required');
+                if (!githubOwner || !repo) {
+                    throw new MCPError('VALIDATION_ERROR', 'owner and repo are required');
                 }
                 const results = { success: true, providers: {} };
                 // GitHub
@@ -236,11 +295,11 @@ export class GitWorkflowTool {
                 return results;
             }
             case 'delete': {
-                const githubOwner = await ctx.providerManager.getGitHubUsername();
-                const giteaOwner = await ctx.providerManager.getGiteaUsername();
+                const githubOwner = params.owner || process.env.GITHUB_USERNAME;
+                const giteaOwner = params.owner || process.env.GITEA_USERNAME;
                 const repo = params.repo;
-                if (!repo) {
-                    throw new MCPError('VALIDATION_ERROR', 'repo is required');
+                if (!githubOwner || !repo) {
+                    throw new MCPError('VALIDATION_ERROR', 'owner and repo are required');
                 }
                 const results = { success: true, providers: {} };
                 // GitHub
@@ -266,11 +325,11 @@ export class GitWorkflowTool {
                 return results;
             }
             case 'fork': {
-                const githubOwner = await ctx.providerManager.getGitHubUsername();
-                const giteaOwner = await ctx.providerManager.getGiteaUsername();
+                const githubOwner = params.owner || process.env.GITHUB_USERNAME;
+                const giteaOwner = params.owner || process.env.GITEA_USERNAME;
                 const repo = params.repo;
-                if (!repo) {
-                    throw new MCPError('VALIDATION_ERROR', 'repo is required');
+                if (!githubOwner || !repo) {
+                    throw new MCPError('VALIDATION_ERROR', 'owner and repo are required');
                 }
                 const results = { success: true, providers: {} };
                 // GitHub
@@ -335,18 +394,30 @@ export class GitWorkflowTool {
                 return results;
             }
             case 'push': {
-                if (!projectPath)
+                if (!projectPath || !git)
                     throw new MCPError('VALIDATION_ERROR', 'projectPath is required for push');
                 const remote = params.remote || 'origin';
-                const branch = params.branch || await git.getCurrentBranch(projectPath);
+                const branch = params.branch;
                 const force = params.force || false;
+                const setUpstream = params.setUpstream || false;
+                const pushOptions = [];
+                if (force)
+                    pushOptions.push('--force');
+                if (setUpstream)
+                    pushOptions.push('--set-upstream');
                 try {
-                    await git.push(projectPath, remote, branch, force);
+                    const pushResult = await git.push(remote, branch, pushOptions);
                     return {
                         success: true,
                         remote,
-                        branch,
+                        branch: branch || 'current',
                         force,
+                        setUpstream,
+                        result: {
+                            pushed: pushResult.pushed || [],
+                            remoteMessages: pushResult.remoteMessages?.all || [],
+                            update: pushResult.update,
+                        },
                     };
                 }
                 catch (err) {
@@ -354,9 +425,7 @@ export class GitWorkflowTool {
                 }
             }
             default:
-                const validActions = ["init", "status", "commit", "sync", "backup", "create", "list", "get", "update", "delete", "fork", "search", "push"];
-                throw new MCPError('VALIDATION_ERROR', `Unsupported action: ${action}. Valid actions: ${validActions.join(', ')}`);
+                throw new MCPError('VALIDATION_ERROR', `Unsupported action: ${action}`);
         }
     }
 }
-//# sourceMappingURL=gitWorkflow.js.map

package/dist/types.d.ts

@@ -8,12 +8,7 @@ export type ToolHandleResult = any;
 export interface Tool {
     name: string;
     description?: string;
-    inputSchema?: {
-        type: string;
-        properties?: Record<string, any>;
-        required?: string[];
-        additionalProperties?: boolean;
-    };
+    inputSchema?: any;
     handle(params: Record<string, any>, ctx: MCPContext): Promise<ToolHandleResult>;
 }
 export interface Resource {
@@ -23,4 +18,3 @@ export interface Resource {
     mimeType: string;
     content: string;
 }
-//# sourceMappingURL=types.d.ts.map

package/dist/types.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=types.js.map

package/dist/utils/apiHelpers.d.ts

@@ -27,4 +27,3 @@ export declare function validateStatsResponse(response: any): any;
  */
 export declare function validateContributorsResponse(response: any): any[];
 export {};
-//# sourceMappingURL=apiHelpers.d.ts.map

package/dist/utils/apiHelpers.js

@@ -123,4 +123,3 @@ export function validateContributorsResponse(response) {
     }
     return response.data;
 }
-//# sourceMappingURL=apiHelpers.js.map

package/dist/utils/errors.d.ts

@@ -11,4 +11,3 @@ export declare class MCPError extends Error {
     suggestions?: string[];
     constructor(code: string, message: string, suggestions?: string[]);
 }
-//# sourceMappingURL=errors.d.ts.map

package/dist/utils/errors.js

@@ -15,4 +15,3 @@ export class MCPError extends Error {
         this.suggestions = suggestions;
     }
 }
-//# sourceMappingURL=errors.js.map