@andrebuzeli/git-mcp 2.14.2 → 2.15.0

package/dist/utils/git-operations.js

@@ -0,0 +1,760 @@
+"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.GitOperations = void 0;
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+/**
+ * Classe para operações Git locais - 100% auto-suficiente
+ * Implementa todas as operações Git sem depender de outras tools
+ */
+class GitOperations {
+    projectPath;
+    constructor(projectPath) {
+        this.projectPath = projectPath;
+    }
+    /**
+     * Executa comando Git local
+     */
+    async runGitCommand(command, args = []) {
+        return new Promise((resolve) => {
+            const fullCommand = `git ${command} ${args.join(' ')}`;
+            (0, child_process_1.exec)(fullCommand, {
+                cwd: this.projectPath,
+                maxBuffer: 1024 * 1024 * 10 // 10MB buffer
+            }, (error, stdout, stderr) => {
+                resolve({
+                    success: !error,
+                    output: stdout.trim(),
+                    error: stderr.trim(),
+                    exitCode: error ? error.code || 1 : 0
+                });
+            });
+        });
+    }
+    /**
+     * Executa comando de sistema
+     */
+    async runSystemCommand(command, args = []) {
+        return new Promise((resolve) => {
+            const fullCommand = `${command} ${args.join(' ')}`;
+            (0, child_process_1.exec)(fullCommand, {
+                cwd: this.projectPath,
+                maxBuffer: 1024 * 1024 * 10 // 10MB buffer
+            }, (error, stdout, stderr) => {
+                resolve({
+                    success: !error,
+                    output: stdout.trim(),
+                    error: stderr.trim(),
+                    exitCode: error ? error.code || 1 : 0
+                });
+            });
+        });
+    }
+    /**
+     * Verifica se é um repositório Git
+     */
+    async isGitRepository() {
+        const result = await this.runGitCommand('rev-parse', ['--git-dir']);
+        return result.success;
+    }
+    /**
+     * Inicializa repositório Git
+     */
+    async initRepository(bare = false) {
+        const args = bare ? ['--bare'] : [];
+        return await this.runGitCommand('init', args);
+    }
+    /**
+     * Clona repositório
+     */
+    async cloneRepository(url, directory, options = {}) {
+        const args = [];
+        if (options.bare)
+            args.push('--bare');
+        if (options.depth)
+            args.push('--depth', options.depth.toString());
+        if (options.branch)
+            args.push('--branch', options.branch);
+        if (options.singleBranch)
+            args.push('--single-branch');
+        if (options.recursive)
+            args.push('--recursive');
+        args.push(url);
+        if (directory)
+            args.push(directory);
+        return await this.runGitCommand('clone', args);
+    }
+    /**
+     * Adiciona arquivos ao staging
+     */
+    async addFiles(files = ['.']) {
+        return await this.runGitCommand('add', files);
+    }
+    /**
+     * Remove arquivos do staging
+     */
+    async resetFiles(files = []) {
+        return await this.runGitCommand('reset', files);
+    }
+    /**
+     * Faz commit
+     */
+    async commit(message, options = {}) {
+        const args = [];
+        if (options.amend)
+            args.push('--amend');
+        if (options.noVerify)
+            args.push('--no-verify');
+        if (options.allowEmpty)
+            args.push('--allow-empty');
+        args.push('-m', message);
+        return await this.runGitCommand('commit', args);
+    }
+    /**
+     * Push para remote
+     */
+    async push(remote = 'origin', branch, options = {}) {
+        const args = [];
+        if (options.force)
+            args.push('--force');
+        if (options.setUpstream)
+            args.push('--set-upstream');
+        if (options.tags)
+            args.push('--tags');
+        if (options.all)
+            args.push('--all');
+        args.push(remote);
+        if (branch)
+            args.push(branch);
+        return await this.runGitCommand('push', args);
+    }
+    /**
+     * Pull do remote
+     */
+    async pull(remote = 'origin', branch, options = {}) {
+        const args = [];
+        if (options.rebase)
+            args.push('--rebase');
+        if (options.ffOnly)
+            args.push('--ff-only');
+        if (options.noEdit)
+            args.push('--no-edit');
+        args.push(remote);
+        if (branch)
+            args.push(branch);
+        return await this.runGitCommand('pull', args);
+    }
+    /**
+     * Fetch do remote
+     */
+    async fetch(remote, options = {}) {
+        const args = [];
+        if (options.all)
+            args.push('--all');
+        if (options.tags)
+            args.push('--tags');
+        if (options.prune)
+            args.push('--prune');
+        if (options.depth)
+            args.push('--depth', options.depth.toString());
+        if (remote)
+            args.push(remote);
+        return await this.runGitCommand('fetch', args);
+    }
+    /**
+     * Lista branches
+     */
+    async listBranches(options = {}) {
+        const args = [];
+        if (options.all)
+            args.push('-a');
+        if (options.remote)
+            args.push('-r');
+        if (options.merged)
+            args.push('--merged');
+        if (options.noMerged)
+            args.push('--no-merged');
+        return await this.runGitCommand('branch', args);
+    }
+    /**
+     * Cria branch
+     */
+    async createBranch(name, startPoint, options = {}) {
+        const args = [];
+        if (options.force)
+            args.push('-f');
+        if (options.track)
+            args.push('--track');
+        if (options.noTrack)
+            args.push('--no-track');
+        args.push(name);
+        if (startPoint)
+            args.push(startPoint);
+        return await this.runGitCommand('branch', args);
+    }
+    /**
+     * Deleta branch
+     */
+    async deleteBranch(name, options = {}) {
+        const args = [];
+        if (options.force)
+            args.push('-D');
+        else
+            args.push('-d');
+        args.push(name);
+        return await this.runGitCommand('branch', args);
+    }
+    /**
+     * Checkout branch/commit
+     */
+    async checkout(target, options = {}) {
+        const args = [];
+        if (options.force)
+            args.push('-f');
+        if (options.create)
+            args.push('-b');
+        if (options.track)
+            args.push('--track');
+        args.push(target);
+        return await this.runGitCommand('checkout', args);
+    }
+    /**
+     * Merge branches
+     */
+    async merge(branch, options = {}) {
+        const args = [];
+        if (options.noCommit)
+            args.push('--no-commit');
+        if (options.squash)
+            args.push('--squash');
+        if (options.noEdit)
+            args.push('--no-edit');
+        if (options.strategy)
+            args.push('-s', options.strategy);
+        args.push(branch);
+        return await this.runGitCommand('merge', args);
+    }
+    /**
+     * Rebase
+     */
+    async rebase(target, options = {}) {
+        const args = [];
+        if (options.interactive)
+            args.push('-i');
+        if (options.onto)
+            args.push('--onto', options.onto);
+        if (options.continue)
+            args.push('--continue');
+        if (options.abort)
+            args.push('--abort');
+        if (options.skip)
+            args.push('--skip');
+        args.push(target);
+        return await this.runGitCommand('rebase', args);
+    }
+    /**
+     * Reset
+     */
+    async reset(target, options = {}) {
+        const args = [];
+        if (options.mode)
+            args.push(`--${options.mode}`);
+        if (options.soft)
+            args.push('--soft');
+        if (options.mixed)
+            args.push('--mixed');
+        if (options.hard)
+            args.push('--hard');
+        args.push(target);
+        return await this.runGitCommand('reset', args);
+    }
+    /**
+     * Revert commit
+     */
+    async revert(commit, options = {}) {
+        const args = [];
+        if (options.noCommit)
+            args.push('--no-commit');
+        if (options.edit)
+            args.push('--edit');
+        if (options.mainline)
+            args.push('-m', options.mainline.toString());
+        args.push(commit);
+        return await this.runGitCommand('revert', args);
+    }
+    /**
+     * Cherry-pick
+     */
+    async cherryPick(commit, options = {}) {
+        const args = [];
+        if (options.noCommit)
+            args.push('--no-commit');
+        if (options.edit)
+            args.push('--edit');
+        if (options.mainline)
+            args.push('-m', options.mainline.toString());
+        if (options.continue)
+            args.push('--continue');
+        if (options.abort)
+            args.push('--abort');
+        if (options.skip)
+            args.push('--skip');
+        args.push(commit);
+        return await this.runGitCommand('cherry-pick', args);
+    }
+    /**
+     * Stash
+     */
+    async stash(action = 'push', options = {}) {
+        const args = [];
+        if (action === 'push') {
+            if (options.message)
+                args.push('-m', options.message);
+            if (options.includeUntracked)
+                args.push('-u');
+            if (options.keepIndex)
+                args.push('--keep-index');
+        }
+        else if (action === 'pop') {
+            args.push('pop');
+            if (options.index)
+                args.push('--index');
+        }
+        else if (action === 'apply') {
+            args.push('apply');
+            if (options.index)
+                args.push('--index');
+        }
+        else if (action === 'list') {
+            args.push('list');
+        }
+        else if (action === 'show') {
+            args.push('show');
+            if (options.patch)
+                args.push('-p');
+        }
+        else if (action === 'drop') {
+            args.push('drop');
+        }
+        else if (action === 'clear') {
+            args.push('clear');
+        }
+        return await this.runGitCommand('stash', args);
+    }
+    /**
+     * Tag operations
+     */
+    async tag(name, options = {}) {
+        const args = [];
+        if (options.list)
+            args.push('-l');
+        if (options.delete)
+            args.push('-d');
+        if (options.force)
+            args.push('-f');
+        if (options.annotate)
+            args.push('-a');
+        if (options.message)
+            args.push('-m', options.message);
+        if (options.sign)
+            args.push('-s');
+        if (name)
+            args.push(name);
+        return await this.runGitCommand('tag', args);
+    }
+    /**
+     * Log
+     */
+    async log(options = {}) {
+        const args = [];
+        if (options.oneline)
+            args.push('--oneline');
+        if (options.graph)
+            args.push('--graph');
+        if (options.decorate)
+            args.push('--decorate');
+        if (options.all)
+            args.push('--all');
+        if (options.branches)
+            args.push('--branches');
+        if (options.tags)
+            args.push('--tags');
+        if (options.remotes)
+            args.push('--remotes');
+        if (options.maxCount)
+            args.push('-n', options.maxCount.toString());
+        if (options.since)
+            args.push('--since', options.since);
+        if (options.until)
+            args.push('--until', options.until);
+        if (options.author)
+            args.push('--author', options.author);
+        if (options.grep)
+            args.push('--grep', options.grep);
+        if (options.path)
+            args.push('--', options.path);
+        return await this.runGitCommand('log', args);
+    }
+    /**
+     * Status
+     */
+    async status(options = {}) {
+        const args = [];
+        if (options.short)
+            args.push('--short');
+        if (options.branch)
+            args.push('--branch');
+        if (options.porcelain)
+            args.push('--porcelain');
+        if (options.ignored)
+            args.push('--ignored');
+        if (options.untracked)
+            args.push('--untracked-files', options.untracked);
+        return await this.runGitCommand('status', args);
+    }
+    /**
+     * Diff
+     */
+    async diff(options = {}) {
+        const args = [];
+        if (options.cached)
+            args.push('--cached');
+        if (options.staged)
+            args.push('--staged');
+        if (options.nameOnly)
+            args.push('--name-only');
+        if (options.nameStatus)
+            args.push('--name-status');
+        if (options.stat)
+            args.push('--stat');
+        if (options.patch)
+            args.push('-p');
+        if (options.unified)
+            args.push('-U', options.unified.toString());
+        if (options.commit1)
+            args.push(options.commit1);
+        if (options.commit2)
+            args.push(options.commit2);
+        if (options.path)
+            args.push('--', options.path);
+        return await this.runGitCommand('diff', args);
+    }
+    /**
+     * Remote operations
+     */
+    async remote(action, name, url) {
+        const args = [action];
+        if (name)
+            args.push(name);
+        if (url)
+            args.push(url);
+        return await this.runGitCommand('remote', args);
+    }
+    /**
+     * Config operations
+     */
+    async config(key, value, options = {}) {
+        const args = [];
+        if (options.global)
+            args.push('--global');
+        if (options.local)
+            args.push('--local');
+        if (options.system)
+            args.push('--system');
+        if (options.unset)
+            args.push('--unset');
+        if (options.list)
+            args.push('--list');
+        if (options.get)
+            args.push('--get');
+        if (options.getAll)
+            args.push('--get-all');
+        if (key)
+            args.push(key);
+        if (value)
+            args.push(value);
+        return await this.runGitCommand('config', args);
+    }
+    /**
+     * Submodule operations
+     */
+    async submodule(action, options = {}) {
+        const args = [action];
+        if (options.init)
+            args.push('--init');
+        if (options.recursive)
+            args.push('--recursive');
+        if (options.remote)
+            args.push('--remote');
+        if (options.merge)
+            args.push('--merge');
+        if (options.rebase)
+            args.push('--rebase');
+        if (options.force)
+            args.push('--force');
+        if (options.path)
+            args.push(options.path);
+        if (options.url)
+            args.push(options.url);
+        return await this.runGitCommand('submodule', args);
+    }
+    /**
+     * Worktree operations
+     */
+    async worktree(action, options = {}) {
+        const args = [action];
+        if (options.add)
+            args.push('add');
+        if (options.remove)
+            args.push('remove');
+        if (options.list)
+            args.push('list');
+        if (options.prune)
+            args.push('prune');
+        if (options.move)
+            args.push('move');
+        if (options.repair)
+            args.push('repair');
+        if (options.path)
+            args.push(options.path);
+        if (options.branch)
+            args.push(options.branch);
+        return await this.runGitCommand('worktree', args);
+    }
+    /**
+     * Archive operations
+     */
+    async archive(format, treeish, output, options = {}) {
+        const args = [];
+        if (options.remote)
+            args.push('--remote');
+        if (options.exec)
+            args.push('--exec', options.exec);
+        if (options.output)
+            args.push('--output', options.output);
+        if (options.prefix)
+            args.push('--prefix', options.prefix);
+        if (options.worktreeAttributes)
+            args.push('--worktree-attributes');
+        args.push(format, treeish);
+        if (output)
+            args.push(output);
+        return await this.runGitCommand('archive', args);
+    }
+    /**
+     * Bundle operations
+     */
+    async bundle(action, options = {}) {
+        const args = [action];
+        if (options.verify)
+            args.push('--verify');
+        if (options.listHeads)
+            args.push('--list-heads');
+        if (options.unbundle)
+            args.push('--unbundle');
+        if (options.create)
+            args.push('create');
+        if (options.file)
+            args.push(options.file);
+        if (options.revlist)
+            args.push(options.revlist);
+        return await this.runGitCommand('bundle', args);
+    }
+    /**
+     * File operations
+     */
+    async readFile(filePath) {
+        try {
+            const fullPath = path.join(this.projectPath, filePath);
+            const content = fs.readFileSync(fullPath, 'utf-8');
+            return {
+                success: true,
+                message: 'Arquivo lido com sucesso',
+                data: { content, path: filePath }
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                message: 'Erro ao ler arquivo',
+                error: error instanceof Error ? error.message : String(error)
+            };
+        }
+    }
+    async writeFile(filePath, content) {
+        try {
+            const fullPath = path.join(this.projectPath, filePath);
+            const dir = path.dirname(fullPath);
+            // Cria diretório se não existir
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            fs.writeFileSync(fullPath, content, 'utf-8');
+            return {
+                success: true,
+                message: 'Arquivo escrito com sucesso',
+                data: { path: filePath, size: content.length }
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                message: 'Erro ao escrever arquivo',
+                error: error instanceof Error ? error.message : String(error)
+            };
+        }
+    }
+    async deleteFile(filePath) {
+        try {
+            const fullPath = path.join(this.projectPath, filePath);
+            fs.unlinkSync(fullPath);
+            return {
+                success: true,
+                message: 'Arquivo deletado com sucesso',
+                data: { path: filePath }
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                message: 'Erro ao deletar arquivo',
+                error: error instanceof Error ? error.message : String(error)
+            };
+        }
+    }
+    async listFiles(directory = '.') {
+        try {
+            const fullPath = path.join(this.projectPath, directory);
+            const files = fs.readdirSync(fullPath, { withFileTypes: true });
+            const fileList = files.map(file => ({
+                name: file.name,
+                type: file.isDirectory() ? 'directory' : 'file',
+                path: path.join(directory, file.name)
+            }));
+            return {
+                success: true,
+                message: 'Arquivos listados com sucesso',
+                data: { files: fileList, directory }
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                message: 'Erro ao listar arquivos',
+                error: error instanceof Error ? error.message : String(error)
+            };
+        }
+    }
+    async createDirectory(dirPath) {
+        try {
+            const fullPath = path.join(this.projectPath, dirPath);
+            fs.mkdirSync(fullPath, { recursive: true });
+            return {
+                success: true,
+                message: 'Diretório criado com sucesso',
+                data: { path: dirPath }
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                message: 'Erro ao criar diretório',
+                error: error instanceof Error ? error.message : String(error)
+            };
+        }
+    }
+    async deleteDirectory(dirPath) {
+        try {
+            const fullPath = path.join(this.projectPath, dirPath);
+            fs.rmSync(fullPath, { recursive: true, force: true });
+            return {
+                success: true,
+                message: 'Diretório deletado com sucesso',
+                data: { path: dirPath }
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                message: 'Erro ao deletar diretório',
+                error: error instanceof Error ? error.message : String(error)
+            };
+        }
+    }
+    /**
+     * Terminal operations
+     */
+    async runCommand(command, args = []) {
+        return await this.runSystemCommand(command, args);
+    }
+    /**
+     * Network operations
+     */
+    async testConnection(url) {
+        // Testa conectividade básica
+        const result = await this.runSystemCommand('ping', ['-c', '1', url]);
+        return result;
+    }
+    /**
+     * Utility operations
+     */
+    async getCurrentDirectory() {
+        return this.projectPath;
+    }
+    async changeDirectory(newPath) {
+        this.projectPath = newPath;
+    }
+    async getGitInfo() {
+        const [status, log, branches, remotes] = await Promise.all([
+            this.status(),
+            this.log({ maxCount: 1, oneline: true }),
+            this.listBranches(),
+            this.remote('show')
+        ]);
+        return {
+            status: status.output,
+            lastCommit: log.output,
+            branches: branches.output,
+            remotes: remotes.output,
+            isGitRepo: await this.isGitRepository()
+        };
+    }
+}
+exports.GitOperations = GitOperations;
+//# sourceMappingURL=git-operations.js.map