@remogram/mcp 0.1.0-beta.0

package/bin/remogram-mcp.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { startServer } from '../server.mjs';
+
+startServer().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@remogram/mcp",
+  "version": "0.1.0-beta.0",
+  "description": "Remogram MCP server delegating to CLI",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/attebury/remogram.git",
+    "directory": "packages/remogram-mcp"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "bin/",
+    "register-tools.mjs",
+    "run-cli.mjs",
+    "server.mjs"
+  ],
+  "bin": {
+    "remogram-mcp": "bin/remogram-mcp.js"
+  },
+  "exports": {
+    ".": "./server.mjs",
+    "./run-cli": "./run-cli.mjs"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.17.0",
+    "@remogram/cli": "0.1.0-beta.0",
+    "zod": "^3.25.76"
+  }
+}

package/register-tools.mjs

@@ -0,0 +1,93 @@
+import { z } from 'zod';
+import { runRemogramCli, packetToMcpContent } from './run-cli.mjs';
+
+export function registerTools(server) {
+  const tools = [
+    {
+      name: 'doctor',
+      description: 'Read-only provider readiness diagnostics for config, remote trust, auth, capabilities, and checks.',
+      inputSchema: z.object({}),
+      args: ['doctor'],
+    },
+    {
+      name: 'provider_capabilities',
+      description: 'Structured provider capability facts for commands, auth, checks, host binding, pagination, and write support.',
+      inputSchema: z.object({}),
+      args: ['provider', 'capabilities'],
+    },
+    {
+      name: 'repo_status',
+      description: 'Forge repo status facts (auth, capabilities, default branch).',
+      inputSchema: z.object({}),
+      args: ['repo', 'status'],
+    },
+    {
+      name: 'ref_compare',
+      description: 'Compare two refs with exact SHAs and ahead/behind counts.',
+      inputSchema: z.object({
+        base: z.string().describe('Base ref'),
+        head: z.string().describe('Head ref'),
+      }),
+      args: (input) => ['refs', 'compare', '--base', input.base, '--head', input.head],
+    },
+    {
+      name: 'pr_status',
+      description: 'PR metadata and mergeability facts.',
+      inputSchema: z.object({
+        number: z.number().int().positive(),
+      }),
+      args: (input) => ['pr', 'view', '--number', String(input.number)],
+    },
+    {
+      name: 'pr_checks',
+      description: 'CI/check conclusions for a PR number or git ref.',
+      inputSchema: z.object({
+        number: z.number().int().positive().optional(),
+        ref: z.string().optional(),
+      }),
+      args: (input) => {
+        const a = ['pr', 'checks'];
+        if (input.number != null) a.push('--number', String(input.number));
+        if (input.ref) a.push('--ref', input.ref);
+        return a;
+      },
+    },
+    {
+      name: 'merge_plan',
+      description: 'Merge readiness facts: mergeability, checks, blockers.',
+      inputSchema: z.object({
+        number: z.number().int().positive(),
+      }),
+      args: (input) => ['merge', 'plan', '--number', String(input.number)],
+    },
+    {
+      name: 'sync_plan',
+      description: 'Local vs remote sync facts and divergent-remote blockers.',
+      inputSchema: z.object({
+        remote: z.string().optional(),
+      }),
+      args: (input) => {
+        const a = ['sync', 'plan'];
+        if (input.remote) a.push('--remote', input.remote);
+        return a;
+      },
+    },
+  ];
+
+  for (const tool of tools) {
+    server.registerTool(
+      tool.name,
+      {
+        description: tool.description,
+        inputSchema: tool.inputSchema,
+        annotations: { readOnlyHint: true, destructiveHint: false },
+      },
+      async (input) => {
+        const args = typeof tool.args === 'function' ? tool.args(input) : tool.args;
+        const result = await runRemogramCli(args);
+        const truncated = result.stdoutTruncated || result.stderrTruncated;
+        return packetToMcpContent(result.stdout, result.stderr, result.code, truncated);
+      },
+    );
+  }
+}

package/run-cli.mjs

@@ -0,0 +1,111 @@
+import { spawn } from 'node:child_process';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import {
+  forgeErrorPacket,
+  unknownForgeContext,
+  ERROR_CODES,
+  forgeError,
+  capText,
+  sanitizeField,
+} from '@remogram/core';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const require = createRequire(import.meta.url);
+const MAX_OUTPUT_BYTES = 65_536;
+
+function safeCliErrorMessage(stderr, stdout) {
+  const raw = stderr || stdout || '';
+  const capped = capText(raw, MAX_OUTPUT_BYTES);
+  const sanitized = sanitizeField(capped.text);
+  if (!sanitized) return 'CLI did not return JSON';
+  if (/Bearer\s|ghp_|gho_|glpat-|GITLAB_TOKEN|GITEA_TOKEN/i.test(sanitized)) {
+    return 'CLI did not return JSON';
+  }
+  return sanitized;
+}
+
+export function remogramCwd() {
+  return process.env.REMOGRAM_CWD || process.cwd();
+}
+
+export function resolveCliBin() {
+  try {
+    return require.resolve('@remogram/cli/bin/remogram.js');
+  } catch {
+    return join(__dirname, '../remogram-cli/bin/remogram.js');
+  }
+}
+
+function appendCapped(current, chunk, maxBytes) {
+  const next = current + chunk;
+  const capped = capText(next, maxBytes);
+  return { text: capped.text, truncated: capped.truncated };
+}
+
+export function runRemogramCli(args) {
+  const cliBin = resolveCliBin();
+  return new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, [cliBin, ...args, '--json'], {
+      cwd: remogramCwd(),
+      env: { ...process.env, REMOGRAM_CWD: remogramCwd() },
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    let stdout = '';
+    let stderr = '';
+    let stdoutTruncated = false;
+    let stderrTruncated = false;
+    child.stdout.on('data', (d) => {
+      const chunk = d.toString();
+      const capped = appendCapped(stdout, chunk, MAX_OUTPUT_BYTES);
+      stdout = capped.text;
+      stdoutTruncated = stdoutTruncated || capped.truncated;
+    });
+    child.stderr.on('data', (d) => {
+      const chunk = d.toString();
+      const capped = appendCapped(stderr, chunk, MAX_OUTPUT_BYTES);
+      stderr = capped.text;
+      stderrTruncated = stderrTruncated || capped.truncated;
+    });
+    child.on('error', reject);
+    child.on('close', (code) => {
+      resolve({
+        code,
+        stdout: stdout.trim(),
+        stderr: stderr.trim(),
+        stdoutTruncated,
+        stderrTruncated,
+      });
+    });
+  });
+}
+
+export function packetToMcpContent(stdout, stderr, code, truncated = false) {
+  let packet;
+  let isError = code !== 0 || truncated;
+  try {
+    packet = JSON.parse(stdout);
+    if (packet && packet.ok === false) isError = true;
+  } catch {
+    isError = true;
+    packet = forgeErrorPacket(
+      unknownForgeContext(),
+      forgeError(
+        ERROR_CODES.UNPARSEABLE_PROVIDER_OUTPUT,
+        safeCliErrorMessage(stderr, stdout),
+      ),
+    );
+  }
+  if (truncated) {
+    isError = true;
+    packet = forgeErrorPacket(
+      unknownForgeContext(),
+      forgeError(ERROR_CODES.OVERSIZED_RAW_OUTPUT, 'CLI output exceeded MCP byte cap'),
+    );
+  }
+  return {
+    isError,
+    content: [{ type: 'text', text: JSON.stringify(packet, null, 2) }],
+  };
+}

package/server.mjs

@@ -0,0 +1,10 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { registerTools } from './register-tools.mjs';
+
+export async function startServer() {
+  const server = new McpServer({ name: 'remogram', version: '0.1.0' });
+  registerTools(server);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}