@gera-services/mcp-gera-skills 0.1.0 → 1.0.0

package/dist/data.d.ts

@@ -0,0 +1,39 @@
+export interface SkillPack {
+    id: string;
+    name: string;
+    category: string;
+    subcategory?: string;
+    description: string;
+    capabilities: string[];
+    priceMonthly: number;
+    priceOneOff?: number;
+    tags: string[];
+    targetUser: string;
+    region?: string[];
+    badge?: string;
+}
+export declare const SKILLS: SkillPack[];
+export declare const CATEGORIES: string[];
+export declare const CATALOGUE_SOURCE: string;
+/**
+ * Public marketplace URL for a skill. Matches the canonical route generated
+ * by the live product at `/skills/[slug]` (slug === pack id), per
+ * `apps/gera-skills-web/src/app/skills/[slug]/page.tsx` generateStaticParams.
+ */
+export declare function skillUrl(id: string): string;
+export interface SearchFilters {
+    query?: string;
+    category?: string;
+    region?: string;
+    maxPriceMonthly?: number;
+    badge?: string;
+}
+/** Filter the catalogue. All filters are AND-combined; omitted filters match all. */
+export declare function searchSkills(f: SearchFilters): SkillPack[];
+/** Find one skill by exact id, or by case-insensitive name match. */
+export declare function getSkill(idOrName: string): SkillPack | undefined;
+/** Category names with their skill counts, sorted by count desc. */
+export declare function categoryCounts(): {
+    category: string;
+    count: number;
+}[];

package/dist/data.js

@@ -0,0 +1,80 @@
+/**
+ * Offline GeraSkills catalogue.
+ *
+ * The data is a verbatim snapshot of the real GeraSkills web catalogue
+ * (`apps/gera-skills-web/src/data/skill-packs.ts`, 104 skill packs across 12
+ * categories), generated into `data/skill-packs.json` and loaded at startup.
+ * Because it is embedded, every tool answers entirely offline — no backend,
+ * no network, no auth — so any MCP client can browse the same catalogue the
+ * GeraSkills product ships.
+ */
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+const here = dirname(fileURLToPath(import.meta.url));
+// data file sits next to the compiled module: dist/data/skill-packs.json
+const dataPath = join(here, 'data', 'skill-packs.json');
+const dataset = JSON.parse(readFileSync(dataPath, 'utf8'));
+export const SKILLS = dataset.skills;
+export const CATEGORIES = dataset.categories;
+export const CATALOGUE_SOURCE = dataset.source;
+/**
+ * Public marketplace URL for a skill. Matches the canonical route generated
+ * by the live product at `/skills/[slug]` (slug === pack id), per
+ * `apps/gera-skills-web/src/app/skills/[slug]/page.tsx` generateStaticParams.
+ */
+export function skillUrl(id) {
+    return `https://skills.gera.services/skills/${id}`;
+}
+/** Lower-cased haystack of every searchable field on a skill. */
+function haystack(s) {
+    return [
+        s.name,
+        s.category,
+        s.subcategory ?? '',
+        s.description,
+        s.capabilities.join(' '),
+        s.tags.join(' '),
+        s.targetUser,
+        (s.region ?? []).join(' '),
+    ]
+        .join(' ')
+        .toLowerCase();
+}
+/** Filter the catalogue. All filters are AND-combined; omitted filters match all. */
+export function searchSkills(f) {
+    const q = f.query?.trim().toLowerCase();
+    const cat = f.category?.trim().toLowerCase();
+    const region = f.region?.trim().toLowerCase();
+    const badge = f.badge?.trim().toLowerCase();
+    return SKILLS.filter((s) => {
+        if (q && !haystack(s).includes(q))
+            return false;
+        if (cat && s.category.toLowerCase() !== cat)
+            return false;
+        if (region && !(s.region ?? []).some((r) => r.toLowerCase() === region))
+            return false;
+        if (f.maxPriceMonthly !== undefined && s.priceMonthly > f.maxPriceMonthly)
+            return false;
+        if (badge && (s.badge ?? '').toLowerCase() !== badge)
+            return false;
+        return true;
+    });
+}
+/** Find one skill by exact id, or by case-insensitive name match. */
+export function getSkill(idOrName) {
+    const key = idOrName.trim().toLowerCase();
+    return (SKILLS.find((s) => s.id.toLowerCase() === key) ??
+        SKILLS.find((s) => s.name.toLowerCase() === key));
+}
+/** Category names with their skill counts, sorted by count desc. */
+export function categoryCounts() {
+    const counts = new Map();
+    for (const c of CATEGORIES)
+        counts.set(c, 0);
+    for (const s of SKILLS)
+        counts.set(s.category, (counts.get(s.category) ?? 0) + 1);
+    return [...counts.entries()]
+        .map(([category, count]) => ({ category, count }))
+        .sort((a, b) => b.count - a.count);
+}

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @gera-services/mcp-gera-skills
+ *
+ * MCP server for GeraSkills — the marketplace of AI skill packs from Gera
+ * Systems. Re-exports the server, the tool registrar, and the offline
+ * catalogue helpers for programmatic use (e.g. mounting on a Streamable HTTP
+ * transport).
+ *
+ * @packageDocumentation
+ */
+export { server, registerTools, main } from './server.js';
+export { SKILLS, CATEGORIES, searchSkills, getSkill, categoryCounts, skillUrl, type SkillPack, } from './data.js';

package/dist/index.js

@@ -1,28 +1,12 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var index_exports = {};
-__export(index_exports, {
-  server: () => import_server.server
-});
-module.exports = __toCommonJS(index_exports);
-var import_server = require("./server.js");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  server
-});
+/**
+ * @gera-services/mcp-gera-skills
+ *
+ * MCP server for GeraSkills — the marketplace of AI skill packs from Gera
+ * Systems. Re-exports the server, the tool registrar, and the offline
+ * catalogue helpers for programmatic use (e.g. mounting on a Streamable HTTP
+ * transport).
+ *
+ * @packageDocumentation
+ */
+export { server, registerTools, main } from './server.js';
+export { SKILLS, CATEGORIES, searchSkills, getSkill, categoryCounts, skillUrl, } from './data.js';

package/dist/server.d.ts

@@ -0,0 +1,22 @@
+/**
+ * GeraSkills MCP Server (stdio)
+ *
+ * Exposes the GeraSkills marketplace catalogue to AI agents over the Model
+ * Context Protocol. The full catalogue (104 skill packs across 12 categories)
+ * is embedded from the real GeraSkills web data, so every tool answers
+ * entirely offline — no backend, no network, no auth required. An agent
+ * (Claude, ChatGPT with tools, any MCP client) can search skills, read a
+ * skill's full detail, recommend skills for a goal, browse categories, and
+ * find skills relevant to a country/region.
+ *
+ * Product: GeraSkills — https://skills.gera.services (a Gera Systems product)
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/**
+ * Register all GeraSkills tools on a given McpServer instance.
+ * Transport-agnostic: the same handlers serve stdio (local) and Streamable
+ * HTTP / SSE (hosted) clients unchanged.
+ */
+export declare function registerTools(server: McpServer): void;
+export declare const server: McpServer;
+export declare function main(): Promise<void>;

package/dist/server.js

@@ -1,172 +1,228 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var server_exports = {};
-__export(server_exports, {
-  server: () => server
-});
-module.exports = __toCommonJS(server_exports);
-var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
-var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
-var import_zod = require("zod");
-const DEFAULT_API = "https://geraskills.com/backend";
-function apiBase() {
-  return process.env.GERASKILLS_API_URL ?? DEFAULT_API;
-}
-function userToken() {
-  const t = process.env.GERA_USER_TOKEN;
-  return t && t.trim() ? t.trim() : void 0;
+/**
+ * GeraSkills MCP Server (stdio)
+ *
+ * Exposes the GeraSkills marketplace catalogue to AI agents over the Model
+ * Context Protocol. The full catalogue (104 skill packs across 12 categories)
+ * is embedded from the real GeraSkills web data, so every tool answers
+ * entirely offline — no backend, no network, no auth required. An agent
+ * (Claude, ChatGPT with tools, any MCP client) can search skills, read a
+ * skill's full detail, recommend skills for a goal, browse categories, and
+ * find skills relevant to a country/region.
+ *
+ * Product: GeraSkills — https://skills.gera.services (a Gera Systems product)
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import { SKILLS, CATEGORIES, CATALOGUE_SOURCE, searchSkills, getSkill, categoryCounts, skillUrl, } from './data.js';
+function asText(payload) {
+    return {
+        content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }],
+    };
 }
-async function apiGet(path) {
-  const res = await fetch(`${apiBase()}${path}`, {
-    headers: { Accept: "application/json", "User-Agent": "gera-skills-mcp/0.1.0" }
-  });
-  if (!res.ok) {
-    throw new Error(`GeraSkills API ${path} returned ${res.status}`);
-  }
-  return res.json();
+/** Compact card used in search/list results (full detail via get_skill). */
+function card(s) {
+    return {
+        id: s.id,
+        name: s.name,
+        category: s.category,
+        subcategory: s.subcategory ?? null,
+        description: s.description,
+        price_monthly_usd: s.priceMonthly,
+        price_one_off_usd: s.priceOneOff ?? null,
+        badge: s.badge ?? null,
+        tags: s.tags,
+        url: skillUrl(s.id),
+    };
 }
-async function apiPost(path, body, authToken) {
-  const res = await fetch(`${apiBase()}${path}`, {
-    method: "POST",
-    headers: {
-      Accept: "application/json",
-      "Content-Type": "application/json",
-      "User-Agent": "gera-skills-mcp/0.1.0",
-      ...authToken ? { Authorization: `Bearer ${authToken}` } : {}
-    },
-    body: JSON.stringify(body)
-  });
-  if (!res.ok) {
-    const errText = await res.text();
-    throw new Error(`GeraSkills API ${path} returned ${res.status}: ${errText.slice(0, 200)}`);
-  }
-  return res.json();
-}
-const server = new import_mcp.McpServer({
-  name: "gera-skills",
-  version: "0.1.0"
-});
-server.tool(
-  "search_skills",
-  "Search the GeraSkills catalogue for robot capability packs. Returns paginated results with id, slug, name, description, price (GBP pence), rating, download count, creator, and category. Use filters to narrow by category, compatible robot, price band, or minimum rating.",
-  {
-    query: import_zod.z.string().max(200).optional().describe("Full-text query"),
-    category: import_zod.z.string().max(120).optional().describe("Category slug"),
-    compatibleRobot: import_zod.z.string().max(200).optional().describe("Robot model identifier \u2014 e.g. boston-dynamics-spot"),
-    minPriceGbpPence: import_zod.z.number().int().min(0).optional(),
-    maxPriceGbpPence: import_zod.z.number().int().min(0).optional(),
-    minRating: import_zod.z.number().min(0).max(5).optional(),
-    sort: import_zod.z.enum(["new", "top", "price_asc", "price_desc", "rating"]).optional(),
-    page: import_zod.z.number().int().min(1).default(1),
-    pageSize: import_zod.z.number().int().min(1).max(50).default(20)
-  },
-  async (args) => {
-    const qs = new URLSearchParams();
-    for (const [k, v] of Object.entries(args)) {
-      if (v !== void 0 && v !== null && v !== "") {
-        qs.set(k, String(v));
-      }
-    }
-    const result = await apiGet(`/api/v1/skills?${qs.toString()}`);
-    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
-  }
-);
-server.tool(
-  "get_skill",
-  "Fetch full metadata for a single GeraSkill by slug or id. Returns description, long description, version history, compatibility floor, creator info, price, and aggregate rating.",
-  {
-    slug: import_zod.z.string().min(1).max(200).describe("Skill slug (kebab-case) or UUID")
-  },
-  async ({ slug }) => {
-    const result = await apiGet(`/api/v1/skills/${encodeURIComponent(slug)}`);
-    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
-  }
-);
-server.tool(
-  "list_categories",
-  "Return the GeraSkills category tree as a flat list (id, slug, name, parent_id). Agents should use this to narrow search scope before calling search_skills.",
-  {},
-  async () => {
-    const result = await apiGet("/api/v1/categories");
-    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
-  }
-);
-server.tool(
-  "get_creator_revenue",
-  "Return lifetime revenue and install count for the creator of one or more skills. Useful for agents evaluating trustworthiness before recommending a skill. Requires an operator JWT (set GERA_USER_TOKEN) if the creator is not the calling user; otherwise returns a limited public view.",
-  {
-    creatorId: import_zod.z.string().min(1).max(200).describe("Creator ID (UUID)")
-  },
-  async () => {
-    const token = userToken();
-    const endpoint = token ? "/api/v1/creators/me/payouts" : "/api/v1/skills?sort=top&pageSize=1";
-    const result = await apiGet(endpoint);
-    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
-  }
-);
-server.tool(
-  "install_skill",
-  "Initiate purchase + install of a GeraSkill on a specific robot. Creates a Stripe PaymentIntent (70% creator / 30% platform) and returns the client_secret plus amount. REQUIRES an operator consent token \u2014 set GERA_USER_TOKEN. The calling agent MUST surface the displayed price to the user and receive explicit approval before calling this tool.",
-  {
-    skillId: import_zod.z.string().min(1).max(200),
-    robotId: import_zod.z.string().min(1).max(200),
-    version: import_zod.z.string().regex(/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/).max(50).optional().describe("Explicit semver version; defaults to skill.current_version_id")
-  },
-  async ({ skillId, robotId, version }) => {
-    const token = userToken();
-    if (!token) {
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(
-              {
+const categoryEnum = z
+    .string()
+    .describe(`Exact category name. One of: ${CATEGORIES.join(', ')}.`);
+/**
+ * Register all GeraSkills tools on a given McpServer instance.
+ * Transport-agnostic: the same handlers serve stdio (local) and Streamable
+ * HTTP / SSE (hosted) clients unchanged.
+ */
+export function registerTools(server) {
+    // ── Tool 1: search_skills ──────────────────────────────────────────────────
+    server.registerTool('search_skills', {
+        title: 'Search the GeraSkills catalogue',
+        description: 'Full-text search the GeraSkills marketplace of AI skill packs. Match against name, description, capabilities, tags, and target user, with optional filters by category, region, maximum monthly price (USD), and badge. Returns compact cards (id, name, category, description, price, tags, marketplace url). Offline — searches the embedded 104-skill catalogue.',
+        inputSchema: {
+            query: z.string().optional().describe('Free-text query, e.g. "GDPR", "soil", "essay".'),
+            category: categoryEnum.optional(),
+            region: z
+                .string()
+                .optional()
+                .describe('Region/country tag a skill is relevant to, e.g. "UK", "EU", "US", "Global".'),
+            max_price_monthly_usd: z
+                .number()
+                .min(0)
+                .optional()
+                .describe('Only return skills at or below this monthly price in USD.'),
+            badge: z
+                .enum(['New', 'Popular', 'Pro'])
+                .optional()
+                .describe('Filter to a marketplace badge.'),
+            limit: z.number().int().min(1).max(104).default(20).describe('Max results to return.'),
+        },
+    }, async ({ query, category, region, max_price_monthly_usd, badge, limit }) => {
+        const matches = searchSkills({
+            query,
+            category,
+            region,
+            maxPriceMonthly: max_price_monthly_usd,
+            badge,
+        });
+        const cap = limit ?? 20;
+        return asText({
+            query: { query: query ?? null, category: category ?? null, region: region ?? null, max_price_monthly_usd: max_price_monthly_usd ?? null, badge: badge ?? null },
+            total_matches: matches.length,
+            returned: Math.min(matches.length, cap),
+            results: matches.slice(0, cap).map(card),
+        });
+    });
+    // ── Tool 2: get_skill ──────────────────────────────────────────────────────
+    server.registerTool('get_skill', {
+        title: 'Get full detail for one GeraSkill',
+        description: 'Return the complete record for a single skill pack by its id (e.g. "gdpr-compliance-checker") or exact name. Includes every capability, both price options (monthly + one-off USD), tags, target user, applicable regions, badge, and the marketplace URL.',
+        inputSchema: {
+            id: z.string().describe('Skill id (kebab-case) or exact skill name.'),
+        },
+    }, async ({ id }) => {
+        const s = getSkill(id);
+        if (!s) {
+            return asText({
                 ok: false,
-                error: "operator_consent_required",
-                message: "install_skill requires an operator consent token. Set GERA_USER_TOKEN to the operator JWT before invoking."
-              },
-              null,
-              2
-            )
-          }
-        ],
-        isError: true
-      };
-    }
-    const result = await apiPost(
-      "/api/v1/purchases",
-      { skillId, robotId, ...version ? { version } : {} },
-      token
-    );
-    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
-  }
-);
-async function main() {
-  const transport = new import_stdio.StdioServerTransport();
-  await server.connect(transport);
-  console.error("GeraSkills MCP server v0.1.0 running on stdio");
+                error: 'not_found',
+                message: `No skill matches "${id}". Use search_skills or list_categories to find a valid id.`,
+            });
+        }
+        return asText({
+            id: s.id,
+            name: s.name,
+            category: s.category,
+            subcategory: s.subcategory ?? null,
+            description: s.description,
+            capabilities: s.capabilities,
+            price_monthly_usd: s.priceMonthly,
+            price_one_off_usd: s.priceOneOff ?? null,
+            tags: s.tags,
+            target_user: s.targetUser,
+            regions: s.region ?? ['Global'],
+            badge: s.badge ?? null,
+            url: skillUrl(s.id),
+        });
+    });
+    // ── Tool 3: recommend_skills ───────────────────────────────────────────────
+    // A ranked "skill path" for a stated goal — relevance-scored across the catalogue.
+    server.registerTool('recommend_skills', {
+        title: 'Recommend a GeraSkills skill path for a goal',
+        description: 'Given a plain-language goal (e.g. "help me run a small UK accountancy practice" or "I want to grow vegetables and sell at market"), return a ranked, deduplicated list of the most relevant GeraSkills, scored by how many goal terms match each skill. Use this to assemble a "skill path" — the set of capability packs that together address the goal. Offline relevance ranking over the embedded catalogue.',
+        inputSchema: {
+            goal: z.string().min(3).describe('What the user wants to accomplish, in their own words.'),
+            region: z
+                .string()
+                .optional()
+                .describe('Bias toward skills tagged for this region, e.g. "UK".'),
+            limit: z.number().int().min(1).max(20).default(5),
+        },
+    }, async ({ goal, region, limit }) => {
+        const stop = new Set([
+            'the', 'a', 'an', 'to', 'for', 'and', 'or', 'of', 'in', 'on', 'my', 'me', 'i',
+            'want', 'need', 'help', 'with', 'how', 'do', 'can', 'is', 'are', 'be', 'run',
+            'small', 'business', 'get', 'make', 'using', 'use', 'practice', 'practise',
+            'manage', 'managing', 'start', 'starting', 'new', 'good', 'best',
+        ]);
+        const terms = goal
+            .toLowerCase()
+            .split(/[^a-z0-9]+/)
+            .filter((t) => t.length > 2 && !stop.has(t));
+        // Match on a short stem so e.g. "accountancy" hits "accounting"/"accountant",
+        // "gardening" hits "garden", "negotiations" hits "negotiation".
+        const stems = terms.map((t) => (t.length > 5 ? t.slice(0, 5) : t));
+        const scored = SKILLS.map((s) => {
+            const hay = [
+                s.name, s.category, s.subcategory ?? '', s.description,
+                s.capabilities.join(' '), s.tags.join(' '), s.targetUser,
+            ]
+                .join(' ')
+                .toLowerCase();
+            let score = 0;
+            for (const stem of stems)
+                if (hay.includes(stem))
+                    score += 1;
+            // small region boost
+            if (region && (s.region ?? []).some((r) => r.toLowerCase() === region.trim().toLowerCase())) {
+                score += 0.5;
+            }
+            return { s, score };
+        })
+            .filter((x) => x.score > 0)
+            .sort((a, b) => b.score - a.score)
+            .slice(0, limit ?? 5);
+        return asText({
+            goal,
+            matched_terms: terms,
+            match_stems: stems,
+            count: scored.length,
+            skill_path: scored.map((x) => ({ relevance: x.score, ...card(x.s) })),
+            note: scored.length === 0
+                ? 'No catalogue matches. Try list_categories then search_skills with a broader query.'
+                : 'Ranked by goal-term overlap; review each skill with get_skill before recommending.',
+        });
+    });
+    // ── Tool 4: list_categories ────────────────────────────────────────────────
+    server.registerTool('list_categories', {
+        title: 'List GeraSkills categories with counts',
+        description: 'Return all GeraSkills top-level categories with the number of skill packs in each, sorted by count. Use this to scope a subsequent search_skills call by category.',
+        inputSchema: {},
+    }, async () => asText({
+        catalogue_size: SKILLS.length,
+        category_count: CATEGORIES.length,
+        categories: categoryCounts(),
+    }));
+    // ── Tool 5: skills_for_region ──────────────────────────────────────────────
+    server.registerTool('skills_for_region', {
+        title: 'List GeraSkills relevant to a region/country',
+        description: 'Return the skills explicitly tagged as relevant to a given region or country (e.g. "UK", "EU", "US", "Global"). Useful for agents serving users in a specific jurisdiction where some skills are jurisdiction-specific (employment law, tax, energy tariffs, certification standards).',
+        inputSchema: {
+            region: z.string().describe('Region/country tag, e.g. "UK", "EU", "US", "Global".'),
+            limit: z.number().int().min(1).max(104).default(50),
+        },
+    }, async ({ region, limit }) => {
+        const matches = searchSkills({ region });
+        const cap = limit ?? 50;
+        return asText({
+            region,
+            total_matches: matches.length,
+            returned: Math.min(matches.length, cap),
+            results: matches.slice(0, cap).map(card),
+        });
+    });
 }
-main().catch((err) => {
-  console.error(err);
-  process.exit(1);
-});
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  server
+// ── Server instance ──────────────────────────────────────────────────────────
+export const server = new McpServer({
+    name: 'gera-skills',
+    version: '1.0.0',
 });
+registerTools(server);
+// ── Start ────────────────────────────────────────────────────────────────────
+export async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    // stderr only — stdout is the MCP transport.
+    console.error(`GeraSkills MCP server running on stdio (gera-skills v1.0.0, ${SKILLS.length} skills, source ${CATALOGUE_SOURCE})`);
+}
+// Run when invoked directly as the built server (node dist/server.js).
+// bin/cli.js imports and calls main() itself, so only auto-run for direct
+// server.js invocation to avoid a double start.
+const isMain = typeof process !== 'undefined' &&
+    process.argv[1] &&
+    /server\.js$/.test(process.argv[1]);
+if (isMain) {
+    main().catch((err) => {
+        console.error('Fatal:', err);
+        process.exit(1);
+    });
+}