@andrebuzeli/git-mcp 10.0.9 → 11.0.0

package/src/tools/git-orgs.js

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

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

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

@@ -0,0 +1,17 @@
+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-remote.js

@@ -0,0 +1,29 @@
+import { Gitea } from '../providers/gitea.js'
+import { Github } from '../providers/github.js'
+import { deriveProjectName } from '../utils/project.js'
+import fs from 'fs'
+import git from 'isomorphic-git'
+import { makeSchema } from './schema.js'
+
+export class GitRemoteTool {
+  constructor(env) { this.env = 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 === 'createRepo') { const r = await Promise.allSettled([ this.providers.gitea.createRepo(name, false, true), this.providers.github.createRepo(name, false, true) ]); return r.map(x => x.status === 'fulfilled' ? x.value : { error: x.reason?.message }) }
+    if (action === 'deleteRepo') { const r = await Promise.allSettled([ this.providers.gitea.deleteRepo(name), this.providers.github.deleteRepo(name) ]); return r.map(x => x.status === 'fulfilled' ? x.value : { error: x.reason?.message }) }
+    if (action === 'ensureRemotes') { const urls = await Promise.all([ this.providers.gitea.repoHttpsUrl(name), this.providers.github.repoHttpsUrl(name) ]); try { await git.addRemote({ fs, dir: projectPath, remote: 'origin-gitea', url: urls[0] }) } catch {} ; try { await git.addRemote({ fs, dir: projectPath, remote: 'origin-github', url: urls[1] }) } catch {} ; return { gitea: urls[0], github: urls[1] } }
+    return { error: 'ação inválida' }
+  }
+}
+
+export function getSchema() {
+  return makeSchema({
+    name: 'git-remote',
+    description: 'Operações remotas simultâneas Gitea/GitHub (repos/remotes)',
+    actions: {
+      createRepo: { description: 'Criar repositório nos provedores' },
+      deleteRepo: { description: 'Excluir repositório nos provedores' },
+      ensureRemotes: { description: 'Garantir remotes origin-gitea/github' }
+    }
+  })
+}

package/src/tools/git-repos.js

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

@@ -0,0 +1,18 @@
+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-sync.js

@@ -0,0 +1,40 @@
+import { deriveProjectName } from '../utils/project.js'
+import { GitLocalTool } from './git-local.js'
+import { GitRemoteTool } from './git-remote.js'
+import { listFilesRecursive, toProjectRelative, readBase64 } from '../utils/fs.js'
+import { Gitea } from '../providers/gitea.js'
+import { Github } from '../providers/github.js'
+import { makeSchema } from './schema.js'
+
+export class GitSyncTool {
+  constructor(env) { this.env = env; this.local = new GitLocalTool(); this.remote = new GitRemoteTool(env) }
+  async handle(action, projectPath, args) {
+    if (action === 'mirror') {
+      await this.remote.handle('createRepo', projectPath, args)
+      const rem = await this.remote.handle('ensureRemotes', projectPath, args)
+      try { await this.local.handle('push', projectPath, { remote: 'origin-gitea', branch: args?.branch || 'master' }, this.env) } catch {}
+      try { await this.local.handle('push', projectPath, { remote: 'origin-github', branch: args?.branch || 'master' }, this.env) } catch {}
+      // Fallback por API: subir todos arquivos via contents
+      const files = listFilesRecursive(projectPath)
+      const gitea = new Gitea(this.env.GITEA_URL, this.env.GITEA_TOKEN)
+      const github = new Github(this.env.GITHUB_TOKEN)
+      const name = deriveProjectName(projectPath)
+      for (const f of files) {
+        const rel = toProjectRelative(projectPath, f)
+        const content = readBase64(f)
+        try { await gitea.putContent(name, rel, content, 'mcp sync', args?.branch || 'master') } catch {}
+        try { await github.putContent(name, rel, content, 'mcp sync', args?.branch || 'master') } catch {}
+      }
+      return { ok: true }
+    }
+    return { error: 'ação inválida' }
+  }
+}
+
+export function getSchema() {
+  return makeSchema({
+    name: 'git-sync',
+    description: 'Espelhamento e sincronização completa entre provedores',
+    actions: { mirror: { description: 'Push e fallback via Contents API' } }
+  })
+}

package/src/tools/git-user.js

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

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

package/src/utils/fs.js

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

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

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

package/tests/full_suite.js

@@ -0,0 +1,98 @@
+import { callOnce } from '../src/server.js'
+import fs from 'fs'
+
+function log(name, res) { const ok = typeof res === 'object' && res !== null && res.ok === false ? false : true; console.log(`${name}: ${ok ? 'OK' : 'ERR'}`) }
+
+async function main() {
+  const projectPath = process.env.TEST_PROJECT || 'Z:/MCP/GIT MCP/temp_git_mcp_test_full'
+  if (!fs.existsSync(projectPath)) fs.mkdirSync(projectPath, { recursive: true })
+  fs.writeFileSync(projectPath + '/README.md', '# Full Suite')
+  fs.writeFileSync(projectPath + '/file.txt', 'content')
+
+  await callOnce({ tool: 'git-local', action: 'init', projectPath })
+  await callOnce({ tool: 'git-local', action: 'add', projectPath, args: { patterns: ['README.md', 'file.txt'] } })
+  await callOnce({ tool: 'git-local', action: 'commit', projectPath, args: { message: 'init' } })
+
+  log('git-remote.createRepo', await callOnce({ tool: 'git-remote', action: 'createRepo', projectPath }))
+  const rem = await callOnce({ tool: 'git-remote', action: 'ensureRemotes', projectPath })
+  log('git-remote.ensureRemotes', rem)
+
+  // Full mirror (push then contents fallback)
+  log('git-sync.mirror', await callOnce({ tool: 'git-sync', action: 'mirror', projectPath, args: { branch: 'master' } }))
+
+  // Repos metadata
+  log('git-repos.get', await callOnce({ tool: 'git-repos', action: 'get', projectPath }))
+  log('git-repos.patch', await callOnce({ tool: 'git-repos', action: 'patch', projectPath, args: { description: 'Updated by full suite' } }))
+  log('git-repos.languages', await callOnce({ tool: 'git-repos', action: 'languages', projectPath }))
+  log('git-repos.tags', await callOnce({ tool: 'git-repos', action: 'tags', projectPath }))
+  log('git-repos.topics-put', await callOnce({ tool: 'git-repos', action: 'topics-put', projectPath, args: { topics: ['mcp','git'] } }))
+  log('git-repos.subscription-get', await callOnce({ tool: 'git-repos', action: 'subscription-get', projectPath }))
+  log('git-repos.subscription-put', await callOnce({ tool: 'git-repos', action: 'subscription-put', projectPath }))
+  log('git-repos.subscription-delete', await callOnce({ tool: 'git-repos', action: 'subscription-delete', projectPath }))
+
+  // Contents
+  log('git-contents.create', await callOnce({ tool: 'git-contents', action: 'create', projectPath, args: { path: 'api.txt', content: Buffer.from('hello').toString('base64'), message: 'add api', branch: 'master' } }))
+  log('git-contents.get', await callOnce({ tool: 'git-contents', action: 'get', projectPath, args: { path: 'api.txt' } }))
+
+  // Commits & branches
+  log('git-commits.branches', await callOnce({ tool: 'git-commits', action: 'branches', projectPath }))
+  log('git-commits.create-branch', await callOnce({ tool: 'git-commits', action: 'create-branch', projectPath, args: { name: 'dev', from: 'master' } }))
+  log('git-commits.branch-protections', await callOnce({ tool: 'git-commits', action: 'branch-protections', projectPath }))
+  const refs = await callOnce({ tool: 'git-commits', action: 'refs', projectPath })
+  log('git-commits.refs', refs)
+  let sha
+  try { const ghRefs = Array.isArray(refs) ? refs[1] : refs; if (Array.isArray(ghRefs)) { const head = ghRefs.find(r => r?.ref?.endsWith('master') || r?.ref?.endsWith('main')); sha = head?.object?.sha } } catch {}
+
+  // Issues & PRs & labels & milestones
+  log('git-issues-prs.labels-create', await 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: 'Issue Full', body: 'Body' } })
+  log('git-issues-prs.issue-create', issue)
+  const issueNum = Array.isArray(issue) ? (issue[1]?.number || issue[0]?.number) : issue?.number
+  if (issueNum) {
+    log('git-issues-prs.issue-comment', await callOnce({ tool: 'git-issues-prs', action: 'issue-comment', projectPath, args: { number: issueNum, comment: 'Comment' } }))
+    log('git-issues-prs.issue-labels', await callOnce({ tool: 'git-issues-prs', action: 'issue-labels', projectPath, args: { number: issueNum, labels: ['bug'] } }))
+  }
+  log('git-issues-prs.milestones-create', await callOnce({ tool: 'git-issues-prs', action: 'milestones-create', projectPath, args: { title: 'v1.0' } }))
+  log('git-issues-prs.pr-create', await callOnce({ tool: 'git-issues-prs', action: 'pr-create', projectPath, args: { title: 'PR Full', head: 'dev', base: 'master' } }))
+
+  // Releases
+  log('git-releases.create', await callOnce({ tool: 'git-releases', action: 'create', projectPath, args: { tag: 'v1.0.0', title: 'v1.0.0', body: 'Desc' } }))
+
+  // Actions (GitHub)
+  log('git-actions.workflows', await callOnce({ tool: 'git-actions', action: 'workflows', projectPath }))
+  log('git-actions.runs', await callOnce({ tool: 'git-actions', action: 'runs', projectPath }))
+
+  // Activity
+  log('git-activity.notifications-get', await callOnce({ tool: 'git-activity', action: 'notifications-get', projectPath }))
+  log('git-activity.events', await callOnce({ tool: 'git-activity', action: 'events', projectPath }))
+
+  // Search
+  log('git-search.repos', await callOnce({ tool: 'git-search', action: 'repos', projectPath }))
+  log('git-search.users', await callOnce({ tool: 'git-search', action: 'users', projectPath }))
+
+  // Git Data (GitHub)
+  if (sha) {
+    log('git-checks.status', await callOnce({ tool: 'git-checks', action: 'status', projectPath, args: { sha, state: 'success', context: 'full-suite' } }))
+    log('git-deployments.create', await callOnce({ tool: 'git-deployments', action: 'create', projectPath }))
+  }
+
+  // Misc
+  log('git-misc.version', await callOnce({ tool: 'git-misc', action: 'version', projectPath }))
+  log('git-misc.markdown', await callOnce({ tool: 'git-misc', action: 'markdown', projectPath, args: { text: '# Hello' } }))
+
+  // Gists (GitHub)
+  const gist = await callOnce({ tool: 'git-gists', action: 'create', projectPath, args: { description: 'Full', public: false, files: { 't.txt': { content: 'x' } } } })
+  log('git-gists.create', gist)
+  const gid = gist?.id || gist?.[0]?.id || gist?.[1]?.id
+  if (gid) {
+    log('git-gists.star', await callOnce({ tool: 'git-gists', action: 'star', projectPath, args: { id: gid } }))
+    log('git-gists.delete', await callOnce({ tool: 'git-gists', action: 'delete', projectPath, args: { id: gid } }))
+  }
+
+  // Packages (Gitea)
+  log('git-packages.list', await callOnce({ tool: 'git-packages', action: 'list', projectPath }))
+
+  console.log('FULL SUITE DONE')
+}
+
+main().catch(e => { console.error(e); process.exit(1) })

package/tests/run.js

@@ -0,0 +1,50 @@
+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 + '/README.md', 'Test')
+  const log = (name, res) => { console.log(name + ': ' + (res && res.ok === false ? 'ERR' : 'OK')) }
+
+  await callOnce({ tool: 'git-local', action: 'init', projectPath })
+  await callOnce({ tool: 'git-local', action: 'add', projectPath, args: { patterns: ['README.md'] } })
+  await callOnce({ tool: 'git-local', action: 'commit', projectPath, args: { message: 'init' } })
+
+  log('git-remote.createRepo', await callOnce({ tool: 'git-remote', action: 'createRepo', projectPath }))
+  const remotes = await callOnce({ tool: 'git-remote', action: 'ensureRemotes', projectPath })
+  log('git-remote.ensureRemotes', remotes)
+  await callOnce({ tool: 'git-local', action: 'addRemote', projectPath, args: { name: 'origin-gitea', url: remotes.gitea } })
+  await callOnce({ tool: 'git-local', action: 'addRemote', projectPath, args: { name: 'origin-github', url: remotes.github } })
+
+  log('git-local.push(github)', await callOnce({ tool: 'git-local', action: 'push', projectPath, args: { url: remotes.github, branch: 'master' } }))
+
+  const calls = [
+    { tool: 'git-repos', action: 'get' },
+    { tool: 'git-repos', action: 'languages' },
+    { tool: 'git-repos', action: 'tags' },
+    { tool: 'git-repos', action: 'topics-put', args: { topics: ['test'] } },
+    { tool: 'git-contents', action: 'create', args: { path: 'test.txt', content: Buffer.from('Hello').toString('base64'), message: 'Add file', branch: 'master' } },
+    { tool: 'git-contents', action: 'get', args: { path: 'test.txt' } },
+    { tool: 'git-commits', action: 'branches' },
+    { tool: 'git-commits', action: 'create-branch', args: { name: 'dev', from: 'main' } },
+    { tool: 'git-issues-prs', action: 'labels-create', args: { name: 'bug', color: 'ff0000' } },
+    { tool: 'git-issues-prs', action: 'issue-create', args: { title: 'Test Issue', body: 'Body' } },
+    { tool: 'git-releases', action: 'create', args: { tag: 'v1.0.0', title: 'v1.0.0', body: 'Release' } },
+    { tool: 'git-actions', action: 'workflows' },
+    { tool: 'git-activity', action: 'notifications-get' },
+    { tool: 'git-search', action: 'repos-gitea' },
+    { tool: 'git-misc', action: 'version' }
+  ]
+
+  for (const c of calls) {
+    const res = await callOnce({ tool: c.tool, action: c.action, projectPath, args: c.args })
+    log(`${c.tool}.${c.action}`, res)
+  }
+
+  // Mirror fallback via contents
+  await callOnce({ tool: 'git-sync', action: 'mirror', projectPath, args: { branch: 'master' } })
+  console.log('DONE')
+}
+
+main().catch(e => { console.error(e); process.exit(1) })

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2024 Andre Buzeli
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/dist/index.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};