@ikhono/mcp 0.1.0

package/dist/index.js

@@ -0,0 +1,252 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { readFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/client.ts
+var IkhonoClient = class {
+  apiUrl;
+  token;
+  constructor(config) {
+    this.apiUrl = config.apiUrl.replace(/\/$/, "");
+    this.token = config.token;
+  }
+  headers() {
+    const h = { "Content-Type": "application/json" };
+    if (this.token) {
+      h["Authorization"] = `Bearer ${this.token}`;
+    }
+    return h;
+  }
+  async handleResponse(res, action) {
+    if (!res.ok) {
+      let message = res.statusText;
+      try {
+        const body = await res.json();
+        if (body.error) message = typeof body.error === "string" ? body.error : JSON.stringify(body.error);
+      } catch {
+      }
+      throw new Error(`${action}: ${message}`);
+    }
+    const json = await res.json();
+    return json.data;
+  }
+  async searchSkills(query, options) {
+    const params = new URLSearchParams();
+    if (query) params.set("q", query);
+    if (options?.category) params.set("category", options.category);
+    if (options?.author) params.set("author", options.author);
+    if (options?.mine) params.set("mine", "true");
+    if (options?.limit) params.set("limit", String(options.limit));
+    const res = await fetch(`${this.apiUrl}/api/skills?${params}`, { headers: this.headers() });
+    return this.handleResponse(res, "Search failed");
+  }
+  async getSkill(slug) {
+    const res = await fetch(`${this.apiUrl}/api/skills/${slug}?use=true`, { headers: this.headers() });
+    return this.handleResponse(res, "Get skill failed");
+  }
+  async pinSkill(slug) {
+    const res = await fetch(`${this.apiUrl}/api/skills/${slug}/pin`, {
+      method: "POST",
+      headers: this.headers()
+    });
+    return this.handleResponse(res, "Pin failed");
+  }
+  async unpinSkill(slug) {
+    const res = await fetch(`${this.apiUrl}/api/skills/${slug}/pin`, {
+      method: "DELETE",
+      headers: this.headers()
+    });
+    return this.handleResponse(res, "Unpin failed");
+  }
+  async listPinned() {
+    const res = await fetch(`${this.apiUrl}/api/skills/pinned`, { headers: this.headers() });
+    return this.handleResponse(res, "List pins failed");
+  }
+  async rateSkill(slug, stars, review) {
+    const res = await fetch(`${this.apiUrl}/api/skills/${slug}/rate`, {
+      method: "POST",
+      headers: this.headers(),
+      body: JSON.stringify({ stars, review })
+    });
+    return this.handleResponse(res, "Rate failed");
+  }
+};
+
+// src/tools/search.ts
+import { z } from "zod";
+var searchToolName = "ikhono_skill_search";
+var searchToolSchema = z.object({
+  query: z.string().optional().default("").describe('Search query to find relevant skills (e.g., "security review", "write tests", "api docs"). Leave empty when using mine or author filters to list all matching skills.'),
+  category: z.string().optional().describe('Filter by category (e.g., "security", "testing", "documentation")'),
+  author: z.string().optional().describe('Filter by author username (e.g., "@alice" or "alice")'),
+  mine: z.boolean().optional().describe("Set to true to show only your own skills (requires authentication)"),
+  limit: z.number().optional().default(5).describe("Maximum number of results to return")
+});
+var searchToolDescription = `Search iKhono for AI skills that match a query. Use this when the user asks you to do something that could benefit from specialized expertise. Returns a list of matching skills with their names, descriptions, ratings, usage counts, and pin counts.`;
+async function handleSearch(client2, args2) {
+  const results = await client2.searchSkills(args2.query, {
+    category: args2.category,
+    author: args2.author,
+    mine: args2.mine,
+    limit: args2.limit
+  });
+  return results;
+}
+
+// src/tools/get-skill.ts
+import { z as z2 } from "zod";
+var getSkillToolName = "ikhono_skill_get";
+var getSkillToolSchema = z2.object({
+  slug: z2.string().describe('The skill slug (e.g., "@alice/security-reviewer"). Get this from ikhono_skill_search results.')
+});
+var getSkillToolDescription = `Load a skill from iKhono by its slug. Returns the full skill content (instructions, process, templates) that you should follow to complete the user's task. After searching with ikhono_skill_search, use this tool to load the best matching skill.`;
+async function handleGetSkill(client2, args2) {
+  const skill = await client2.getSkill(args2.slug);
+  return skill;
+}
+
+// src/tools/pin.ts
+import { z as z3 } from "zod";
+var pinToolName = "ikhono_skill_pin";
+var pinToolSchema = z3.object({
+  slug: z3.string().describe('The skill slug to pin (e.g., "@alice/security-reviewer")')
+});
+var pinToolDescription = `Pin a skill to the user's favorites so it's always available. Pinned skills are shown in the user's profile.`;
+async function handlePin(client2, args2) {
+  return await client2.pinSkill(args2.slug);
+}
+var unpinToolName = "ikhono_skill_unpin";
+var unpinToolSchema = z3.object({
+  slug: z3.string().describe("The skill slug to unpin")
+});
+var unpinToolDescription = `Remove a skill from the user's pinned favorites.`;
+async function handleUnpin(client2, args2) {
+  return await client2.unpinSkill(args2.slug);
+}
+var listPinnedToolName = "ikhono_skill_list_pinned";
+var listPinnedToolSchema = z3.object({});
+var listPinnedToolDescription = `List all skills the user has pinned. Returns pinned skills with their names, descriptions, and ratings.`;
+async function handleListPinned(client2) {
+  return await client2.listPinned();
+}
+
+// src/tools/rate.ts
+import { z as z4 } from "zod";
+var rateToolName = "ikhono_skill_rate";
+var rateToolSchema = z4.object({
+  slug: z4.string().describe('The skill slug to rate (e.g., "@alice/security-reviewer")'),
+  stars: z4.number().min(1).max(5).describe("Rating from 1 to 5 stars"),
+  review: z4.string().optional().describe("Optional text review")
+});
+var rateToolDescription = `Rate a skill after using it. Helps the community discover the best skills.`;
+async function handleRate(client2, args2) {
+  return await client2.rateSkill(args2.slug, args2.stars, args2.review);
+}
+
+// src/version.ts
+import { createRequire } from "module";
+function getVersion() {
+  if (true) return "0.1.0";
+  const require2 = createRequire(import.meta.url);
+  return require2("../package.json").version;
+}
+var VERSION = getVersion();
+
+// src/index.ts
+function readCliConfig() {
+  try {
+    const raw = readFileSync(join(homedir(), ".ikhono", "config.json"), "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+var cliConfig = readCliConfig();
+var args = process.argv.slice(2);
+var apiUrl = "http://localhost:3456";
+var token;
+for (let i = 0; i < args.length; i++) {
+  if (args[i] === "--api-url" && args[i + 1]) {
+    apiUrl = args[i + 1];
+    i++;
+  } else if (args[i] === "--token" && args[i + 1]) {
+    token = args[i + 1];
+    i++;
+  }
+}
+apiUrl = process.env.IKHONO_API_URL || apiUrl || cliConfig.apiUrl || "http://localhost:3456";
+token = process.env.IKHONO_API_TOKEN || token || cliConfig.token;
+var client = new IkhonoClient({ apiUrl, token });
+var server = new McpServer({
+  name: "iKhono",
+  version: VERSION
+}, {
+  instructions: `You have access to iKhono, a registry of AI skills that enhance your capabilities. When the user asks you to do something that could benefit from specialized expertise (code review, test writing, documentation, refactoring, etc.), use ikhono_skill_search to find relevant skills, then use ikhono_skill_get to load the skill's full instructions. Follow those instructions to give a better, more structured response. Always tell the user which skill you're using and its rating.`
+});
+server.tool(searchToolName, searchToolDescription, searchToolSchema.shape, async (args2) => {
+  try {
+    const results = await handleSearch(client, searchToolSchema.parse(args2));
+    return { content: [{ type: "text", text: JSON.stringify(results, null, 2) }] };
+  } catch (err) {
+    return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+  }
+});
+server.tool(getSkillToolName, getSkillToolDescription, getSkillToolSchema.shape, async (args2) => {
+  try {
+    const parsed = getSkillToolSchema.parse(args2);
+    const skill = await handleGetSkill(client, parsed);
+    const slug = parsed.slug;
+    const prompt = `IMPORTANT: After you finish the task using this skill, you MUST ask the user:
+"Would you like to pin or rate the skill ${slug}? Rate it 1-5 stars."
+If they respond with a rating, call ikhono_skill_rate with slug "${slug}" and their star count.
+If they want to pin it, call ikhono_skill_pin with slug "${slug}".
+This helps skill creators improve their work.`;
+    return {
+      content: [
+        { type: "text", text: JSON.stringify(skill, null, 2) },
+        { type: "text", text: prompt }
+      ]
+    };
+  } catch (err) {
+    return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+  }
+});
+server.tool(pinToolName, pinToolDescription, pinToolSchema.shape, async (args2) => {
+  try {
+    const result = await handlePin(client, pinToolSchema.parse(args2));
+    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+  } catch (err) {
+    return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+  }
+});
+server.tool(unpinToolName, unpinToolDescription, unpinToolSchema.shape, async (args2) => {
+  try {
+    const result = await handleUnpin(client, unpinToolSchema.parse(args2));
+    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+  } catch (err) {
+    return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+  }
+});
+server.tool(listPinnedToolName, listPinnedToolDescription, listPinnedToolSchema.shape, async () => {
+  try {
+    const result = await handleListPinned(client);
+    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+  } catch (err) {
+    return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+  }
+});
+server.tool(rateToolName, rateToolDescription, rateToolSchema.shape, async (args2) => {
+  try {
+    const result = await handleRate(client, rateToolSchema.parse(args2));
+    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+  } catch (err) {
+    return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+  }
+});
+var transport = new StdioServerTransport();
+await server.connect(transport);

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@ikhono/mcp",
+  "version": "0.1.0",
+  "description": "iKhono MCP Server — runtime skill router for AI agents",
+  "type": "module",
+  "bin": {
+    "ikhono-mcp": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsx watch src/index.ts",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "tsup": "^8.0.0",
+    "tsx": "^4.16.0",
+    "typescript": "^5.5.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}