ai-consensus-connector 0.12.0

package/README.md

@@ -0,0 +1,80 @@
+# AI Consensus — coding-agent connector
+
+Make AI Consensus a **standing part of your development model**. Your coding
+agent — Claude Code, Cursor, Cline, any MCP client — routes every decision of
+consequence through three frontier AIs (Claude, GPT, Gemini) that answer
+**independently**, then **cross-examine each other**, and return one
+recommendation **plus the strongest dissent**. You keep working inside your
+agent; the panel reviews as you go.
+
+This is not a tool you reach for occasionally. It's a review layer you switch
+on once, and from then on everything that matters gets debated by three
+independent models before it ships. (Honest bill: a run takes a few minutes
+and, on the bring-your-own-keys plan, costs roughly $0.40–$1 of your own
+provider tokens.)
+
+## Setup — Claude Code (about 2 minutes)
+
+1. Get an API key: sign in at https://ai-consensus.ai → **Developer API** → create a key (copy it; it's shown once).
+2. Add the connector:
+
+   ```bash
+   claude mcp add ai-consensus --scope user \
+     --env AI_CONSENSUS_API_KEY=aic_live_your_key_here \
+     -- npx -y ai-consensus-connector
+   ```
+
+   (Self-hosting? add `--env AI_CONSENSUS_API_URL=https://your-instance`.)
+
+3. Verify it's connected (free — no run is started):
+
+   > "Use the check_ai_consensus_connection tool."
+
+4. Make it your standing rule — add to your project's `CLAUDE.md`:
+
+   ```
+   STANDING RULE: This project develops with AI Consensus as its review layer.
+   Route every decision of consequence — architecture, design, implementation
+   approach, tricky bugs, anything whose cost of being wrong is real — through
+   consult_ai_consensus as a matter of course, and weigh its recommendation and
+   strongest dissent before acting. Purely mechanical edits (formatting, typos,
+   exact instructed changes) don't need a run. When in doubt, consult.
+   ```
+
+   Teams that want *everything* routed can use the strict variant instead:
+
+   ```
+   STRICT MODE: Consult consult_ai_consensus before every non-trivial change of
+   any kind, and weigh the dissent before acting.
+   ```
+
+## Setup — Cursor / Cline / other MCP clients
+
+Add a stdio MCP server with command `npx -y ai-consensus-connector` and the
+`AI_CONSENSUS_API_KEY` environment variable. For Cursor, in `mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "ai-consensus": {
+      "command": "npx",
+      "args": ["-y", "ai-consensus-connector"],
+      "env": { "AI_CONSENSUS_API_KEY": "aic_live_your_key_here" }
+    }
+  }
+}
+```
+
+Then put the standing rule in your project's agent rules file (`.cursorrules`,
+`.clinerules`, etc.).
+
+## Tools
+- `consult_ai_consensus` — route a decision/task through the panel and wait for the result (a few minutes).
+- `start_ai_consensus` / `get_ai_consensus_result` — fire-and-forget + collect later.
+- `check_ai_consensus_connection` — zero-cost setup check (reachability, key accepted, provider keys present).
+- `cancel_ai_consensus_run` — stop a run.
+
+Your key authenticates to your account and bills your plan (unlimited on your
+own keys, or prepaid credits). Keep it secret — and note that pasting the
+`--env` form above stores the key in your shell history; use your client's
+config file if that concerns you.

package/index.js

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+// AI Consensus — MCP connector. Makes AI Consensus a standing review layer in
+// your development loop: your coding agent (Claude Code, Cursor, Cline — any
+// MCP client) routes decisions of consequence through three frontier AIs that
+// answer independently, cross-examine each other, and return one
+// recommendation plus the strongest dissent. Config via env:
+//   AI_CONSENSUS_API_KEY  (required)  aic_live_...
+//   AI_CONSENSUS_API_URL  (optional)  defaults to the hosted API
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+
+const API_BASE = (process.env.AI_CONSENSUS_API_URL || "https://ai-consensus.ai").replace(/\/$/, "");
+const API_KEY = process.env.AI_CONSENSUS_API_KEY || "";
+
+async function api(path, opts = {}) {
+  const res = await fetch(API_BASE + path, {
+    ...opts,
+    headers: { Authorization: `Bearer ${API_KEY}`, "Content-Type": "application/json", ...(opts.headers || {}) },
+  });
+  let json;
+  try { json = JSON.parse(await res.text()); } catch { json = {}; }
+  return { status: res.status, json };
+}
+
+function render(r) {
+  if (r?.result?.artifact) return r.result.artifact;
+  const v = r?.result?.verdict;
+  if (v) {
+    const out = [v.consensusReached ? "RECOMMENDATION:" : "A JUDGEMENT CALL — WHAT TO WEIGH:", v.consensusReached ? v.consensusDecision : v.escalation];
+    if (v.dissent) out.push("", "STRONGEST DISSENT:", v.dissent);
+    return out.join("\n");
+  }
+  return `Status: ${r?.status}`;
+}
+
+const server = new McpServer({ name: "ai-consensus", version: "0.12.0" });
+
+server.tool(
+  "consult_ai_consensus",
+  "Route a decision, question, or task through three frontier AIs (Claude, GPT, Gemini) that answer independently, then cross-examine each other — returning one recommendation plus the strongest dissent. Intended as a STANDING part of the development loop: consult it as a matter of course for any decision of consequence (architecture, design, approach, tricky bugs, anything whose cost of being wrong is real) — not just rare emergencies. Purely mechanical edits do not need a run. A run takes a few minutes.",
+  { prompt: z.string().describe("The decision, question, or task to run through AI Consensus.") },
+  async ({ prompt }) => {
+    if (!API_KEY) return { content: [{ type: "text", text: "AI_CONSENSUS_API_KEY is not set." }], isError: true };
+    const sub = await api("/api/v1/runs", { method: "POST", body: JSON.stringify({ question: prompt }) });
+    if (sub.status !== 202) return { content: [{ type: "text", text: `Could not start the run: ${JSON.stringify(sub.json)}` }], isError: true };
+    const runId = sub.json.run_id;
+    for (let i = 0; i < 30; i++) {
+      const w = await api(`/api/v1/runs/${runId}/wait`, { method: "POST" });
+      if (w.json?.status === "succeeded" || w.json?.status === "failed") return { content: [{ type: "text", text: render(w.json) }] };
+    }
+    return { content: [{ type: "text", text: `Still running — collect it later with get_ai_consensus_result and run id ${runId}.` }] };
+  },
+);
+
+server.tool("start_ai_consensus", "Start an AI Consensus run without waiting; returns a run id to collect later.",
+  { prompt: z.string() },
+  async ({ prompt }) => {
+    const sub = await api("/api/v1/runs", { method: "POST", body: JSON.stringify({ question: prompt }) });
+    return { content: [{ type: "text", text: sub.status === 202 ? `Started. run_id: ${sub.json.run_id}` : `Error: ${JSON.stringify(sub.json)}` }] };
+  });
+
+server.tool("get_ai_consensus_result", "Fetch the status/result of an AI Consensus run by id.",
+  { run_id: z.string() },
+  async ({ run_id }) => {
+    const r = await api(`/api/v1/runs/${run_id}`);
+    return { content: [{ type: "text", text: r.json?.status === "succeeded" ? render(r.json) : `Status: ${r.json?.status ?? r.status}` }] };
+  });
+
+server.tool("cancel_ai_consensus_run", "Cancel an in-progress AI Consensus run by id.",
+  { run_id: z.string() },
+  async ({ run_id }) => {
+    const r = await api(`/api/v1/runs/${run_id}/cancel`, { method: "POST" });
+    return { content: [{ type: "text", text: JSON.stringify(r.json) }] };
+  });
+
+server.tool(
+  "check_ai_consensus_connection",
+  "Zero-cost setup check: verifies the API is reachable, your AI Consensus key is accepted, and (on bring-your-own-keys plans) which provider keys are present. Does NOT start a deliberation and costs nothing. Use right after installing the connector.",
+  {},
+  async () => {
+    if (!API_KEY) return { content: [{ type: "text", text: "AI_CONSENSUS_API_KEY is not set." }], isError: true };
+    const r = await api("/api/v1/status");
+    if (r.status !== 200 || !r.json?.ok) {
+      return { content: [{ type: "text", text: `Not connected (HTTP ${r.status}): ${JSON.stringify(r.json)}` }], isError: true };
+    }
+    const lines = [`Connected ✓ — key accepted, plan: ${r.json.plan_type ?? "unknown"}.`];
+    if (r.json.provider_keys_present) {
+      const p = r.json.provider_keys_present;
+      lines.push(`Provider keys present: anthropic=${p.anthropic}, openai=${p.openai}, gemini=${p.gemini} (presence only — validated on your first real run).`);
+    }
+    return { content: [{ type: "text", text: lines.join("\n") }] };
+  },
+);
+
+await server.connect(new StdioServerTransport());

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "ai-consensus-connector",
+  "version": "0.12.0",
+  "mcpName": "io.github.thestevenjohnstone/ai-consensus",
+  "description": "Make AI Consensus a standing review layer for your coding agent — Claude, GPT and Gemini answer independently, cross-examine each other, and return one recommendation plus the strongest dissent.",
+  "type": "module",
+  "bin": { "ai-consensus-connector": "index.js" },
+  "files": ["index.js", "README.md"],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "zod": "^3.23.8"
+  },
+  "engines": { "node": ">=18" },
+  "license": "UNLICENSED"
+}