@ratifia/mcp 0.9.0 → 0.10.1

package/README.md

@@ -59,6 +59,7 @@ real decisions. CI runs it on every push.
 | `RATIFIA_APP_URL` | | `https://app.ratifia.com` | Dashboard base for decision links. |
 | `RATIFIA_APPROVER_EMAIL` | | — | Who the decision is assigned to / notified. |
 | `RATIFIA_POLICY` | | — | The **key** of a policy deciding **who** reviews and the quorum they need. It must exist in your org: an unknown key is a tool error, and the `gate` hook denies. |
+| `RATIFIA_GATE_INCLUDE_PROMPT` | | off | `gate` hook only: `1` includes the user's last request (from the transcript) in the decision. Off by default — the gate otherwise sends only metadata, never your conversation. |
 | `RATIFIA_WORKFLOW` | | `ratifia-mcp` (`ratifia-gate` for the hook) | The **workflow** decisions are filed under — the category the dashboard's Workflow filter groups by, e.g. `deploys` or `billing-agent`. A `request_decision` call can override it. |
 
 Who is notified is decided **inside Ratifia** by your org's policy — this server is a thin request/verdict bridge.

package/dist/index.js

@@ -27,6 +27,8 @@
  *   RATIFIA_APPROVER_EMAIL  who the decision is assigned to / notified
  *   RATIFIA_POLICY          optional: policy key deciding who reviews (must exist in the org)
  *                           (e.g. a route to your phone)
+ *   RATIFIA_GATE_INCLUDE_PROMPT  gate hook only: 1 = include the user's last request from the
+ *                           transcript in the decision (off by default — it is case content)
  *   RATIFIA_WORKFLOW        optional: the workflow (category) decisions are filed under —
  *                           what the dashboard's Workflow filter groups by. Defaults to
  *                           `ratifia-mcp` (tools) / `ratifia-gate` (the gate hook).
@@ -34,6 +36,8 @@
 import { McpServer } from '@modelcontextprotocol/server';
 import { StdioServerTransport } from '@modelcontextprotocol/server/stdio';
 import { randomUUID } from 'node:crypto';
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import { basename, dirname, join, resolve } from 'node:path';
 import { z } from 'zod';
 const API_URL = (process.env.RATIFIA_API_URL ?? 'https://api.ratifia.com').replace(/\/+$/, '');
 const API_KEY = process.env.RATIFIA_API_KEY;
@@ -261,6 +265,87 @@ function gateDecision(decision, reason) {
         },
     }));
 }
+/**
+ * Where the agent is working, read straight from `.git` rather than shelling out
+ * to git — a hook runs on every gated tool call and must stay cheap.
+ */
+function repoContext(cwd) {
+    let dir;
+    try {
+        dir = resolve(cwd);
+    }
+    catch {
+        return {};
+    }
+    for (let i = 0; i < 6; i++) {
+        try {
+            const dotGit = join(dir, '.git');
+            if (existsSync(dotGit)) {
+                // A worktree's `.git` is a FILE ("gitdir: <path>"); a normal repo's is a
+                // directory. Read HEAD from whichever this is.
+                const gitDir = statSync(dotGit).isDirectory()
+                    ? dotGit
+                    : resolve(dir, readFileSync(dotGit, 'utf8').replace(/^gitdir:/, '').trim());
+                const head = readFileSync(join(gitDir, 'HEAD'), 'utf8').trim();
+                // Keep the whole branch name: "feat/x" is not "x".
+                const branch = head.startsWith('ref: refs/heads/')
+                    ? head.slice('ref: refs/heads/'.length)
+                    : head.startsWith('ref: ')
+                        ? head.slice(head.lastIndexOf('/') + 1)
+                        : head.slice(0, 7);
+                return { repo: basename(dir), branch };
+            }
+        }
+        catch {
+            // `.git` is a directory (readFileSync throws EISDIR) or unreadable — the
+            // repo name is still the useful half.
+            return { repo: basename(dir) };
+        }
+        const up = dirname(dir);
+        if (up === dir)
+            break;
+        dir = up;
+    }
+    return { repo: basename(resolve(cwd)) };
+}
+/**
+ * The user's most recent request, from the transcript the harness points at.
+ * OFF unless RATIFIA_GATE_INCLUDE_PROMPT=1: it is case content, and the gate is
+ * otherwise metadata only. The file is JSONL and written asynchronously, so the
+ * newest lines may lag; a miss just means no block.
+ */
+function lastUserRequest(transcriptPath) {
+    if (process.env.RATIFIA_GATE_INCLUDE_PROMPT !== '1')
+        return null;
+    if (typeof transcriptPath !== 'string' || !transcriptPath)
+        return null;
+    try {
+        const lines = readFileSync(transcriptPath, 'utf8').split('\n').filter(Boolean);
+        for (let i = lines.length - 1; i >= 0; i--) {
+            const row = JSON.parse(lines[i]);
+            if (row.type !== 'user' && row.message?.role !== 'user')
+                continue;
+            const content = row.message?.content;
+            const text = typeof content === 'string'
+                ? content
+                : Array.isArray(content)
+                    ? content
+                        .filter((c) => typeof c === 'object' && c !== null && c.type === 'text')
+                        .map((c) => c.text)
+                        .join('\n')
+                    : '';
+            const trimmed = text.trim();
+            // Skip the harness's own injected turns — they are not what the user asked.
+            if (!trimmed || trimmed.startsWith('<'))
+                continue;
+            return trimmed.length > 1500 ? `${trimmed.slice(0, 1500)}…` : trimmed;
+        }
+    }
+    catch {
+        /* unreadable transcript — the gate still works without it */
+    }
+    return null;
+}
 /**
  * `ratifia-mcp gate` — a Claude Code **PreToolUse hook**. Opens a Ratifia
  * decision for the tool call (rendered as a `tool_call` context panel), blocks
@@ -280,6 +365,23 @@ async function runGate() {
     }
     const toolName = String(payload.tool_name ?? 'unknown_tool');
     const toolInput = payload.tool_input ?? {};
+    // FN: the reviewer sees WHAT would run (the tool call) — give them WHERE and
+    // WHO too. All of it comes from the harness payload; none of it is guessed.
+    const cwd = typeof payload.cwd === 'string' ? payload.cwd : '';
+    const { repo, branch } = cwd ? repoContext(cwd) : {};
+    const where = [repo, branch && `(${branch})`].filter(Boolean).join(' ');
+    const askedFor = lastUserRequest(payload.transcript_path);
+    const fields = [
+        repo ? { label: 'Repo', value: branch ? `${repo} (${branch})` : repo } : null,
+        cwd ? { label: 'Directory', value: cwd } : null,
+        typeof payload.agent_type === 'string' && payload.agent_type ? { label: 'Agent', value: payload.agent_type } : null,
+        typeof payload.permission_mode === 'string' && payload.permission_mode
+            ? { label: 'Permission mode', value: payload.permission_mode }
+            : null,
+        typeof payload.session_id === 'string' && payload.session_id
+            ? { label: 'Session', value: payload.session_id.slice(0, 12) }
+            : null,
+    ].filter((f) => f !== null);
     // Optional allow-list: if set, only gate these tools; pass the rest through.
     const gated = (process.env.RATIFIA_GATED_TOOLS ?? '')
         .split(',')
@@ -308,8 +410,12 @@ async function runGate() {
                 ...(POLICY ? { policy: POLICY } : {}),
                 required: true,
                 context: {
-                    prompt: `An agent wants to run the tool "${toolName}". Approve?`,
-                    blocks: [{ kind: 'tool_call', title: 'Tool call', tool: toolName, args: toolInput }],
+                    prompt: `An agent wants to run the tool "${toolName}"${where ? ` in ${where}` : ''}. Approve?`,
+                    blocks: [
+                        { kind: 'tool_call', title: 'Tool call', tool: toolName, args: toolInput },
+                        ...(fields.length ? [{ kind: 'fields', title: 'Where', fields }] : []),
+                        ...(askedFor ? [{ kind: 'text', title: 'What the user asked for', text: askedFor }] : []),
+                    ],
                 },
             }),
         }));
@@ -349,7 +455,10 @@ if (process.argv[2] === 'gate') {
     await runGate();
     process.exit(0);
 }
-const server = new McpServer({ name: 'ratifia', version: '0.7.0' }, {
+/** The published version, read from package.json so the handshake can't drift
+ *  from npm again (it reported 0.6.0/0.7.0 through several releases). */
+const VERSION = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version;
+const server = new McpServer({ name: 'ratifia', version: VERSION }, {
     instructions: [
         'Ratifia lets you request a HUMAN decision or input mid-task (human-in-the-loop) and resume once it is answered.',
         '',

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@ratifia/mcp",
-  "version": "0.9.0",
+  "version": "0.10.1",
   "type": "module",
-  "description": "Ratifia MCP server \u2014 let an AI agent request a human decision/approval (HITL) mid-task and resume once it's answered. The agent becomes a Ratifia 'engine'.",
+  "description": "Ratifia MCP server — let an AI agent request a human decision/approval (HITL) mid-task and resume once it's answered. The agent becomes a Ratifia 'engine'.",
   "keywords": [
     "mcp",
     "model-context-protocol",