@gemmein/mcp 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Gemmein Limited (Company No. 17339623, England and Wales)
+
+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/README.md

@@ -0,0 +1,49 @@
+# @gemmein/mcp
+
+The [Gemmein](https://gemmein.com) MCP server — gives your coding agent the
+whole Gemmein contract as tools, straight in the editor.
+
+Gemmein is the backend for AI-built web apps: passwordless auth, structured
+storage with plain-English safety rules, and built-in Stripe subscription
+handling. This server is **read-only**: it never creates, edits, or deletes
+anything on the platform.
+
+## Setup
+
+Claude Code:
+
+```sh
+claude mcp add gemmein -- npx -y @gemmein/mcp
+```
+
+Cursor / any MCP client (`mcpServers` config):
+
+```json
+{ "gemmein": { "command": "npx", "args": ["-y", "@gemmein/mcp"] } }
+```
+
+## Tools
+
+- **`guide`** — the full builder's guide (auth flow, the seven collection
+  safety rules, record shapes, links, uploads, contention patterns, payments).
+- **`reference`** — the exact SDK API reference: every method, signature,
+  return shape, error code.
+- **`search_docs`** — targeted search over both documents.
+- **`explain_rule`** — any safety rule's contract, what it's right for, and
+  the mistakes to avoid (or a cheat-sheet of all seven).
+- **`explain_error`** — what a `GemmeinError` code means and exactly what to do.
+- **`validate_collection_name`** — catch a bad collection name at planning
+  time (a bad name throws synchronously and can blank an app silently).
+- **`reaffirm_template`** — the ready-to-edit CI harness that proves an app's
+  boundaries on every deploy.
+- **`check_integration`** — run those boundary checks live against your own
+  app right now: anonymous access refused where it must be, cross-user
+  isolation proven with throwaway dev test sessions, structured pass/fail
+  back. Never pass a live secret key — `sk_live` is refused by design.
+
+## The companion SDK
+
+Your app talks to Gemmein through [`@gemmein/sdk`](https://www.npmjs.com/package/@gemmein/sdk).
+This server teaches your agent to use it correctly.
+
+MIT © Gemmein Limited

package/dist/index.js

@@ -0,0 +1,379 @@
+#!/usr/bin/env node
+// @gemmein/mcp — the Gemmein MCP server (phase 1: read-only).
+//
+// Gives a coding agent the whole Gemmein contract as tools: the guide
+// (llms.txt), the API reference (REFERENCE.md), targeted search over both,
+// deterministic explainers for safety rules and error codes, the reaffirm
+// harness template, and `check_integration` — the reaffirm boundary checks
+// run live against the caller's own app.
+//
+// Phase-1 law: NOTHING here creates, mutates, or deletes platform state.
+// The only writes anywhere are check_integration's Tier-B probe records in
+// the caller's own DEV environment (created and deleted by the check, the
+// same as reaffirm.mjs in CI). Provisioning (create app / mint keys) is
+// phase 2, gated behind launch signup unlock.
+//
+// The guide/reference/template are read from the installed @gemmein/sdk
+// package — one source of truth, no copies to drift.
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { gemmein, gemmeinServer } from "@gemmein/sdk";
+const require = createRequire(import.meta.url);
+function sdkFile(name) {
+    try {
+        return readFileSync(require.resolve(`@gemmein/sdk/${name}`), "utf8");
+    }
+    catch {
+        // sdk 0.1.0 shipped the files in its tarball but without subpath
+        // exports, so Node refuses the pretty specifier. Resolve the entry
+        // point (dist/index.js) and read from the package root instead.
+        return readFileSync(join(dirname(require.resolve("@gemmein/sdk")), "..", name), "utf8");
+    }
+}
+// Same law as the SDK's assertCollectionName — kept in lockstep by test.
+const COLLECTION_NAME_RE = /^[a-z][a-z0-9_]{1,62}$/;
+// ── Safety rules (distilled from llms.txt; the guide stays the source of
+//    truth for prose — these are the decision-shaped versions) ─────────────
+const RULES = {
+    private: {
+        contract: "Each signed-in user sees and edits ONLY their own records. Anonymous access is refused (denied). The app owner (signed in with their dashboard email) can read everyone's records — that is how admin views work, read-only.",
+        rightFor: "notes, tasks, saved games — anything personal to one user.",
+        cautions: "No expand/links here — join in memory. Touching someone else's record returns 404 not_found (existence is never leaked).",
+    },
+    shared: {
+        contract: "Every signed-in user can read AND write every record. Anonymous access is refused.",
+        rightFor: "a team board every user edits together.",
+        cautions: "WRONG for personal data — it leaks to every user. Render other users' content as text (never innerHTML). Use { ifVersion } on updates to avoid silently clobbering concurrent edits.",
+    },
+    admin_write: {
+        contract: "Everyone signed in can read; ONLY the app owner writes. One record that all users read.",
+        rightFor: "announcements, app settings, feature flags your human curates.",
+        cautions: "Non-owner writes get 403 forbidden — never retry a forbidden. If each user should get their OWN copy, that is `addressed`, not admin_write.",
+    },
+    public_read: {
+        contract: "Readable WITHOUT signing in; only the app owner writes. Strangers can never inject records.",
+        rightFor: "catalogs, menus, single-author blogs.",
+        cautions: "Everything in it is public — no secrets, ever. Drafts: create with option { published: false }, publish with update(id, {}, { published: true }). No expand/links.",
+    },
+    community: {
+        contract: "Readable without signing in; any signed-in user creates and edits their OWN records. The public multi-author surface.",
+        rightFor: "multi-author blogs, public boards, user profiles.",
+        cautions: "Everything is PUBLIC — keep record data minimal. Plain text only: HTML in string fields is refused (400 html_not_allowed). Links learn + expand here. One-record-per-user (profiles) = keyed create: create(data, { key: 'profile:' + user.userId }). Drafts supported.",
+    },
+    addressed: {
+        contract: "The app sends to one user: the OWNER creates records naming a recipient — create(data, { for: userId }). Each user's .list() returns only records addressed to them (their inbox). Users never write.",
+        rightFor: "notifications, order status, invoices, results, purchase receipts.",
+        cautions: "Recipient is server-stamped (record.audienceUserId), never a data field. Same message for everyone = admin_write instead. Plain text only. 400 invalid_audience = the recipient isn't a user of this app.",
+    },
+    direct: {
+        contract: "Users send to each other: any signed-in user creates records naming a recipient; only the author and that recipient can read them. The app owner can read directs too (owner reads reach everything).",
+        rightFor: "messages, sharing, requests between users.",
+        cautions: "NEVER present as private or encrypted chat (the owner can read it). Plain text only. 403 reply_only = this collection only allows replying to someone who wrote first; 403 sends_disabled = the owner turned in-app sends off.",
+    },
+};
+const RULES_FOOTER = "Cross-cutting law: collections are created by the app owner in their dashboard, never by the SDK. " +
+    "There is NO team/group/workspace scope and no per-user visibility inside a rule — if the app needs that shape, stop and tell your human it isn't supported yet (never approximate it by client-side filtering a shared collection). " +
+    "Record fields always live under record.data; ownerUserId/version/published are server-derived and top-level.";
+// invalid_collection_name is thrown client-side by the SDK, so it is not in
+// the REFERENCE server-error table — appended here.
+const EXTRA_ERRORS = {
+    invalid_collection_name: {
+        meaning: "the collection name breaks the naming law (lowercase letters, numbers, underscores; must start with a letter; 2-63 chars). Thrown synchronously by g.collection(name), before any network call.",
+        fix: "rename the collection (e.g. saved_games, never savedGames) — validate with the validate_collection_name tool",
+    },
+};
+function parseErrorTable() {
+    const out = {};
+    for (const line of sdkFile("REFERENCE.md").split("\n")) {
+        const m = line.match(/^\|\s*`([a-z_ /`]+?)`?\s*(?:\/\s*`([a-z_]+)`)?\s*\|(.+)\|(.+)\|\s*$/);
+        if (!m)
+            continue;
+        const cells = line.split("|").map((c) => c.trim());
+        // cells[1] = code cell, cells[2] = meaning, cells[3] = do
+        const codes = (cells[1].match(/`([a-z_]+)`/g) ?? []).map((c) => c.slice(1, -1));
+        for (const code of codes) {
+            out[code] = { meaning: cells[2], fix: cells[3].replace(/\*\*/g, "") };
+        }
+    }
+    return { ...out, ...EXTRA_ERRORS };
+}
+// ── search over the two docs ───────────────────────────────────────────────
+function searchDocs(query) {
+    const q = query.toLowerCase().trim();
+    const terms = q.split(/\s+/).filter(Boolean);
+    if (!terms.length)
+        return "Empty query.";
+    const files = [
+        ["llms.txt (the guide)", sdkFile("llms.txt")],
+        ["REFERENCE.md (the API reference)", sdkFile("REFERENCE.md")],
+    ];
+    const blocks = [];
+    for (const [label, text] of files) {
+        const lines = text.split("\n");
+        const hits = [];
+        lines.forEach((line, i) => {
+            const l = line.toLowerCase();
+            if (l.includes(q) || terms.every((t) => l.includes(t)))
+                hits.push(i);
+        });
+        // merge hits into windows of ±3 lines
+        let win = null;
+        const windows = [];
+        for (const h of hits) {
+            const lo = Math.max(0, h - 3);
+            const hi = Math.min(lines.length - 1, h + 3);
+            if (win && lo <= win[1] + 1)
+                win[1] = hi;
+            else
+                windows.push((win = [lo, hi]));
+        }
+        for (const [lo, hi] of windows.slice(0, 6)) {
+            blocks.push(`── ${label}, lines ${lo + 1}-${hi + 1} ──\n` + lines.slice(lo, hi + 1).join("\n"));
+        }
+        if (windows.length > 6)
+            blocks.push(`… ${windows.length - 6} more match block(s) in ${label} — narrow the query.`);
+    }
+    return blocks.length
+        ? blocks.join("\n\n")
+        : `No matches for "${query}". Try a term from the contract vocabulary (rule names, error codes, method names) — or read the full guide/reference tools.`;
+}
+async function runIntegrationChecks(input) {
+    const checks = [];
+    const notes = [];
+    const opts = input.apiUrl ? { apiUrl: input.apiUrl } : {};
+    const push = (label, pass, detail) => checks.push({ label, pass, ...(detail ? { detail } : {}) });
+    const refuse = async (label, code, fn) => {
+        try {
+            await fn();
+            push(label, false, `expected error "${code}" but the call succeeded — the boundary is OPEN`);
+        }
+        catch (e) {
+            const got = e.code ?? e.message;
+            push(label, got === code, got === code ? undefined : `expected "${code}", got "${got}"`);
+        }
+    };
+    const g = gemmein(input.publicKey, opts);
+    // ── Tier A — anonymous + shape. Safe against any environment, live included.
+    try {
+        g.collection(input.privateCollection);
+        push(`collection name "${input.privateCollection}" is valid`, true);
+    }
+    catch (e) {
+        push(`collection name "${input.privateCollection}" is valid`, false, e.message);
+        return { checks, notes }; // nothing downstream can run
+    }
+    await refuse(`anonymous CANNOT read the "${input.privateCollection}" collection`, "denied", () => g.collection(input.privateCollection).list());
+    await refuse(`anonymous CANNOT write the "${input.privateCollection}" collection`, "denied", () => g.collection(input.privateCollection).create({ probe: "x" }));
+    if (input.publicCollection) {
+        try {
+            const open = await g.collection(input.publicCollection).list();
+            push(`"${input.publicCollection}" is anonymously readable (as its rule intends)`, true);
+            notes.push(`"${input.publicCollection}" is public by rule — ${open.records.length} record(s) visible to ANYONE. Never put secrets or personal data in it.`);
+        }
+        catch (e) {
+            push(`"${input.publicCollection}" is anonymously readable (as its rule intends)`, false, `got "${e.code ?? e.message}" — is its rule really community/public_read?`);
+        }
+    }
+    // ── Tier B — cross-user isolation. Dev environments only, by design.
+    const sk = input.secretKey;
+    if (!sk) {
+        notes.push("Tier B (cross-user isolation) skipped — pass secretKey (sk_dev) to prove one user can't read another's private records. Dev and live enforce the same rules, so isolation proven in dev holds in live.");
+        return { checks, notes };
+    }
+    if (sk.startsWith("sk_live")) {
+        notes.push("Tier B skipped — sk_live can never mint test sessions (by design; never point test tooling at live user data). Use the sk_dev key.");
+        return { checks, notes };
+    }
+    const users = input.testUsers?.length === 2 ? input.testUsers : ["reaffirm-a@test.dev", "reaffirm-b@test.dev"];
+    const srv = gemmeinServer(sk, opts);
+    const [a, b] = await Promise.all(users.map((e) => srv.testSession(e)));
+    const asUser = (token) => gemmein(input.publicKey, {
+        ...opts,
+        tokenStore: { get: async () => token, set: async () => { }, clear: async () => { } },
+    });
+    const A = asUser(a.token);
+    const B = asUser(b.token);
+    const note = await A.collection(input.privateCollection).create({ probe: "a-secret" });
+    try {
+        await refuse(`user B CANNOT read user A's private record (404-shaped, existence not leaked)`, "not_found", () => B.collection(input.privateCollection).get(note.id));
+        const bSees = await B.collection(input.privateCollection).list();
+        push("user B's private list contains none of user A's records", !bSees.records.some((r) => r.id === note.id), bSees.records.some((r) => r.id === note.id) ? "ISOLATION BREACH — B's list contains A's record" : undefined);
+        const who = await A.auth.currentUser();
+        push("currentUser() exposes userId (not id) — the shape your UI must read", !!who.userId);
+        push("record fields live under .data", note.data?.probe === "a-secret");
+    }
+    finally {
+        try {
+            await A.collection(input.privateCollection).delete(note.id);
+        }
+        catch { /* leave nothing behind on a best-effort basis */ }
+    }
+    return { checks, notes };
+}
+// ── the MCP server ─────────────────────────────────────────────────────────
+const TOOLS = [
+    {
+        name: "guide",
+        description: "The Gemmein guide (llms.txt): what the platform is, the full contract an AI builder follows — auth flow, the seven collection safety rules, record shapes, links/expand, uploads, contention patterns, payments (g.subscriptions.checkout/g.payments.buy), drafts, error philosophy, pricing. Read this FIRST when building on Gemmein.",
+        inputSchema: { type: "object", properties: {}, additionalProperties: false },
+    },
+    {
+        name: "reference",
+        description: "The Gemmein SDK API reference (REFERENCE.md): every method, exact signature, return shape, and the stable error-code table. Use when you need a precise signature or shape; use `guide` for how the model works.",
+        inputSchema: { type: "object", properties: {}, additionalProperties: false },
+    },
+    {
+        name: "search_docs",
+        description: "Search the Gemmein guide and API reference for a term or phrase (e.g. 'keyed create', 'ifVersion', 'addressed', 'expand'). Returns matching passages with a few lines of context. Cheaper than reading both documents when you need one fact.",
+        inputSchema: {
+            type: "object",
+            properties: { query: { type: "string", description: "term or phrase to find" } },
+            required: ["query"],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "explain_rule",
+        description: "Explain one of Gemmein's seven collection safety rules (private, shared, admin_write, public_read, community, addressed, direct): the exact access contract, what it's right for, and the mistakes to avoid. Call with no rule to get the one-line summary of all seven (rule choice cheat-sheet).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                rule: {
+                    type: "string",
+                    enum: Object.keys(RULES),
+                    description: "the rule to explain; omit for the all-rules cheat-sheet",
+                },
+            },
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "explain_error",
+        description: "Explain a GemmeinError code (e.g. conflict, forbidden, unknown_collection, invalid_shape, html_not_allowed): what it means and exactly what to do. Sourced live from the API reference. Call with no code to list every stable code.",
+        inputSchema: {
+            type: "object",
+            properties: { code: { type: "string", description: "the err.code to explain; omit to list all" } },
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "validate_collection_name",
+        description: "Check a collection name against Gemmein's naming law (lowercase letters, numbers, underscores; starts with a letter). A bad name throws synchronously in the SDK and can blank a whole app with no console error — validate names at planning time.",
+        inputSchema: {
+            type: "object",
+            properties: { name: { type: "string" } },
+            required: ["name"],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "reaffirm_template",
+        description: "The ready-to-edit reaffirm.mjs CI harness that proves an app's boundaries against live Gemmein on every deploy (also shipped inside the @gemmein/sdk npm package). Copy it next to the app, set the CONFIG block, run it in CI. For an immediate one-off check, use check_integration instead.",
+        inputSchema: { type: "object", properties: {}, additionalProperties: false },
+    },
+    {
+        name: "check_integration",
+        description: "Run Gemmein's reaffirm boundary checks against the caller's own app, live, and return structured pass/fail results. Tier A (public key only): anonymous access to a private collection is refused, collection names are valid, a public collection reads as intended — safe against any environment. Tier B (add the sk_dev secret key): proves cross-user isolation with two throwaway test sessions in the DEV environment (sk_live is refused by design). The only writes are Tier B's own probe records in dev, deleted afterwards. NEVER pass an sk_live key to any tool.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                publicKey: { type: "string", description: "the app's public pk_ key" },
+                privateCollection: { type: "string", description: "a collection with the `private` rule" },
+                publicCollection: { type: "string", description: "optional: a community/public_read collection to confirm anonymous readability" },
+                secretKey: { type: "string", description: "optional: the sk_dev secret key — enables Tier B isolation proof (sk_live is refused)" },
+                apiUrl: { type: "string", description: "optional: API base URL override (local/dev API); omit for production Gemmein" },
+                testUsers: { type: "array", items: { type: "string" }, minItems: 2, maxItems: 2, description: "optional: the two Tier-B test emails (default reaffirm-a/b@test.dev)" },
+                timeoutMs: { type: "number", description: "overall time budget, default 30000" },
+            },
+            required: ["publicKey", "privateCollection"],
+            additionalProperties: false,
+        },
+    },
+];
+const server = new Server({ name: "gemmein", version: "0.1.0" }, { capabilities: { tools: {} } });
+server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
+const text = (t) => ({ content: [{ type: "text", text: t }] });
+const errText = (t) => ({ content: [{ type: "text", text: t }], isError: true });
+server.setRequestHandler(CallToolRequestSchema, async (req) => {
+    const { name, arguments: args = {} } = req.params;
+    try {
+        switch (name) {
+            case "guide":
+                return text(sdkFile("llms.txt"));
+            case "reference":
+                return text(sdkFile("REFERENCE.md"));
+            case "search_docs":
+                return text(searchDocs(String(args.query ?? "")));
+            case "explain_rule": {
+                const rule = args.rule;
+                if (!rule) {
+                    const sheet = Object.entries(RULES)
+                        .map(([r, d]) => `- \`${r}\` — ${d.contract.split(".")[0]}. Right for: ${d.rightFor}`)
+                        .join("\n");
+                    return text(`Gemmein's seven collection safety rules (each collection has exactly one):\n\n${sheet}\n\n${RULES_FOOTER}`);
+                }
+                const d = RULES[rule];
+                if (!d)
+                    return errText(`Unknown rule "${rule}". The seven rules: ${Object.keys(RULES).join(", ")}.`);
+                return text(`## \`${rule}\`\n\n**Contract:** ${d.contract}\n\n**Right for:** ${d.rightFor}\n\n**Cautions:** ${d.cautions}\n\n${RULES_FOOTER}`);
+            }
+            case "explain_error": {
+                const table = parseErrorTable();
+                const code = args.code;
+                if (!code) {
+                    return text("Stable GemmeinError codes (branch on err.code, render err.message):\n\n" +
+                        Object.entries(table).map(([c, e]) => `- \`${c}\` — ${e.meaning}`).join("\n"));
+                }
+                const e = table[code];
+                if (!e)
+                    return errText(`"${code}" is not a stable Gemmein error code. Known codes: ${Object.keys(table).join(", ")}.`);
+                return text(`## \`${code}\`\n\n**Meaning:** ${e.meaning}\n\n**What to do:** ${e.fix}`);
+            }
+            case "validate_collection_name": {
+                const n = String(args.name ?? "");
+                if (COLLECTION_NAME_RE.test(n))
+                    return text(`"${n}" is a valid collection name.`);
+                const suggestion = n.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase().replace(/[^a-z0-9_]+/g, "_").replace(/^[^a-z]+/, "").slice(0, 63);
+                return text(`"${n}" is INVALID — collection names are lowercase letters, numbers, and underscores, starting with a letter (2-63 chars). ` +
+                    (suggestion && COLLECTION_NAME_RE.test(suggestion) ? `Suggested: "${suggestion}". ` : "") +
+                    "A bad name throws synchronously from g.collection(name) — at module load it can blank the whole app with no console error.");
+            }
+            case "reaffirm_template":
+                return text(sdkFile("reaffirm.mjs"));
+            case "check_integration": {
+                const input = args;
+                if (typeof input.publicKey !== "string" || !input.publicKey.startsWith("pk_")) {
+                    return errText("publicKey must be the app's public pk_ key (never an sk_ secret).");
+                }
+                const timeoutMs = input.timeoutMs ?? 30000;
+                const run = runIntegrationChecks(input);
+                const timeout = new Promise((_, rej) => setTimeout(() => rej(new Error(`check_integration timed out after ${timeoutMs}ms — is the API reachable?`)), timeoutMs).unref?.());
+                const { checks, notes } = await Promise.race([run, timeout]);
+                const failed = checks.filter((c) => !c.pass);
+                const lines = checks.map((c) => `${c.pass ? "✓" : "✗"} ${c.label}${c.detail ? ` — ${c.detail}` : ""}`);
+                const verdict = failed.length
+                    ? `${failed.length} boundary check(s) FAILED — treat this as drift between the app's assumptions and its rules; fix before shipping.`
+                    : "All boundaries reaffirmed.";
+                return {
+                    content: [{
+                            type: "text",
+                            text: [lines.join("\n"), notes.map((n) => `ℹ ${n}`).join("\n"), verdict].filter(Boolean).join("\n\n"),
+                        }],
+                    structuredContent: { checks, notes, failedCount: failed.length, passed: failed.length === 0 },
+                    ...(failed.length ? { isError: true } : {}),
+                };
+            }
+            default:
+                return errText(`Unknown tool "${name}".`);
+        }
+    }
+    catch (e) {
+        const err = e;
+        return errText(`${name} failed: ${err.code ? `[${err.code}] ` : ""}${err.message ?? String(e)}`);
+    }
+});
+await server.connect(new StdioServerTransport());

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@gemmein/mcp",
+  "version": "0.2.0",
+  "description": "Gemmein MCP server — gives coding agents the Gemmein guide, API reference, rule/error explainers, and a live integration check (reaffirm) as tools. Read-only: it never creates, edits, or deletes anything.",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "gemmein-mcp": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "auth",
+    "backend",
+    "baas",
+    "ai",
+    "vibe-coding",
+    "gemmein"
+  ],
+  "homepage": "https://gemmein.com",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.build.json && chmod +x dist/index.js",
+    "prepack": "npm run build",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@gemmein/sdk": "^0.2.0",
+    "@modelcontextprotocol/sdk": "^1.29.0"
+  },
+  "author": "Gemmein Limited",
+  "bugs": {
+    "email": "hello@gemmein.com"
+  }
+}