@andrebuzeli/git-mcp 11.0.5 → 12.0.0

package/src/tools/git-contents.js

@@ -1,30 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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-local.js

@@ -1,66 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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)' } } }) }

package/src/tools/git-orgs.js

@@ -1,26 +0,0 @@
-import { Gitea } from '../providers/gitea.js'
-import { Github } from '../providers/github.js'
-import { makeSchema } from './schema.js'
-
-export class GitOrgsTool {
-  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 === 'create') return await this.gitea.request('POST', '/orgs', { username: args?.org_name, visibility: args?.visibility || 'public' })
-    if (action === 'list') { const r = await Promise.allSettled([ this.gitea.request('GET', '/orgs'), this.github.request('GET', '/user/orgs') ]); return r.map(x => x.status === 'fulfilled' ? x.value : { error: x.reason?.message }) }
-    if (action === 'get') { const r = await Promise.allSettled([ this.gitea.request('GET', `/orgs/${args?.org_name}`), this.github.request('GET', `/orgs/${args?.org_name}`) ]); return r.map(x => x.status === 'fulfilled' ? x.value : { error: x.reason?.message }) }
-    if (action === 'members') return await this.gitea.request('GET', `/orgs/${args?.org_name}/members`)
-    if (action === 'public_members') return await this.gitea.request('GET', `/orgs/${args?.org_name}/public_members`)
-    if (action === 'repos') return await this.gitea.request('GET', `/orgs/${args?.org_name}/repos`)
-    if (action === 'activities') return await this.gitea.request('GET', `/orgs/${args?.org_name}/activities/feeds`)
-    if (action === 'hooks') return await this.gitea.request('GET', `/orgs/${args?.org_name}/hooks`)
-    if (action === 'team-create') return await this.gitea.request('POST', `/orgs/${args?.org_name}/teams`, { name: args?.name || 'Team', permission: args?.permission || 'read' })
-    if (action === 'team-get') return await this.gitea.request('GET', `/api/v1/teams/${args?.team_id}`)
-    if (action === 'team-members') return await this.gitea.request('GET', `/teams/${args?.team_id}/members`)
-    if (action === 'team-repos') return await this.gitea.request('GET', `/teams/${args?.team_id}/repos`)
-    if (action === 'labels') return await this.gitea.request('GET', `/orgs/${args?.org_name}/labels`)
-    if (action === 'delete') return await this.gitea.request('DELETE', `/orgs/${args?.org_name}`)
-    return { error: 'ação inválida' }
-  }
-}
-
-export function getSchema() { return makeSchema({ name: 'git-orgs', description: 'Organizações e times (Gitea)', actions: { create: { description: 'Criar organização' }, list: { description: 'Listar organizações' }, get: { description: 'Obter organização' }, members: { description: 'Membros' }, public_members: { description: 'Membros públicos' }, repos: { description: 'Repositórios' }, activities: { description: 'Atividades' }, hooks: { description: 'Hooks' }, 'team-create': { description: 'Criar time' }, 'team-get': { description: 'Obter time' }, 'team-members': { description: 'Membros do time' }, 'team-repos': { description: 'Repos do time' }, labels: { description: 'Labels da org' }, delete: { description: 'Excluir organização' } } }) }

package/src/tools/git-packages.js

@@ -1,12 +0,0 @@
-import { Gitea } from '../providers/gitea.js'
-import { makeSchema } from './schema.js'
-
-export class GitPackagesTool {
-  constructor(env) { this.gitea = new Gitea(env.GITEA_URL, env.GITEA_TOKEN) }
-  async handle(action, projectPath, args) {
-    if (action === 'list') { const me = await this.gitea.me(); return await this.gitea.request('GET', `/packages/${me.login}`) }
-    return { error: 'ação inválida' }
-  }
-}
-
-export function getSchema() { return makeSchema({ name: 'git-packages', description: 'Pacotes (Gitea)', actions: { list: { description: 'Listar pacotes do usuário' } } }) }

package/src/tools/git-raw.js

@@ -1,14 +0,0 @@
-import { Gitea } from '../providers/gitea.js'
-import { deriveProjectName } from '../utils/project.js'
-import { makeSchema } from './schema.js'
-
-export class GitRawTool {
-  constructor(env) { this.gitea = new Gitea(env.GITEA_URL, env.GITEA_TOKEN) }
-  async handle(action, projectPath, args) {
-    const me = await this.gitea.me(); const name = deriveProjectName(projectPath); const repo = `${me.login}/${name}`
-    if (action === 'get') return await this.gitea.request('GET', `/repos/${repo}/raw/${args?.path || 'test.txt'}`)
-    return { error: 'ação inválida' }
-  }
-}
-
-export function getSchema() { return makeSchema({ name: 'git-raw', description: 'Conteúdo bruto (Gitea)', actions: { get: { description: 'Obter arquivo bruto' } } }) }

package/src/tools/git-releases.js

@@ -1,17 +0,0 @@
-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 GitReleasesTool {
-  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 tag = args?.tag || 'v1.0.0'; const title = args?.title || tag; const body = args?.body || ''; const r = await Promise.allSettled([ this.providers.gitea.createRelease(name, tag, title, body), this.providers.github.createRelease(name, tag, title, body) ]); return r.map(x => x.status === 'fulfilled' ? x.value : { error: x.reason?.message }) }
-    return { error: 'ação inválida' }
-  }
-}
-
-export function getSchema() {
-  return makeSchema({ name: 'git-releases', description: 'Gerenciar releases', actions: { create: { description: 'Criar release (tag/title/body)' } } })
-}

package/src/tools/git-repos.js

@@ -1,60 +0,0 @@
-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 GitReposTool {
-  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 repoFullG = `${meG.login}/${name}`
-    const repoFullH = `${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 === 'get') return await par(() => this.providers.gitea.request('GET', `/repos/${repoFullG}`), () => this.providers.github.request('GET', `/repos/${repoFullH}`))
-    if (action === 'patch') return await par(() => this.providers.gitea.request('PATCH', `/repos/${repoFullG}`, { description: args?.description || 'Updated' }), () => this.providers.github.request('PATCH', `/repos/${repoFullH}`, { description: args?.description || 'Updated' }))
-    if (action === 'languages') return await par(() => this.providers.gitea.request('GET', `/repos/${repoFullG}/languages`), () => this.providers.github.request('GET', `/repos/${repoFullH}/languages`))
-    if (action === 'tags') return await par(() => this.providers.gitea.request('GET', `/repos/${repoFullG}/tags`), () => this.providers.github.request('GET', `/repos/${repoFullH}/tags`))
-    if (action === 'topics-get') return await par(() => this.providers.gitea.request('GET', `/repos/${repoFullG}/topics`), () => this.providers.github.request('GET', `/repos/${repoFullH}/topics`))
-    if (action === 'topics-put') return await par(() => this.providers.gitea.request('PUT', `/repos/${repoFullG}/topics`, { topics: args?.topics || ['test'] }), () => this.providers.github.request('PUT', `/repos/${repoFullH}/topics`, { names: args?.topics || ['test'] }))
-    if (action === 'collaborators') return await par(() => this.providers.gitea.request('GET', `/repos/${repoFullG}/collaborators`), () => this.providers.github.request('GET', `/repos/${repoFullH}/collaborators`))
-    if (action === 'subscribers') return await par(() => this.providers.gitea.request('GET', `/repos/${repoFullG}/subscribers`), () => this.providers.github.request('GET', `/repos/${repoFullH}/subscribers`))
-    if (action === 'subscription-get') return await par(() => this.providers.gitea.request('GET', `/repos/${repoFullG}/subscription`), () => this.providers.github.request('GET', `/repos/${repoFullH}/subscription`))
-    if (action === 'subscription-put') return await par(() => this.providers.gitea.request('PUT', `/repos/${repoFullG}/subscription`, { subscribed: true }), () => this.providers.github.request('PUT', `/repos/${repoFullH}/subscription`, { subscribed: true }))
-    if (action === 'subscription-delete') return await par(() => this.providers.gitea.request('DELETE', `/repos/${repoFullG}/subscription`), () => this.providers.github.request('DELETE', `/repos/${repoFullH}/subscription`))
-    if (action === 'stargazers') return await par(() => this.providers.gitea.request('GET', `/repos/${repoFullG}/stargazers`), () => this.providers.github.request('GET', `/repos/${repoFullH}/stargazers`))
-    if (action === 'forks-get') return await par(() => this.providers.gitea.request('GET', `/repos/${repoFullG}/forks`), () => this.providers.github.request('GET', `/repos/${repoFullH}/forks`))
-    if (action === 'forks-post') return await par(() => this.providers.gitea.request('POST', `/repos/${repoFullG}/forks`), () => this.providers.github.request('POST', `/repos/${repoFullH}/forks`))
-    if (action === 'activities') return await par(() => this.providers.gitea.request('GET', `/repos/${repoFullG}/activities/feeds`), () => this.providers.github.request('GET', `/repos/${repoFullH}/events`))
-    if (action === 'hooks') return await par(() => this.providers.gitea.request('GET', `/repos/${repoFullG}/hooks`), () => this.providers.github.request('GET', `/repos/${repoFullH}/hooks`))
-    if (action === 'keys') return await par(() => this.providers.gitea.request('GET', `/repos/${repoFullG}/keys`), () => this.providers.github.request('GET', `/repos/${repoFullH}/keys`))
-    return { error: 'ação inválida' }
-  }
-}
-
-export function getSchema() {
-  return makeSchema({
-    name: 'git-repos',
-    description: 'Metadados e relações de repositórios',
-    actions: {
-      get: { description: 'Obter repositório' },
-      patch: { description: 'Atualizar descrição' },
-      languages: { description: 'Listar linguagens' },
-      tags: { description: 'Listar tags' },
-      'topics-get': { description: 'Obter tópicos' },
-      'topics-put': { description: 'Definir tópicos' },
-      collaborators: { description: 'Listar colaboradores' },
-      subscribers: { description: 'Listar assinantes' },
-      'subscription-get': { description: 'Obter assinatura' },
-      'subscription-put': { description: 'Assinar repo' },
-      'subscription-delete': { description: 'Cancelar assinatura' },
-      stargazers: { description: 'Listar estrelas' },
-      'forks-get': { description: 'Listar forks' },
-      'forks-post': { description: 'Criar fork' },
-      activities: { description: 'Feed de atividades' },
-      hooks: { description: 'Hooks do repo' },
-      keys: { description: 'Chaves do repo' }
-    }
-  })
-}

package/src/tools/git-search.js

@@ -1,18 +0,0 @@
-import { Gitea } from '../providers/gitea.js'
-import { Github } from '../providers/github.js'
-import { makeSchema } from './schema.js'
-
-export class GitSearchTool {
-  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 === 'repos') { const q = args?.q || 'user:defunkt'; return await this.github.request('GET', `/search/repositories?q=${encodeURIComponent(q)}`) }
-    if (action === 'users') { const q = args?.q || 'tom'; return await this.github.request('GET', `/search/users?q=${encodeURIComponent(q)}`) }
-    if (action === 'issues') { const q = args?.q || 'type:issue+user:defunkt'; return await this.github.request('GET', `/search/issues?q=${encodeURIComponent(q)}`) }
-    if (action === 'repos-gitea') return await this.gitea.request('GET', '/repos/search')
-    return { error: 'ação inválida' }
-  }
-}
-
-export function getSchema() {
-  return makeSchema({ name: 'git-search', description: 'Busca em GitHub/Gitea', actions: { repos: { description: 'Buscar repositórios (GitHub)' }, users: { description: 'Buscar usuários (GitHub)' }, issues: { description: 'Buscar issues (GitHub)' }, 'repos-gitea': { description: 'Buscar repositórios (Gitea)' } } })
-}

package/src/tools/git-user.js

@@ -1,26 +0,0 @@
-import { Gitea } from '../providers/gitea.js'
-import { Github } from '../providers/github.js'
-import { makeSchema } from './schema.js'
-
-export class GitUserTool {
-  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 === 'me') { const r = await Promise.allSettled([ this.gitea.request('GET', '/user'), this.github.request('GET', '/user') ]); return r.map(x => x.status === 'fulfilled' ? x.value : { error: x.reason?.message }) }
-    if (action === 'users-search') return await this.gitea.request('GET', '/users/search')
-    if (action === 'user-get') return await this.gitea.request('GET', `/users/${args?.username}`)
-    if (action === 'heatmap') return await this.gitea.request('GET', `/users/${args?.username}/heatmap`)
-    if (action === 'followers') { const r = await Promise.allSettled([ this.gitea.request('GET', `/users/${args?.username}/followers`), this.github.request('GET', '/user/followers') ]); return r.map(x => x.status === 'fulfilled' ? x.value : { error: x.reason?.message }) }
-    if (action === 'following') { const r = await Promise.allSettled([ this.gitea.request('GET', `/users/${args?.username}/following`), this.github.request('GET', '/user/following') ]); return r.map(x => x.status === 'fulfilled' ? x.value : { error: x.reason?.message }) }
-    if (action === 'keys') { const r = await Promise.allSettled([ this.gitea.request('GET', `/users/${args?.username}/keys`), this.github.request('GET', '/user/keys') ]); return r.map(x => x.status === 'fulfilled' ? x.value : { error: x.reason?.message }) }
-    if (action === 'gpg_keys') { const r = await Promise.allSettled([ this.gitea.request('GET', `/users/${args?.username}/gpg_keys`), this.github.request('GET', '/user/gpg_keys') ]); return r.map(x => x.status === 'fulfilled' ? x.value : { error: x.reason?.message }) }
-    if (action === 'oauth2-apps') return await this.gitea.request('GET', '/user/applications/oauth2')
-    if (action === 'emails') { const r = await Promise.allSettled([ this.gitea.request('GET', '/user/emails'), this.github.request('GET', '/user/emails') ]); return r.map(x => x.status === 'fulfilled' ? x.value : { error: x.reason?.message }) }
-    if (action === 'starred') { const r = await Promise.allSettled([ this.gitea.request('GET', '/user/starred'), this.github.request('GET', '/user/starred') ]); return r.map(x => x.status === 'fulfilled' ? x.value : { error: x.reason?.message }) }
-    if (action === 'subscriptions') { const r = await Promise.allSettled([ this.gitea.request('GET', '/user/subscriptions'), this.github.request('GET', '/user/subscriptions') ]); return r.map(x => x.status === 'fulfilled' ? x.value : { error: x.reason?.message }) }
-    if (action === 'stopwatches') return await this.gitea.request('GET', '/user/stopwatches')
-    if (action === 'settings') return await this.gitea.request('GET', '/user/settings')
-    return { error: 'ação inválida' }
-  }
-}
-
-export function getSchema() { return makeSchema({ name: 'git-user', description: 'Perfil e dados de usuário (Gitea/GitHub)', actions: { me: { description: 'Dados do usuário autenticado' }, 'users-search': { description: 'Buscar usuários (Gitea)' }, 'user-get': { description: 'Obter usuário (Gitea)' }, heatmap: { description: 'Heatmap (Gitea)' }, followers: { description: 'Seguidores' }, following: { description: 'Seguindo' }, keys: { description: 'Chaves SSH' }, gpg_keys: { description: 'Chaves GPG' }, 'oauth2-apps': { description: 'Apps OAuth2 (Gitea)' }, emails: { description: 'Emails' }, starred: { description: 'Repos estrelados' }, subscriptions: { description: 'Assinaturas' }, stopwatches: { description: 'Cronômetros (Gitea)' }, settings: { description: 'Configurações (Gitea)' } } }) }

package/src/tools/schema.js

@@ -1,3 +0,0 @@
-export function makeSchema({ name, description, params = ["projectPath", "action", "args"], actions }) {
-  return { name, description, params, actions }
-}

package/src/utils/fs.js

@@ -1,29 +0,0 @@
-import fs from 'fs'
-import path from 'path'
-
-export function listFilesRecursive(dir) {
-  const out = []
-  function walk(d) {
-    const entries = fs.readdirSync(d, { withFileTypes: true })
-    for (const e of entries) {
-      const p = path.join(d, e.name)
-      if (e.isDirectory()) {
-        if (e.name === '.git') continue
-        walk(p)
-      } else {
-        out.push(p)
-      }
-    }
-  }
-  walk(dir)
-  return out
-}
-
-export function toProjectRelative(dir, filePath) {
-  return path.relative(dir, filePath).split(path.sep).join('/')
-}
-
-export function readBase64(filePath) {
-  const buf = fs.readFileSync(filePath)
-  return buf.toString('base64')
-}

package/src/utils/project.js

@@ -1,7 +0,0 @@
-import path from 'path'
-
-export function deriveProjectName(projectPath) {
-  const base = path.basename(projectPath).replace(/\s+/g, '_')
-  const s = base.replace(/[^A-Za-z0-9_.-]/g, '_').replace(/_+/g, '_').replace(/^\.+/, '')
-  return s
-}

package/tests/errors.js

@@ -1,26 +0,0 @@
-import { callOnce } from '../src/server.js'
-import fs from 'fs'
-const projectPath = process.env.TEST_PROJECT || 'Z:/MCP/GIT MCP/temp_git_mcp_test'
-
-async function main() {
-  if (!fs.existsSync(projectPath)) fs.mkdirSync(projectPath, { recursive: true })
-  fs.writeFileSync(projectPath + '/err.txt', 'X')
-  const wrap = async (name, fn) => { try { const r = await fn(); console.log(name + ': OK' + (r?.fallback ? ' (fallback)' : '')) } catch (e) { console.log(name + ': ERR ' + e?.message) } }
-
-  // Missing remote -> ensureRemotes then push
-  await wrap('ensureRemotes', () => callOnce({ tool: 'git-remote', action: 'ensureRemotes', projectPath }))
-  await wrap('push-fallback', () => callOnce({ tool: 'git-local', action: 'push', projectPath, args: { branch: 'master' } }))
-
-  // Issue labels with nonexistent label -> autocreate and apply
-  await wrap('labels-create', () => callOnce({ tool: 'git-issues-prs', action: 'labels-create', projectPath, args: { name: 'bug', color: 'ff0000' } }))
-  const issue = await callOnce({ tool: 'git-issues-prs', action: 'issue-create', projectPath, args: { title: 'Err Issue', body: 'B' } })
-  const num = Array.isArray(issue) ? (issue[1]?.number) : issue?.number
-  await wrap('issue-labels-autocorrect', () => callOnce({ tool: 'git-issues-prs', action: 'issue-labels', projectPath, args: { number: num, labels: ['bug'] } }))
-
-  // PR head inexistente -> autocorreção criando branch/arquivo e reabrindo
-  await wrap('pr-create-autocorrect', () => callOnce({ tool: 'git-issues-prs', action: 'pr-create', projectPath, args: { title: 'PR Err', head: 'feature-branch', base: 'main' } }))
-
-  console.log('ERROR TESTS DONE')
-}
-
-main().catch(e => { console.error(e); process.exit(1) })