@andrebuzeli/git-mcp 10.0.8 → 11.0.0

package/package.json

@@ -1,86 +1,19 @@
 {
   "name": "@andrebuzeli/git-mcp",
-  "version": "10.0.8",
+  "version": "11.0.0",
   "type": "module",
-  "description": "Professional MCP server for Git operations - STDIO UNIVERSAL: works in ANY IDE (Cursor, VSCode, Claude Desktop, Trae AI, Kiro.dev). Fully autonomous DUAL execution (GitHub + Gitea APIs) with automatic username detection. Smart parameter normalization handles both 'action' and 'command' formats. All tools execute on BOTH providers simultaneously. No manual parameters needed.",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
   "bin": {
-    "git-mcp": "dist/index.js"
+    "git-mcp": "bin/git-mcp.js"
   },
-  "files": [
-    "dist/",
-    "README.md",
-    "LICENSE",
-    "package.json"
-  ],
   "scripts": {
-    "build": "tsc",
-    "start": "node dist/index.js",
-    "dev": "ts-node src/index.ts",
-    "test": "jest",
-    "test:watch": "jest --watch",
-    "semantic-release": "semantic-release",
-    "prepublishOnly": "npm run build",
-    "clean": "rimraf dist",
-    "release": "npm run build && npm version patch && git push origin --follow-tags"
+    "start": "node bin/git-mcp.js start",
+    "init": "node bin/git-mcp.js init",
+    "test": "node tests/run.js"
   },
-  "keywords": [
-    "mcp",
-    "git",
-    "github",
-    "gitea",
-    "universal-mode",
-    "multi-provider",
-    "model-context-protocol",
-    "ai-agent",
-    "version-control",
-    "automation",
-    "cli",
-    "developer-tools",
-    "workflow",
-    "repository-management"
-  ],
-  "author": "Andre Buzeli",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/andrebuzeli/git-mcp.git"
-  },
-  "bugs": {
-    "url": "https://github.com/andrebuzeli/git-mcp/issues"
-  },
-  "homepage": "https://github.com/andrebuzeli/git-mcp#readme",
   "dependencies": {
-    "@isomorphic-git/lightning-fs": "^4.6.2",
-    "@modelcontextprotocol/sdk": "^0.4.0",
-    "@octokit/rest": "^20.0.0",
-    "ajv": "^8.12.0",
-    "axios": "^1.6.0",
-    "body-parser": "^1.20.2",
-    "express": "^4.18.2",
-    "isomorphic-git": "^1.34.0"
-  },
-  "devDependencies": {
-    "@semantic-release/commit-analyzer": "^10.0.0",
-    "@semantic-release/github": "^9.0.0",
-    "@semantic-release/npm": "^10.0.0",
-    "@semantic-release/release-notes-generator": "^10.0.0",
-    "@types/body-parser": "^1.19.2",
-    "@types/express": "^4.17.17",
-    "@types/jest": "^29.0.0",
-    "@types/node": "^20.0.0",
-    "jest": "^29.0.0",
-    "rimraf": "^5.0.0",
-    "semantic-release": "^20.1.0",
-    "ts-jest": "^29.0.0",
-    "ts-node": "^10.0.0",
-    "typescript": "^5.0.0"
-  },
-  "engines": {
-    "node": ">=18.0.0"
-  },
-  "publishConfig": {
-    "access": "public"
+    "axios": "^1.7.7",
+    "kleur": "^4.1.5",
+    "isomorphic-git": "^1.25.4",
+    "yargs": "^17.7.2"
   }
 }

package/src/local/git.js

@@ -0,0 +1,14 @@
+import simpleGit from 'simple-git'
+
+export class LocalGit {
+  constructor(projectPath) { this.projectPath = projectPath; this.git = simpleGit({ baseDir: projectPath }) }
+  async status() { return await this.git.status() }
+  async init() { await this.git.init(); return { ok: true } }
+  async add(patterns) { await this.git.add(patterns); return { ok: true } }
+  async commit(message) { await this.git.commit(message); return { ok: true } }
+  async addOrSetRemote(name, url) { const rems = await this.git.getRemotes(true); const exists = rems.find(r => r.name === name); if (exists) { await this.git.remote(['set-url', name, url]) } else { await this.git.addRemote(name, url) } return { ok: true } }
+  async push(remote, branch) { await this.git.push(remote, branch); return { ok: true } }
+  async pull(remote, branch) { await this.git.pull(remote, branch); return { ok: true } }
+  async branch(subaction, args) { if (subaction === 'list') { return await this.git.branchLocal() } if (subaction === 'create') { await this.git.checkoutLocalBranch(args?.name); return { ok: true } } if (subaction === 'switch') { await this.git.checkout(args?.name); return { ok: true } } throw new Error('subaction inválida') }
+  async tag(subaction, args) { if (subaction === 'list') { return await this.git.tags() } if (subaction === 'create') { await this.git.addTag(args?.name); return { ok: true } } throw new Error('subaction inválida') }
+}

package/src/providers/gitea.js

@@ -0,0 +1,13 @@
+import axios from 'axios'
+
+export class Gitea {
+  constructor(baseUrl, token) { this.baseUrl = baseUrl; this.token = token; this.http = axios.create({ baseURL: baseUrl + '/api/v1', headers: { Authorization: `token ${token}` } }); this._me = null }
+  async me() { if (this._me) return this._me; const r = await this.http.get('/user'); this._me = r.data; return r.data }
+  async request(method, endpoint, data) { const r = await this.http.request({ method, url: endpoint, data }); return r.data }
+  async createRepo(name, priv, auto) { const r = await this.request('POST', '/user/repos', { name, private: priv, auto_init: auto }); return r }
+  async deleteRepo(name) { const me = await this.me(); await this.request('DELETE', `/repos/${me.login}/${name}`); return { ok: true } }
+  repoHttpsUrl(name) { return this.me().then(me => `${this.baseUrl}/${me.login}/${name}.git`) }
+  async createIssue(name, title, body) { const me = await this.me(); const r = await this.request('POST', `/repos/${me.login}/${name}/issues`, { title, body }); return r }
+  async createRelease(name, tag, title, body) { const me = await this.me(); const r = await this.request('POST', `/repos/${me.login}/${name}/releases`, { tag_name: tag, name: title, body }); return r }
+  async putContent(name, path, content, message, branch) { const me = await this.me(); const r = await this.request('POST', `/repos/${me.login}/${name}/contents/${path}`, { content, message, branch: branch || 'master' }); return r }
+}

package/src/providers/github.js

@@ -0,0 +1,13 @@
+import axios from 'axios'
+
+export class Github {
+  constructor(token) { this.http = axios.create({ baseURL: 'https://api.github.com', headers: { Authorization: `token ${token}`, Accept: 'application/vnd.github.v3+json', 'User-Agent': 'git-mcp' } }); this._me = null }
+  async me() { if (this._me) return this._me; const r = await this.http.get('/user'); this._me = r.data; return r.data }
+  async request(method, endpoint, data) { const r = await this.http.request({ method, url: endpoint, data }); return r.data }
+  async createRepo(name, priv, auto) { const r = await this.request('POST', '/user/repos', { name, private: priv, auto_init: auto }); return r }
+  async deleteRepo(name) { const me = await this.me(); await this.request('DELETE', `/repos/${me.login}/${name}`); return { ok: true } }
+  repoHttpsUrl(name) { return this.me().then(me => `https://github.com/${me.login}/${name}.git`) }
+  async createIssue(name, title, body) { const me = await this.me(); const r = await this.request('POST', `/repos/${me.login}/${name}/issues`, { title, body }); return r }
+  async createRelease(name, tag, title, body) { const me = await this.me(); const r = await this.request('POST', `/repos/${me.login}/${name}/releases`, { tag_name: tag, name: title, body, prerelease: false, draft: false }); return r }
+  async putContent(name, path, content, message, branch) { const me = await this.me(); const r = await this.request('PUT', `/repos/${me.login}/${name}/contents/${path}`, { content, message, branch: branch || 'master' }); return r }
+}

package/src/server.js

@@ -0,0 +1,63 @@
+import fs from 'fs'
+import path from 'path'
+import { fileURLToPath } from 'url'
+import { deriveProjectName } from './utils/project.js'
+
+export async function initMcpJson(targetPath, force) {
+  const base = targetPath || process.cwd()
+  const file = path.join(base, 'mcp.json')
+  const templatePath = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'mcp.json.template')
+  const tpl = fs.readFileSync(templatePath, 'utf-8')
+  if (!force && fs.existsSync(file)) { console.log('mcp.json já existe'); return }
+  fs.writeFileSync(file, tpl, 'utf-8')
+  console.log('mcp.json criado')
+}
+
+function getEnv() { return { GITEA_URL: process.env.GITEA_URL, GITEA_TOKEN: process.env.GITEA_TOKEN, GITHUB_TOKEN: process.env.GITHUB_TOKEN } }
+
+async function getTool(toolName, env) {
+  if (toolName === 'git-local') { const { GitLocalTool } = await import('./tools/git-local.js'); return new GitLocalTool() }
+  if (toolName === 'git-remote') { const { GitRemoteTool } = await import('./tools/git-remote.js'); return new GitRemoteTool(env) }
+  if (toolName === 'git-sync') { const { GitSyncTool } = await import('./tools/git-sync.js'); return new GitSyncTool(env) }
+  if (toolName === 'git-issues') { const { GitIssuesTool } = await import('./tools/git-issues.js'); return new GitIssuesTool(env) }
+  if (toolName === 'git-releases') { const { GitReleasesTool } = await import('./tools/git-releases.js'); return new GitReleasesTool(env) }
+  if (toolName === 'git-repos') { const { GitReposTool } = await import('./tools/git-repos.js'); return new GitReposTool(env) }
+  if (toolName === 'git-contents') { const { GitContentsTool } = await import('./tools/git-contents.js'); return new GitContentsTool(env) }
+  if (toolName === 'git-commits') { const { GitCommitsTool } = await import('./tools/git-commits.js'); return new GitCommitsTool(env) }
+  if (toolName === 'git-issues-prs') { const { GitIssuesPRsTool } = await import('./tools/git-issues-prs.js'); return new GitIssuesPRsTool(env) }
+  if (toolName === 'git-actions') { const { GitActionsTool } = await import('./tools/git-actions.js'); return new GitActionsTool(env) }
+  if (toolName === 'git-activity') { const { GitActivityTool } = await import('./tools/git-activity.js'); return new GitActivityTool(env) }
+  if (toolName === 'git-admin') { const { GitAdminTool } = await import('./tools/git-admin.js'); return new GitAdminTool(env) }
+  if (toolName === 'git-user') { const { GitUserTool } = await import('./tools/git-user.js'); return new GitUserTool(env) }
+  if (toolName === 'git-orgs') { const { GitOrgsTool } = await import('./tools/git-orgs.js'); return new GitOrgsTool(env) }
+  if (toolName === 'git-gists') { const { GitGistsTool } = await import('./tools/git-gists.js'); return new GitGistsTool(env) }
+  if (toolName === 'git-search') { const { GitSearchTool } = await import('./tools/git-search.js'); return new GitSearchTool(env) }
+  if (toolName === 'git-gitdata') { const { GitGitDataTool } = await import('./tools/git-gitdata.js'); return new GitGitDataTool(env) }
+  if (toolName === 'git-checks') { const { GitChecksTool } = await import('./tools/git-checks.js'); return new GitChecksTool(env) }
+  if (toolName === 'git-deployments') { const { GitDeploymentsTool } = await import('./tools/git-deployments.js'); return new GitDeploymentsTool(env) }
+  if (toolName === 'git-misc') { const { GitMiscTool } = await import('./tools/git-misc.js'); return new GitMiscTool(env) }
+  if (toolName === 'git-packages') { const { GitPackagesTool } = await import('./tools/git-packages.js'); return new GitPackagesTool(env) }
+  if (toolName === 'git-raw') { const { GitRawTool } = await import('./tools/git-raw.js'); return new GitRawTool(env) }
+  if (toolName === 'git-meta') { const { GitMetaTool } = await import('./tools/git-meta.js'); return new GitMetaTool(env) }
+  return null
+}
+
+async function dispatch(req) {
+  const { tool, action, projectPath, args } = req
+  const name = deriveProjectName(projectPath)
+  const inst = await getTool(tool, getEnv())
+  if (inst) return await inst.handle(action, projectPath, args, getEnv())
+  throw new Error('Tool/action não suportado')
+}
+
+export async function startServer() {
+  process.stdin.setEncoding('utf-8')
+  let buf = ''
+  process.stdin.on('data', async chunk => {
+    buf += chunk
+    try { const req = JSON.parse(buf); buf = ''; const res = await dispatch(req); process.stdout.write(JSON.stringify({ ok: true, res }) + '\n') } catch (e) { if (e instanceof SyntaxError) return; process.stdout.write(JSON.stringify({ ok: false, error: e.message }) + '\n'); buf = '' }
+  })
+  console.log('git-mcp pronto')
+}
+
+export async function callOnce(req) { return await dispatch(req) }

package/src/tools/git-actions.js

@@ -0,0 +1,19 @@
+import { Github } from '../providers/github.js'
+import { makeSchema } from './schema.js'
+
+export class GitActionsTool {
+  constructor(env) { this.gh = new Github(env.GITHUB_TOKEN) }
+  async handle(action, projectPath, args) {
+    const me = await this.gh.me(); const name = projectPath.split(/[\\/]/).pop().replace(/\s+/g, '_'); const repo = `${me.login}/${name}`
+    if (action === 'workflows') return await this.gh.request('GET', `/repos/${repo}/actions/workflows`)
+    if (action === 'runs') return await this.gh.request('GET', `/repos/${repo}/actions/runs`)
+    if (action === 'artifacts') return await this.gh.request('GET', `/repos/${repo}/actions/artifacts`)
+    if (action === 'runners') return await this.gh.request('GET', `/repos/${repo}/actions/runners`)
+    if (action === 'secrets') return await this.gh.request('GET', `/repos/${repo}/actions/secrets`)
+    return { error: 'ação inválida' }
+  }
+}
+
+export function getSchema() {
+  return makeSchema({ name: 'git-actions', description: 'Consultas a GitHub Actions', actions: { workflows: { description: 'Listar workflows' }, runs: { description: 'Listar runs' }, artifacts: { description: 'Listar artifacts' }, runners: { description: 'Listar runners' }, secrets: { description: 'Listar secrets' } } })
+}

package/src/tools/git-activity.js

@@ -0,0 +1,28 @@
+import { Gitea } from '../providers/gitea.js'
+import { Github } from '../providers/github.js'
+import { deriveProjectName } from '../utils/project.js'
+import { makeSchema } from './schema.js'
+
+export class GitActivityTool {
+  constructor(env) { this.providers = { gitea: new Gitea(env.GITEA_URL, env.GITEA_TOKEN), github: new Github(env.GITHUB_TOKEN) } }
+  async handle(action, projectPath, args) {
+    const name = deriveProjectName(projectPath)
+    const meG = await this.providers.gitea.me(); const meH = await this.providers.github.me()
+    const gRepo = `${meG.login}/${name}`; const hRepo = `${meH.login}/${name}`
+    const par = async (fnG, fnH) => { const r = await Promise.allSettled([ fnG(), fnH() ]); return r.map(x => x.status === 'fulfilled' ? x.value : { error: x.reason?.message }) }
+    if (action === 'notifications-get') return await par(() => this.providers.gitea.request('GET', '/notifications'), () => this.providers.github.request('GET', '/notifications'))
+    if (action === 'notifications-put') return await par(() => this.providers.gitea.request('PUT', '/notifications', { last_read_at: Date.now() / 1000 }), () => ({ ok: true }))
+    if (action === 'events') return await par(() => this.providers.gitea.request('GET', `/repos/${gRepo}/activities/feeds`), () => this.providers.github.request('GET', '/events'))
+    if (action === 'feeds') return await this.providers.github.request('GET', '/feeds')
+    if (action === 'starring-put') return await this.providers.github.request('PUT', `/user/starred/${hRepo}`)
+    if (action === 'starring-get') return await this.providers.github.request('GET', `/user/starred/${hRepo}`)
+    if (action === 'starring-delete') return await this.providers.github.request('DELETE', `/user/starred/${hRepo}`)
+    if (action === 'subscription-put') return await par(() => this.providers.gitea.request('PUT', `/repos/${gRepo}/subscription`, { subscribed: true }), () => this.providers.github.request('PUT', `/repos/${hRepo}/subscription`, { subscribed: true }))
+    if (action === 'subscription-delete') return await par(() => this.providers.gitea.request('DELETE', `/repos/${gRepo}/subscription`), () => this.providers.github.request('DELETE', `/repos/${hRepo}/subscription`))
+    return { error: 'ação inválida' }
+  }
+}
+
+export function getSchema() {
+  return makeSchema({ name: 'git-activity', description: 'Notificações e atividades', actions: { 'notifications-get': { description: 'Obter notificações' }, 'notifications-put': { description: 'Marcar como lidas' }, events: { description: 'Eventos' }, feeds: { description: 'Feeds (GitHub)' }, 'starring-put': { description: 'Estrelas' }, 'starring-get': { description: 'Checar estrela' }, 'starring-delete': { description: 'Remover estrela' }, 'subscription-put': { description: 'Assinar repo' }, 'subscription-delete': { description: 'Cancelar assinatura' } } })
+}

package/src/tools/git-admin.js

@@ -0,0 +1,20 @@
+import { Gitea } from '../providers/gitea.js'
+import { makeSchema } from './schema.js'
+
+export class GitAdminTool {
+  constructor(env) { this.gitea = new Gitea(env.GITEA_URL, env.GITEA_TOKEN) }
+  async handle(action, projectPath, args) {
+    if (action === 'cron') return await this.gitea.request('GET', '/admin/cron')
+    if (action === 'emails') return await this.gitea.request('GET', '/admin/emails')
+    if (action === 'orgs') return await this.gitea.request('GET', '/admin/orgs')
+    if (action === 'users') return await this.gitea.request('GET', '/admin/users')
+    if (action === 'user-create') return await this.gitea.request('POST', '/admin/users', { username: args?.username, email: args?.email, password: args?.password || 'Password123!', must_change_password: false })
+    if (action === 'user-patch') return await this.gitea.request('PATCH', `/admin/users/${args?.username}`, { full_name: args?.full_name || 'Updated Name', login_name: args?.username, email: args?.email })
+    if (action === 'user-delete') return await this.gitea.request('DELETE', `/admin/users/${args?.username}`)
+    if (action === 'unadopted') return await this.gitea.request('GET', '/admin/unadopted')
+    if (action === 'hooks') return await this.gitea.request('GET', '/admin/hooks')
+    return { error: 'ação inválida' }
+  }
+}
+
+export function getSchema() { return makeSchema({ name: 'git-admin', description: 'Endpoints de administração (Gitea)', actions: { cron: { description: 'Cron jobs' }, emails: { description: 'Emails' }, orgs: { description: 'Organizações' }, users: { description: 'Usuários' }, 'user-create': { description: 'Criar usuário' }, 'user-patch': { description: 'Atualizar usuário' }, 'user-delete': { description: 'Excluir usuário' }, unadopted: { description: 'Repositórios não adotados' }, hooks: { description: 'Hooks admin' } } }) }

package/src/tools/git-checks.js

@@ -0,0 +1,14 @@
+import { Github } from '../providers/github.js'
+import { deriveProjectName } from '../utils/project.js'
+import { makeSchema } from './schema.js'
+
+export class GitChecksTool {
+  constructor(env) { this.gh = new Github(env.GITHUB_TOKEN) }
+  async handle(action, projectPath, args) {
+    const me = await this.gh.me(); const name = deriveProjectName(projectPath); const repo = `${me.login}/${name}`
+    if (action === 'status') return await this.gh.request('POST', `/repos/${repo}/statuses/${args?.sha}`, { state: args?.state || 'success', context: args?.context || 'test' })
+    return { error: 'ação inválida' }
+  }
+}
+
+export function getSchema() { return makeSchema({ name: 'git-checks', description: 'Statuses/Checks (GitHub)', actions: { status: { description: 'Definir status para SHA' } } }) }

package/src/tools/git-commits.js

@@ -0,0 +1,34 @@
+import { Gitea } from '../providers/gitea.js'
+import { Github } from '../providers/github.js'
+import { deriveProjectName } from '../utils/project.js'
+import { makeSchema } from './schema.js'
+
+export class GitCommitsTool {
+  constructor(env) { this.providers = { gitea: new Gitea(env.GITEA_URL, env.GITEA_TOKEN), github: new Github(env.GITHUB_TOKEN) } }
+  async handle(action, projectPath, args) {
+    const name = deriveProjectName(projectPath)
+    const meG = await this.providers.gitea.me(); const meH = await this.providers.github.me()
+    const gRepo = `${meG.login}/${name}`; const hRepo = `${meH.login}/${name}`
+    const par = async (fnG, fnH) => { const r = await Promise.allSettled([ fnG(), fnH() ]); return r.map(x => x.status === 'fulfilled' ? x.value : { error: x.reason?.message }) }
+    if (action === 'branches') return await par(() => this.providers.gitea.request('GET', `/repos/${gRepo}/branches`), () => this.providers.github.request('GET', `/repos/${hRepo}/branches`))
+    if (action === 'create-branch') return await par(() => this.providers.gitea.request('POST', `/repos/${gRepo}/branches`, { new_branch_name: args?.name || 'dev', old_branch_name: args?.from || 'main' }), async () => { const ref = await this.providers.github.request('GET', `/repos/${hRepo}/git/ref/heads/${args?.from || 'main'}`); const sha = ref.object.sha; return await this.providers.github.request('POST', `/repos/${hRepo}/git/refs`, { ref: `refs/heads/${args?.name || 'dev'}`, sha }) })
+    if (action === 'branch-protections') return await par(() => this.providers.gitea.request('GET', `/repos/${gRepo}/branch_protections`), () => ({ ok: true }))
+    if (action === 'commits') return await par(() => this.providers.gitea.request('GET', `/repos/${gRepo}/commits`), () => this.providers.github.request('GET', `/repos/${hRepo}/commits`))
+    if (action === 'refs') return await par(() => this.providers.gitea.request('GET', `/repos/${gRepo}/git/refs`), () => this.providers.github.request('GET', `/repos/${hRepo}/git/refs`))
+    return { error: 'ação inválida' }
+  }
+}
+
+export function getSchema() {
+  return makeSchema({
+    name: 'git-commits',
+    description: 'Branches, commits e refs',
+    actions: {
+      branches: { description: 'Listar branches' },
+      'create-branch': { description: 'Criar branch' },
+      'branch-protections': { description: 'Proteções de branch (Gitea)' },
+      commits: { description: 'Listar commits' },
+      refs: { description: 'Listar refs' }
+    }
+  })
+}

package/src/tools/git-contents.js

@@ -0,0 +1,30 @@
+import { Gitea } from '../providers/gitea.js'
+import { Github } from '../providers/github.js'
+import { deriveProjectName } from '../utils/project.js'
+import { makeSchema } from './schema.js'
+
+export class GitContentsTool {
+  constructor(env) { this.providers = { gitea: new Gitea(env.GITEA_URL, env.GITEA_TOKEN), github: new Github(env.GITHUB_TOKEN) } }
+  async handle(action, projectPath, args) {
+    const name = deriveProjectName(projectPath)
+    const meG = await this.providers.gitea.me(); const meH = await this.providers.github.me()
+    const gRepo = `${meG.login}/${name}`; const hRepo = `${meH.login}/${name}`
+    const par = async (fnG, fnH) => { const r = await Promise.allSettled([ fnG(), fnH() ]); return r.map(x => x.status === 'fulfilled' ? x.value : { error: x.reason?.message }) }
+    if (action === 'list') return await par(() => this.providers.gitea.request('GET', `/repos/${gRepo}/contents`), () => this.providers.github.request('GET', `/repos/${hRepo}/readme`))
+    if (action === 'create') { const path = args?.path || 'test.txt'; const content = args?.content || Buffer.from('Hello').toString('base64'); const message = args?.message || 'Add file'; return await par(() => this.providers.gitea.request('POST', `/repos/${gRepo}/contents/${path}`, { content, message, branch: args?.branch || 'main' }), () => this.providers.github.request('PUT', `/repos/${hRepo}/contents/${path}`, { content, message, branch: args?.branch || 'main' })) }
+    if (action === 'get') { const path = args?.path || 'test.txt'; return await par(() => this.providers.gitea.request('GET', `/repos/${gRepo}/contents/${path}`), () => this.providers.github.request('GET', `/repos/${hRepo}/contents/${path}`)) }
+    return { error: 'ação inválida' }
+  }
+}
+
+export function getSchema() {
+  return makeSchema({
+    name: 'git-contents',
+    description: 'Listar/criar/obter arquivos via Contents API',
+    actions: {
+      list: { description: 'Listar conteúdos' },
+      create: { description: 'Criar arquivo (base64)' },
+      get: { description: 'Obter arquivo' }
+    }
+  })
+}

package/src/tools/git-deployments.js

@@ -0,0 +1,21 @@
+import { Github } from '../providers/github.js'
+import { deriveProjectName } from '../utils/project.js'
+import { makeSchema } from './schema.js'
+
+export class GitDeploymentsTool {
+  constructor(env) { this.gh = new Github(env.GITHUB_TOKEN) }
+  async handle(action, projectPath, args) {
+    const me = await this.gh.me(); const name = deriveProjectName(projectPath); const repo = `${me.login}/${name}`
+    if (action === 'create') {
+      let ref = args?.ref
+      if (!ref) {
+        try { const branches = await this.gh.request('GET', `/repos/${repo}/branches`); const names = (branches || []).map(b => b.name); ref = names.includes('main') ? 'main' : (names.includes('master') ? 'master' : (names[0] || 'main')) } catch { ref = 'main' }
+      }
+      return await this.gh.request('POST', `/repos/${repo}/deployments`, { ref })
+    }
+    if (action === 'status') return await this.gh.request('POST', `/repos/${repo}/deployments/${args?.id}/statuses`, { state: args?.state || 'success' })
+    return { error: 'ação inválida' }
+  }
+}
+
+export function getSchema() { return makeSchema({ name: 'git-deployments', description: 'Deployments (GitHub)', actions: { create: { description: 'Criar deployment (ref automática)' }, status: { description: 'Atualizar status do deployment' } } }) }

package/src/tools/git-gists.js

@@ -0,0 +1,15 @@
+import { Github } from '../providers/github.js'
+import { makeSchema } from './schema.js'
+
+export class GitGistsTool {
+  constructor(env) { this.gh = new Github(env.GITHUB_TOKEN) }
+  async handle(action, projectPath, args) {
+    if (action === 'create') return await this.gh.request('POST', '/gists', { description: args?.description || 'Test Gist', public: args?.public ?? false, files: args?.files || { 'test.txt': { content: 'Gist Content' } } })
+    if (action === 'get') return await this.gh.request('GET', `/gists/${args?.id}`)
+    if (action === 'star') return await this.gh.request('PUT', `/gists/${args?.id}/star`)
+    if (action === 'delete') return await this.gh.request('DELETE', `/gists/${args?.id}`)
+    return { error: 'ação inválida' }
+  }
+}
+
+export function getSchema() { return makeSchema({ name: 'git-gists', description: 'Gerenciar gists (GitHub)', actions: { create: { description: 'Criar gist' }, get: { description: 'Obter gist' }, star: { description: 'Favoritar gist' }, delete: { description: 'Excluir gist' } } }) }

package/src/tools/git-gitdata.js

@@ -0,0 +1,19 @@
+import { Github } from '../providers/github.js'
+import { deriveProjectName } from '../utils/project.js'
+import { makeSchema } from './schema.js'
+
+export class GitGitDataTool {
+  constructor(env) { this.gh = new Github(env.GITHUB_TOKEN) }
+  async handle(action, projectPath, args) {
+    const me = await this.gh.me(); const name = deriveProjectName(projectPath); const repo = `${me.login}/${name}`
+    if (action === 'blob-create') return await this.gh.request('POST', `/repos/${repo}/git/blobs`, { content: args?.content || 'Hello World', encoding: args?.encoding || 'utf-8' })
+    if (action === 'blob-get') return await this.gh.request('GET', `/repos/${repo}/git/blobs/${args?.sha}`)
+    if (action === 'tree-create') return await this.gh.request('POST', `/repos/${repo}/git/trees`, { tree: args?.tree || [] })
+    if (action === 'refs-get') return await this.gh.request('GET', `/repos/${repo}/git/refs`)
+    return { error: 'ação inválida' }
+  }
+}
+
+export function getSchema() {
+  return makeSchema({ name: 'git-gitdata', description: 'Dados Git low-level (GitHub)', actions: { 'blob-create': { description: 'Criar blob' }, 'blob-get': { description: 'Obter blob' }, 'tree-create': { description: 'Criar tree' }, 'refs-get': { description: 'Listar refs' } } })
+}

package/src/tools/git-issues-prs.js

@@ -0,0 +1,44 @@
+import { Gitea } from '../providers/gitea.js'
+import { Github } from '../providers/github.js'
+import { deriveProjectName } from '../utils/project.js'
+import { makeSchema } from './schema.js'
+
+export class GitIssuesPRsTool {
+  constructor(env) { this.providers = { gitea: new Gitea(env.GITEA_URL, env.GITEA_TOKEN), github: new Github(env.GITHUB_TOKEN) } }
+  async handle(action, projectPath, args) {
+    const name = deriveProjectName(projectPath)
+    const meG = await this.providers.gitea.me(); const meH = await this.providers.github.me()
+    const gRepo = `${meG.login}/${name}`; const hRepo = `${meH.login}/${name}`
+    const par = async (fnG, fnH) => { const r = await Promise.allSettled([ fnG(), fnH() ]); return r.map(x => x.status === 'fulfilled' ? x.value : { error: x.reason?.message }) }
+    if (action === 'issue-create') return await par(() => this.providers.gitea.request('POST', `/repos/${gRepo}/issues`, { title: args?.title || 'Test Issue', body: args?.body || '' }), () => this.providers.github.request('POST', `/repos/${hRepo}/issues`, { title: args?.title || 'Test Issue', body: args?.body || '' }))
+    if (action === 'issue-comment') { const id = args?.number; return await par(() => this.providers.gitea.request('POST', `/repos/${gRepo}/issues/${id}/comments`, { body: args?.comment || 'Comment' }), () => this.providers.github.request('POST', `/repos/${hRepo}/issues/${id}/comments`, { body: args?.comment || 'Comment' })) }
+    if (action === 'issue-labels') { const id = args?.number; try { return await par(() => this.providers.gitea.request('POST', `/repos/${gRepo}/issues/${id}/labels`, { labels: args?.labels || [1] }), () => this.providers.github.request('POST', `/repos/${hRepo}/issues/${id}/labels`, { labels: args?.labels || ['bug'] })) } catch (e) { try { await this.providers.github.request('POST', `/repos/${hRepo}/labels`, { name: (args?.labels && args.labels[0]) || 'bug', color: '#ff0000' }); return await this.providers.github.request('POST', `/repos/${hRepo}/issues/${id}/labels`, { labels: args?.labels || ['bug'] }) } catch { return { error: 'labels failed' } } } }
+    if (action === 'issue-lock') { const id = args?.number; return await par(() => ({ ok: true }), () => this.providers.github.request('PUT', `/repos/${hRepo}/issues/${id}/lock`)) }
+    if (action === 'issue-unlock') { const id = args?.number; return await par(() => ({ ok: true }), () => this.providers.github.request('DELETE', `/repos/${hRepo}/issues/${id}/lock`)) }
+    if (action === 'labels-list') return await par(() => this.providers.gitea.request('GET', `/repos/${gRepo}/labels`), () => this.providers.github.request('GET', `/repos/${hRepo}/labels`))
+    if (action === 'labels-create') return await par(() => this.providers.gitea.request('POST', `/repos/${gRepo}/labels`, { name: args?.name || 'bug', color: args?.color || 'ff0000' }), () => this.providers.github.request('POST', `/repos/${hRepo}/labels`, { name: args?.name || 'bug', color: '#' + (args?.color || 'ff0000') }))
+    if (action === 'milestones-list') return await par(() => this.providers.gitea.request('GET', `/repos/${gRepo}/milestones`), () => this.providers.github.request('GET', `/repos/${hRepo}/milestones`))
+    if (action === 'milestones-create') return await par(() => this.providers.gitea.request('POST', `/repos/${gRepo}/milestones`, { title: args?.title || 'v1.0' }), () => this.providers.github.request('POST', `/repos/${hRepo}/milestones`, { title: args?.title || 'v2.0' }))
+    if (action === 'pr-create') { try { return await par(() => this.providers.gitea.request('POST', `/repos/${gRepo}/pulls`, { title: args?.title || 'PR', head: args?.head || 'dev', base: args?.base || 'main' }), () => this.providers.github.request('POST', `/repos/${hRepo}/pulls`, { title: args?.title || 'PR', head: args?.head || 'feature-branch', base: args?.base || 'main' })) } catch (e) { try { const ref = await this.providers.github.request('GET', `/repos/${hRepo}/git/ref/heads/${args?.base || 'main'}`); const sha = ref.object.sha; await this.providers.github.request('POST', `/repos/${hRepo}/git/refs`, { ref: `refs/heads/${args?.head || 'feature-branch'}`, sha }); await this.providers.github.putContent(name, 'feature.txt', Buffer.from('Feature Change').toString('base64'), 'Feature', args?.head || 'feature-branch'); return await this.providers.github.request('POST', `/repos/${hRepo}/pulls`, { title: args?.title || 'PR', head: args?.head || 'feature-branch', base: args?.base || 'main' }) } catch { return { error: 'pr failed' } } } }
+    if (action === 'pr-get') { const num = args?.number; return await par(() => this.providers.gitea.request('GET', `/repos/${gRepo}/pulls/${num}`), () => this.providers.github.request('GET', `/repos/${hRepo}/pulls/${num}`)) }
+    return { error: 'ação inválida' }
+  }
+}
+
+export function getSchema() {
+  return makeSchema({
+    name: 'git-issues-prs',
+    description: 'Issues, comentários, labels, milestones e pull requests',
+    actions: {
+      'issue-create': { description: 'Criar issue' },
+      'issue-comment': { description: 'Comentar issue' },
+      'issue-labels': { description: 'Aplicar labels à issue (autocorreção)' },
+      'labels-list': { description: 'Listar labels' },
+      'labels-create': { description: 'Criar label' },
+      'milestones-list': { description: 'Listar milestones' },
+      'milestones-create': { description: 'Criar milestone' },
+      'pr-create': { description: 'Criar PR (autocorreção de branch)' },
+      'pr-get': { description: 'Obter PR' }
+    }
+  })
+}

package/src/tools/git-issues.js

@@ -0,0 +1,12 @@
+import { Gitea } from '../providers/gitea.js'
+import { Github } from '../providers/github.js'
+import { deriveProjectName } from '../utils/project.js'
+
+export class GitIssuesTool {
+  constructor(env) { this.providers = { gitea: new Gitea(env.GITEA_URL, env.GITEA_TOKEN), github: new Github(env.GITHUB_TOKEN) } }
+  async handle(action, projectPath, args) {
+    const name = deriveProjectName(projectPath)
+    if (action === 'create') { const r = await Promise.allSettled([ this.providers.gitea.createIssue(name, args?.title || 'Issue', args?.body || ''), this.providers.github.createIssue(name, args?.title || 'Issue', args?.body || '' ) ]); return r.map(x => x.status === 'fulfilled' ? x.value : { error: x.reason?.message }) }
+    return { error: 'ação inválida' }
+  }
+}

package/src/tools/git-local.js

@@ -0,0 +1,66 @@
+import fs from 'fs'
+import path from 'path'
+import git from 'isomorphic-git'
+import http from 'isomorphic-git/http/node'
+import { deriveProjectName } from '../utils/project.js'
+import { Github } from '../providers/github.js'
+import { Gitea } from '../providers/gitea.js'
+import { makeSchema } from './schema.js'
+
+async function addAll(dir) {
+  const status = await git.statusMatrix({ fs, dir })
+  for (const row of status) {
+    const filepath = row[0]
+    const workdir = row[1]
+    const stage = row[2]
+    if (workdir !== stage) await git.add({ fs, dir, filepath })
+  }
+  return { ok: true }
+}
+
+export class GitLocalTool {
+  async handle(action, projectPath, args, env) {
+    const dir = projectPath
+    if (action === 'status') {
+      const s = await git.statusMatrix({ fs, dir })
+      return { files: s.length }
+    }
+    if (action === 'init') { await git.init({ fs, dir }); return { ok: true } }
+    if (action === 'add') { if (args?.patterns) { for (const p of args.patterns) { const full = path.join(dir, p); if (fs.existsSync(full) && fs.statSync(full).isFile()) await git.add({ fs, dir, filepath: p }) } return { ok: true } } return await addAll(dir) }
+    if (action === 'commit') { const author = { name: args?.name || 'mcp', email: args?.email || 'mcp@example.com' }; const sha = await git.commit({ fs, dir, message: args?.message || 'mcp', author }); return { sha } }
+    if (action === 'branch') { const sub = args?.subaction || 'list'; if (sub === 'list') { const list = await git.listBranches({ fs, dir }); return { branches: list } } if (sub === 'create') { await git.branch({ fs, dir, ref: args?.name }); return { ok: true } } if (sub === 'switch') { await git.checkout({ fs, dir, ref: args?.name }); return { ok: true } } }
+    if (action === 'tag') { const sub = args?.subaction || 'list'; if (sub === 'list') { const list = await git.listTags({ fs, dir }); return { tags: list } } if (sub === 'create') { await git.tag({ fs, dir, ref: args?.name }); return { ok: true } } }
+    if (action === 'addRemote') { await git.addRemote({ fs, dir, remote: args?.name, url: args?.url }); return { ok: true } }
+    if (action === 'push') { const remote = args?.remote; const url = args?.url; const ref = args?.branch || 'master'; let ghUser, gtUser; try { if (env.GITHUB_TOKEN) { ghUser = (await new Github(env.GITHUB_TOKEN).me()).login } } catch {} ; try { if (env.GITEA_URL && env.GITEA_TOKEN) { gtUser = (await new Gitea(env.GITEA_URL, env.GITEA_TOKEN).me()).login } } catch {} ; const onAuth = ({ url }) => { if (!url) return {}; if (url.includes('github.com')) return { username: ghUser || 'username', password: env.GITHUB_TOKEN }; if (env.GITEA_URL && url.includes(new URL(env.GITEA_URL).host)) return { username: gtUser || 'username', password: env.GITEA_TOKEN }; return {} } ; const opts = { fs, http, dir, ref, onAuth }; if (remote) opts.remote = remote; if (url) opts.url = url; if (!remote && !url) { const origin = await git.getConfig({ fs, dir, path: 'remote.origin.url' }); if (origin) { opts.remote = 'origin' } else { throw new Error('Remote ou URL não fornecido e nenhum remote.origin.url configurado') } } try { await git.push(opts); return { ok: true } } catch (e) { // fallback: conteúdo via API
+        const name = deriveProjectName(dir); const files = (await fs.promises.readdir(dir)).filter(f => f !== '.git')
+        const gitea = env.GITEA_URL && env.GITEA_TOKEN ? new Gitea(env.GITEA_URL, env.GITEA_TOKEN) : null
+        const github = env.GITHUB_TOKEN ? new Github(env.GITHUB_TOKEN) : null
+        for (const f of files) {
+          const p = path.join(dir, f); if (fs.statSync(p).isFile()) { const content = fs.readFileSync(p).toString('base64'); try { if (gitea) await gitea.putContent(name, f, content, 'mcp push fallback', ref) } catch {} ; try { if (github) await github.putContent(name, f, content, 'mcp push fallback', ref) } catch {} }
+        }
+        return { ok: true, fallback: true }
+      }
+    }
+    if (action === 'pull') { const remote = args?.remote; const url = args?.url; const ref = args?.branch || 'master'; let ghUser, gtUser; try { if (env.GITHUB_TOKEN) { ghUser = (await new Github(env.GITHUB_TOKEN).me()).login } } catch {} ; try { if (env.GITEA_URL && env.GITEA_TOKEN) { gtUser = (await new Gitea(env.GITEA_URL, env.GITEA_TOKEN).me()).login } } catch {} ; const onAuth = ({ url }) => { if (!url) return {}; if (url.includes('github.com')) return { username: ghUser || 'git', password: env.GITHUB_TOKEN }; if (env.GITEA_URL && url.includes(new URL(env.GITEA_URL).host)) return { username: gtUser || 'git', password: env.GITEA_TOKEN }; return {} } ; const opts = { fs, http, dir, ref, singleBranch: true, onAuth }; if (remote) opts.remote = remote; if (url) opts.url = url; if (!remote && !url) { const origin = await git.getConfig({ fs, dir, path: 'remote.origin.url' }); if (origin) { opts.remote = 'origin' } else { throw new Error('Remote ou URL não fornecido e nenhum remote.origin.url configurado') } } await git.pull(opts); return { ok: true } }
+    if (action === 'clone') { const url = args?.url; const ref = args?.branch || 'main'; const onAuth = ({ url }) => { if (url.includes('github.com')) return { username: env.GITHUB_TOKEN, password: 'x-oauth-basic' }; if (env.GITEA_URL && url.includes(new URL(env.GITEA_URL).host)) return { username: env.GITEA_TOKEN, password: '' }; return {} } ; await git.clone({ fs, http, dir, url, ref }); return { ok: true } }
+    return { error: 'ação inválida' }
+  }
+}
+
+export function getSchema() {
+  return makeSchema({
+    name: 'git-local',
+    description: 'Operações locais Git independentes de git nativo',
+    actions: {
+      status: { description: 'Listar estado dos arquivos' },
+      init: { description: 'Inicializar repositório local' },
+      add: { description: 'Adicionar arquivos ao índice' },
+      commit: { description: 'Criar commit local' },
+      branch: { description: 'Gerenciar branches (list/create/switch)' },
+      tag: { description: 'Gerenciar tags (list/create)' },
+      push: { description: 'Enviar para remoto ou URL com fallback' },
+      pull: { description: 'Buscar alterações do remoto/URL' },
+      clone: { description: 'Clonar repo para projectPath' }
+    }
+  })
+}

package/src/tools/git-meta.js

@@ -0,0 +1,19 @@
+export class GitMetaTool {
+  constructor(env) { this.env = env }
+  async handle(action, projectPath, args) {
+    if (action === 'list') {
+      const names = ['git-local','git-remote','git-sync','git-repos','git-contents','git-commits','git-issues-prs','git-releases','git-actions','git-activity','git-search','git-gitdata','git-checks','git-deployments','git-misc','git-gists','git-packages','git-raw','git-admin','git-user','git-orgs']
+      const res = {}
+      for (const n of names) {
+        const mod = await import(`./${n}.js`)
+        if (mod.getSchema) res[n] = mod.getSchema()
+      }
+      return res
+    }
+    if (action === 'get') {
+      const mod = await import(`./${args?.name}.js`)
+      return mod.getSchema ? mod.getSchema() : null
+    }
+    return { error: 'ação inválida' }
+  }
+}

package/src/tools/git-misc.js

@@ -0,0 +1,21 @@
+import { Gitea } from '../providers/gitea.js'
+import { Github } from '../providers/github.js'
+import { makeSchema } from './schema.js'
+
+export class GitMiscTool {
+  constructor(env) { this.gitea = new Gitea(env.GITEA_URL, env.GITEA_TOKEN); this.github = new Github(env.GITHUB_TOKEN) }
+  async handle(action, projectPath, args) {
+    if (action === 'version') return await this.gitea.request('GET', '/version')
+    if (action === 'markdown') { const text = args?.text || '# Hello'; const r = await Promise.allSettled([ this.gitea.request('POST', '/markdown', { text, mode: 'markdown' }), this.github.request('POST', '/markdown', { text }) ]); return r.map(x => x.status === 'fulfilled' ? x.value : { error: x.reason?.message }) }
+    if (action === 'markdown-raw') return await this.gitea.request('POST', '/markdown/raw', { body: args?.body || '# Hello' })
+    if (action === 'licenses') return await this.gitea.request('GET', '/licenses')
+    if (action === 'gitignore-templates') return await this.gitea.request('GET', '/gitignore/templates')
+    if (action === 'label-templates') return await this.gitea.request('GET', '/label/templates')
+    if (action === 'emojis') return await this.github.request('GET', '/emojis')
+    if (action === 'rate_limit') return await this.github.request('GET', '/rate_limit')
+    if (action === 'zen') return await this.github.request('GET', '/zen')
+    return { error: 'ação inválida' }
+  }
+}
+
+export function getSchema() { return makeSchema({ name: 'git-misc', description: 'Endpoints diversos (Gitea/GitHub)', actions: { version: { description: 'Versão do servidor Gitea' }, markdown: { description: 'Renderizar markdown' }, 'markdown-raw': { description: 'Renderizar markdown raw (Gitea)' }, licenses: { description: 'Licenças (Gitea)' }, 'gitignore-templates': { description: 'Templates gitignore (Gitea)' }, 'label-templates': { description: 'Templates de labels (Gitea)' }, emojis: { description: 'Emojis (GitHub)' }, rate_limit: { description: 'Limite de rate (GitHub)' }, zen: { description: 'Frase zen (GitHub)' } } }) }