@andrebuzeli/git-mcp 11.0.5 → 12.0.0

package/src/utils/gitAdapter.js

@@ -0,0 +1,116 @@
+import * as git from "isomorphic-git";
+import fs from "node:fs";
+import path from "node:path";
+import http from "isomorphic-git/http/node";
+import { MCPError } from "./errors.js";
+import { getProvidersEnv } from "./repoHelpers.js";
+
+export class GitAdapter {
+  constructor(providerManager) {
+    this.pm = providerManager;
+  }
+
+  async init(dir, defaultBranch = "main") {
+    await git.init({ fs, dir, defaultBranch });
+  }
+
+  async status(dir) {
+    const matrix = await git.statusMatrix({ fs, dir });
+    const FILE = 0, HEAD = 1, WORKDIR = 2, STAGE = 3;
+    const modified = [], created = [], deleted = [], not_added = [], files = [];
+    for (const row of matrix) {
+      const f = row[FILE], h = row[HEAD], w = row[WORKDIR], s = row[STAGE];
+      if (h === 0 && w === 2 && s === 0) { not_added.push(f); files.push({ path: f, working_dir: "new" }); }
+      else if (h === 0 && w === 2 && s === 2) { created.push(f); files.push({ path: f, index: "new", working_dir: "new" }); }
+      else if (h === 1 && w === 2 && s === 1) { not_added.push(f); files.push({ path: f, working_dir: "modified" }); }
+      else if (h === 1 && w === 2 && s === 2) { modified.push(f); files.push({ path: f, index: "modified", working_dir: "modified" }); }
+      else if (h === 1 && w === 0 && s === 1) { not_added.push(f); files.push({ path: f, working_dir: "deleted" }); }
+      else if (h === 1 && w === 0 && s === 0) { deleted.push(f); files.push({ path: f, index: "deleted", working_dir: "deleted" }); }
+    }
+    const current = await this.getCurrentBranch(dir);
+    const staged = [...modified, ...created, ...deleted];
+    const isClean = modified.length === 0 && created.length === 0 && deleted.length === 0 && not_added.length === 0;
+    return { modified, created, deleted, renamed: [], not_added, staged, conflicted: [], current, tracking: null, ahead: 0, behind: 0, isClean, files };
+  }
+
+  async add(dir, files) {
+    for (const fp of files) {
+      if (fp === ".") {
+        const matrix = await git.statusMatrix({ fs, dir });
+        for (const row of matrix) {
+          const file = row[0];
+          const work = row[2];
+          if (work === 2) await git.add({ fs, dir, filepath: file });
+          else if (work === 0 && row[1] === 1) await git.remove({ fs, dir, filepath: file });
+        }
+      } else {
+        await git.add({ fs, dir, filepath: fp });
+      }
+    }
+  }
+
+  async remove(dir, files) {
+    for (const fp of files) await git.remove({ fs, dir, filepath: fp });
+  }
+
+  async getAuthor(dir) {
+    const name = await git.getConfig({ fs, dir, path: "user.name" }).catch(() => "");
+    const email = await git.getConfig({ fs, dir, path: "user.email" }).catch(() => "");
+    if (name && email) return { name, email };
+    const ownerGH = await this.pm.getGitHubOwner();
+    const ownerGE = await this.pm.getGiteaOwner();
+    const who = ownerGH || ownerGE;
+    if (who) {
+      const inferred = { name: who, email: `${who}@users.noreply` };
+      await git.setConfig({ fs, dir, path: "user.name", value: inferred.name }).catch(() => {});
+      await git.setConfig({ fs, dir, path: "user.email", value: inferred.email }).catch(() => {});
+      return inferred;
+    }
+    throw new MCPError("AUTHOR_ERROR", "Configure user.name e user.email ou tokens de provider");
+  }
+
+  async commit(dir, message) {
+    const author = await this.getAuthor(dir);
+    const sha = await git.commit({ fs, dir, message, author: { name: author.name, email: author.email } });
+    return sha;
+  }
+
+  async getCurrentBranch(dir) {
+    return (await git.currentBranch({ fs, dir, fullname: false }).catch(() => "HEAD")) || "HEAD";
+  }
+
+  async ensureRemotes(dir, { githubUrl, giteaUrl }) {
+    const remotes = await git.listRemotes({ fs, dir });
+    const names = remotes.map(r => r.remote);
+    if (githubUrl && !names.includes("github")) await git.addRemote({ fs, dir, remote: "github", url: githubUrl });
+    if (giteaUrl && !names.includes("gitea")) await git.addRemote({ fs, dir, remote: "gitea", url: giteaUrl });
+    if (githubUrl && !names.includes("origin")) await git.addRemote({ fs, dir, remote: "origin", url: githubUrl });
+  }
+
+  getAuth(remoteUrl) {
+    const { githubToken, giteaToken } = getProvidersEnv();
+    if (remoteUrl.includes("github.com")) {
+      if (!githubToken) throw new MCPError("AUTH", "GITHUB_TOKEN ausente");
+      return () => ({ username: githubToken, password: "x-oauth-basic" });
+    }
+    if (giteaToken) return () => ({ username: "git", password: giteaToken });
+    throw new MCPError("AUTH", "GITEA_TOKEN ausente");
+  }
+
+  async pushOne(dir, remote, branch) {
+    const remotes = await git.listRemotes({ fs, dir });
+    const info = remotes.find(r => r.remote === remote);
+    if (!info) throw new MCPError("REMOTE", `Remote '${remote}' não encontrado`);
+    const onAuth = this.getAuth(info.url);
+    const ref = branch.startsWith("refs/") ? branch : `refs/heads/${branch}`;
+    await git.push({ fs, http, dir, remote, ref, remoteRef: ref, onAuth });
+  }
+
+  async pushParallel(dir, branch) {
+    const remotes = await git.listRemotes({ fs, dir });
+    const targets = remotes.filter(r => ["github", "gitea"].includes(r.remote));
+    if (targets.length === 0) throw new MCPError("REMOTE", "Nenhum remote github/gitea configurado");
+    await Promise.all(targets.map(t => this.pushOne(dir, t.remote, branch)));
+  }
+}
+

package/src/utils/providerExec.js

@@ -0,0 +1,13 @@
+export async function runBoth(pm, handlers) {
+  const out = { github: null, gitea: null };
+  const ghOwner = await pm.getGitHubOwner();
+  const geOwner = await pm.getGiteaOwner();
+  if (pm.github && ghOwner && handlers.github) {
+    try { out.github = await handlers.github(ghOwner); } catch (e) { out.github = { ok: false, error: String(e?.message || e) }; }
+  }
+  if (pm.giteaUrl && pm.giteaToken && geOwner && handlers.gitea) {
+    try { out.gitea = await handlers.gitea(geOwner); } catch (e) { out.gitea = { ok: false, error: String(e?.message || e) }; }
+  }
+  return out;
+}
+

package/src/utils/repoHelpers.js

@@ -0,0 +1,25 @@
+import path from "node:path";
+
+export function getRepoNameFromPath(projectPath) {
+  const base = path.basename(projectPath).trim();
+  return base.replace(/\s+/g, "_").replace(/[^A-Za-z0-9_\-]/g, "");
+}
+
+export function normalizeProjectFilePath(projectPath, relative) {
+  const joined = path.resolve(projectPath, relative || ".");
+  return joined;
+}
+
+export function getEnv(key) {
+  const v = process.env[key];
+  return v === undefined ? "" : String(v);
+}
+
+export function getProvidersEnv() {
+  return {
+    githubToken: getEnv("GITHUB_TOKEN"),
+    giteaUrl: getEnv("GITEA_URL"),
+    giteaToken: getEnv("GITEA_TOKEN"),
+  };
+}
+

package/src/utils/retry.js

@@ -0,0 +1,12 @@
+export async function withRetry(fn, { retries = 3, baseDelayMs = 300 } = {}) {
+  let attempt = 0;
+  let lastErr;
+  while (attempt < retries) {
+    try { return await fn(); } catch (e) { lastErr = e; }
+    const delay = baseDelayMs * Math.pow(2, attempt);
+    await new Promise(r => setTimeout(r, delay));
+    attempt++;
+  }
+  throw lastErr;
+}
+

package/bin/git-mcp.js

@@ -1,21 +0,0 @@
-#!/usr/bin/env node
-import { initMcpJson, startServer, callOnce } from '../src/server.js'
-
-const argv = process.argv.slice(2)
-const cmd = argv[0] || 'start'
-
-function getFlag(name) {
-  const idx = argv.findIndex(a => a === `--${name}`)
-  if (idx >= 0) return argv[idx + 1]
-  return undefined
-}
-
-async function main() {
-  if (cmd === 'init') { const pathArg = getFlag('path'); const force = !!getFlag('force'); await initMcpJson(pathArg, force); return }
-  if (cmd === 'start') { await startServer(); return }
-  if (cmd === 'call') { const tool = getFlag('tool'); const action = getFlag('action'); const projectPath = getFlag('projectPath'); const argsStr = getFlag('args'); const args = argsStr ? JSON.parse(argsStr) : undefined; const res = await callOnce({ tool, action, projectPath, args }); console.log(JSON.stringify(res)); return }
-  console.error('Comando inválido')
-  process.exit(1)
-}
-
-main()

package/docs/TOOLS.md

@@ -1,110 +0,0 @@
-# Tools e Actions — @andrebuzeli/git-mcp
-
-Todas as tools operam com chamadas no formato padrão via stdio:
-
-Entrada:
-```
-{ "tool": "<nome>", "action": "<acao>", "projectPath": "<caminho>", "args": { ... } }
-```
-Saída:
-```
-{ "ok": true, "res": <resultado> }
-```
-
-## Parâmetros
-- `projectPath` (string): caminho completo do projeto no IDE
-- `action` (string): ação dentro da tool
-- `args` (objeto, opcional): parâmetros da ação
-- Nome do projeto é derivado do último segmento de `projectPath` com espaços substituídos por underline
-
-## Tools
-
-### git-local
-- Ações: `status`, `init`, `add`, `commit`, `push`, `pull`, `branch`, `tag`, `clone`
-- Observações:
-  - Independente de Git instalado (usa `isomorphic-git`)
-  - `branch`: subactions `list|create|switch` via `args.subaction`
-  - `push`/`pull`: aceita `args.remote` ou `args.url` e faz fallback por Contents API
-- Exemplos:
-```
-call --tool git-local --action init --projectPath "C:\Projetos\X"
-call --tool git-local --action add --projectPath "..." --args '{"patterns":["README.md"]}'
-call --tool git-local --action commit --projectPath "..." --args '{"message":"init"}'
-call --tool git-local --action push --projectPath "..." --args '{"branch":"master"}'
-```
-
-### git-remote
-- Ações: `createRepo`, `deleteRepo`, `ensureRemotes`
-- Cria/garante repositórios/remotes em Gitea e GitHub simultaneamente
-
-### git-sync
-- Ações: `mirror`
-- Sincroniza conteúdo para ambos provedores; tenta push e, se necessário, sobe todos arquivos via Contents API
-
-### git-repos
-- Ações: `get`, `patch`, `languages`, `tags`, `topics-get`, `topics-put`, `collaborators`, `subscribers`, `subscription-get`, `subscription-put`, `subscription-delete`, `stargazers`, `forks-get`, `forks-post`, `activities`, `hooks`, `keys`
-
-### git-contents
-- Ações: `list`, `create`, `get`
-- `create`: `args.path`, `args.content` (base64), `args.message`, opcional `args.branch`
-
-### git-commits
-- Ações: `branches`, `create-branch`, `branch-protections`, `commits`, `refs`
-
-### git-issues-prs
-- Ações: `issue-create`, `issue-comment`, `issue-labels`, `labels-list`, `labels-create`, `milestones-list`, `milestones-create`, `pr-create`, `pr-get`
-- Auto-correções: cria labels/branches quando necessário
-
-### git-releases
-- Ações: `create`
-- `args`: `tag`, `title`, `body`
-
-### git-actions (GitHub)
-- Ações: `workflows`, `runs`, `artifacts`, `runners`, `secrets`
-
-### git-activity
-- Ações: `notifications-get`, `notifications-put`, `events`, `feeds`, `starring-put`, `starring-get`, `starring-delete`, `subscription-put`, `subscription-delete`
-
-### git-search
-- Ações: `repos`, `users`, `issues`, `repos-gitea`
-
-### git-gitdata (GitHub)
-- Ações: `blob-create`, `blob-get`, `tree-create`, `refs-get`
-
-### git-checks (GitHub)
-- Ações: `status`
-- `args`: `sha`, `state`, `context`
-
-### git-deployments (GitHub)
-- Ações: `create`, `status`
-- `create` detecta automaticamente `ref` (`main`/`master`)
-
-### git-misc
-- Ações: `version`, `markdown`, `markdown-raw`, `licenses`, `gitignore-templates`, `label-templates`, `emojis`, `rate_limit`, `zen`
-
-### git-gists (GitHub)
-- Ações: `create`, `get`, `star`, `delete`
-
-### git-packages (Gitea)
-- Ações: `list`
-
-### git-raw (Gitea)
-- Ações: `get`
-
-## Integração IDE
-- Configure `mcp.json` com:
-```
-{
-  "git-mcp": {
-    "command": "npx",
-    "type": "stdio",
-    "args": ["@andrebuzeli/git-mcp@latest"],
-    "env": {
-      "GITEA_URL": "",
-      "GITEA_TOKEN": "",
-      "GITHUB_TOKEN": ""
-    }
-  }
-}
-```
-- IDEs (VSCode, Cursor, Trae) podem invocar via stdio enviando o JSON de chamada descrito acima

package/mcp.json.template

@@ -1,12 +0,0 @@
-{
-  "git-mcp": {
-    "command": "npx",
-    "type": "stdio",
-    "args": ["@andrebuzeli/git-mcp@latest"],
-    "env": {
-      "GITEA_URL": "",
-      "GITEA_TOKEN": "",
-      "GITHUB_TOKEN": ""
-    }
-  }
-}

package/src/local/git.js

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

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

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

@@ -1,130 +0,0 @@
-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')
-}
-
-function writeJsonRpc(id, result, error) {
-  const msg = error ? { jsonrpc: '2.0', id, error } : { jsonrpc: '2.0', id, result }
-  const json = JSON.stringify(msg)
-  const out = `Content-Length: ${Buffer.byteLength(json, 'utf8')}\r\n\r\n${json}`
-  process.stdout.write(out)
-}
-
-async function listSchemas() {
-  const mod = await import('./tools/git-meta.js')
-  const meta = new mod.GitMetaTool(getEnv())
-  return await meta.handle('list', process.cwd(), {})
-}
-
-export async function startServer() {
-  process.stdin.setEncoding('utf-8')
-  let buf = ''
-  process.stdin.resume()
-  process.stdin.on('data', async chunk => {
-    buf += chunk
-    // Try LSP-like framing with Content-Length
-    while (true) {
-      const headerEnd = buf.indexOf('\r\n\r\n')
-      if (headerEnd === -1) break
-      const header = buf.slice(0, headerEnd)
-      const m = header.match(/Content-Length:\s*(\d+)/i)
-      const len = m ? parseInt(m[1], 10) : null
-      const bodyStart = headerEnd + 4
-      if (len == null) {
-        // No content-length, fall back to line-based
-        const line = buf.slice(bodyStart)
-        buf = ''
-        try { const req = JSON.parse(line); await handleRpc(req) } catch { /* ignore */ }
-        break
-      }
-      if (buf.length - bodyStart < len) break
-      const body = buf.slice(bodyStart, bodyStart + len)
-      buf = buf.slice(bodyStart + len)
-      try { const req = JSON.parse(body); await handleRpc(req) } catch (e) { /* ignore parse errors */ }
-    }
-  })
-}
-
-async function handleRpc(req) {
-  if (req && req.jsonrpc === '2.0' && typeof req.method === 'string') {
-    const id = req.id
-    const m = req.method
-    const p = req.params || {}
-    try {
-      if (m === 'initialize') {
-        const result = { serverInfo: { name: '@andrebuzeli/git-mcp', version: '11.0.4' }, capabilities: { tools: true } }
-        writeJsonRpc(id, result)
-      } else if (m === 'tools/list' || m === 'listOfferings') {
-        let schemas = await listSchemas()
-        if (schemas && !Array.isArray(schemas)) { schemas = Object.entries(schemas).map(([name, s]) => ({ name, ...s })) }
-        writeJsonRpc(id, { tools: schemas })
-      } else if (m === 'tools/call' || m === 'callTool' || m === 'call') {
-        const call = {
-          tool: p.name || p.tool,
-          action: p.action,
-          projectPath: p.projectPath || p.path,
-          args: p.args || p.arguments || {}
-        }
-        const res = await dispatch(call)
-        writeJsonRpc(id, { result: res })
-      } else if (m === 'ping') {
-        writeJsonRpc(id, { ok: true })
-      } else {
-        writeJsonRpc(id, undefined, { code: -32601, message: 'Method not found', data: m })
-      }
-    } catch (err) {
-      writeJsonRpc(id, undefined, { code: -32000, message: err?.message || 'Server error' })
-    }
-  } else {
-    writeJsonRpc(req?.id ?? null, undefined, { code: -32600, message: 'Invalid Request' })
-  }
-}
-
-export async function callOnce(req) { return await dispatch(req) }

package/src/tools/git-actions.js

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

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

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

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

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