@slexkit/mcp 0.2.0

package/dist/index.js

@@ -0,0 +1,621 @@
+#!/usr/bin/env node
+// @bun
+
+// src/index.ts
+import { createInterface } from "readline";
+import { readFile } from "fs/promises";
+
+// ../../dist/runtime.js
+var ITERATE_KEY = Symbol("iterate");
+var REVISION_KEY = Symbol("revision");
+var pendingEffects = new Set;
+var targetDeps = new WeakMap;
+var proxyCache = new WeakMap;
+var rawTargets = new WeakMap;
+var rootTargets = new WeakMap;
+
+class ReactiveScope {
+  cleanups = [];
+  effects = new Set;
+  disposed = false;
+  dispose() {
+    if (this.disposed)
+      return;
+    this.disposed = true;
+    for (const effect of Array.from(this.effects))
+      effect.stop();
+    this.effects.clear();
+    for (let i = this.cleanups.length - 1;i >= 0; i -= 1) {
+      this.cleanups[i]();
+    }
+    this.cleanups.length = 0;
+  }
+}
+var _stores = new Map;
+var _registry = new Map;
+var lastValues = new Map;
+var SKIP_EAGER_TRACK = Symbol.for("slexkit.skipEagerTrack");
+var EAGER_TRACK_TARGET = Symbol.for("slexkit.eagerTrackTarget");
+var componentDisposers = new WeakMap;
+var componentStateProxies = new WeakMap;
+class SlexKitSyntaxError extends SyntaxError {
+  diagnostic;
+  constructor(diagnostic) {
+    super(formatSlexKitDiagnostic(diagnostic));
+    this.name = "SlexKitSyntaxError";
+    this.diagnostic = diagnostic;
+  }
+}
+function excerpt(source, line, column) {
+  const lines = source.split(`
+`);
+  const start = Math.max(1, line - 2);
+  const end = Math.min(lines.length, line + 2);
+  const width = String(end).length;
+  const rows = [];
+  for (let current = start;current <= end; current += 1) {
+    const marker = current === line ? ">" : " ";
+    rows.push(`${marker} ${String(current).padStart(width, " ")} | ${lines[current - 1] ?? ""}`);
+    if (current === line) {
+      rows.push(`  ${" ".repeat(width)} | ${" ".repeat(Math.max(0, column - 1))}^`);
+    }
+  }
+  return rows.join(`
+`);
+}
+function lineColumnAt(source, index) {
+  const prefix = source.slice(0, Math.max(0, index));
+  const lines = prefix.split(`
+`);
+  return {
+    line: lines.length,
+    column: lines[lines.length - 1].length + 1
+  };
+}
+function stackLine(error) {
+  if (!(error instanceof Error) || !error.stack)
+    return null;
+  const match = error.stack.match(/<parse>\s+\(:(\d+)\)/);
+  if (!match)
+    return null;
+  const parsed = Number(match[1]);
+  return Number.isFinite(parsed) ? Math.max(1, parsed - 2) : null;
+}
+function scanSource(source) {
+  const chars = [];
+  let quote = "";
+  let escaped = false;
+  let line = 1;
+  let column = 0;
+  for (let index = 0;index < source.length; index += 1) {
+    const char = source[index];
+    const next = source[index + 1];
+    column += 1;
+    if (char === `
+`) {
+      line += 1;
+      column = 0;
+      if (quote === "//")
+        quote = "";
+      continue;
+    }
+    if (quote) {
+      if (quote === "/*" && char === "*" && next === "/") {
+        quote = "";
+        index += 1;
+        column += 1;
+      } else if (quote !== "/*" && quote !== "//" && !escaped && char === quote) {
+        quote = "";
+      }
+      escaped = !escaped && quote !== "/*" && quote !== "//" && char === "\\";
+      if (char !== "\\")
+        escaped = false;
+      continue;
+    }
+    if (char === "/" && next === "/") {
+      quote = "//";
+      index += 1;
+      column += 1;
+      continue;
+    }
+    if (char === "/" && next === "*") {
+      quote = "/*";
+      index += 1;
+      column += 1;
+      continue;
+    }
+    if (char === '"' || char === "'" || char === "`") {
+      quote = char;
+      escaped = false;
+      continue;
+    }
+    chars.push({ char, index, line, column });
+  }
+  return chars;
+}
+function tokenDiagnostic(source, message) {
+  const chars = scanSource(source);
+  const unexpectedString = message.match(/Unexpected string(?: literal)?(?: "([^"]+)")?/);
+  if (unexpectedString) {
+    const literal = unexpectedString[1];
+    if (literal) {
+      const quoted = [`"${literal}"`, `'${literal}'`, `\`${literal}\``];
+      const index = quoted.map((candidate) => source.indexOf(candidate)).filter((candidate) => candidate >= 0).sort((a, b) => a - b)[0];
+      if (index !== undefined)
+        return lineColumnAt(source, index);
+    }
+    const suspiciousString = source.match(/[}\])"']\s*(['"`])/);
+    if (suspiciousString?.index !== undefined) {
+      const quoteIndex = source.indexOf(suspiciousString[1], suspiciousString.index + 1);
+      if (quoteIndex >= 0)
+        return lineColumnAt(source, quoteIndex);
+    }
+  }
+  if (message.includes("Unexpected token ':'")) {
+    const doubleColon = chars.find((item, index) => item.char === ":" && chars[index - 1]?.char === ":");
+    if (doubleColon)
+      return doubleColon;
+    const suspiciousColon = chars.find((item, index) => {
+      if (item.char !== ":")
+        return false;
+      const prev = chars[index - 1]?.char;
+      return prev === '"' || prev === "'" || prev === "}" || prev === "]" || prev === ")";
+    });
+    if (suspiciousColon)
+      return suspiciousColon;
+  }
+  return null;
+}
+function delimiterDiagnostic(source) {
+  const stack = [];
+  const pairs = { "}": "{", "]": "[", ")": "(" };
+  for (const item of scanSource(source)) {
+    if (item.char === "{" || item.char === "[" || item.char === "(") {
+      stack.push(item);
+      continue;
+    }
+    if (item.char === "}" || item.char === "]" || item.char === ")") {
+      const expected = pairs[item.char];
+      const opener2 = stack.pop();
+      if (!opener2 || opener2.char !== expected) {
+        return {
+          line: item.line,
+          column: item.column,
+          detail: `Unexpected closing delimiter ${item.char}.`
+        };
+      }
+    }
+  }
+  const opener = stack.at(-1);
+  if (!opener)
+    return null;
+  const end = lineColumnAt(source, source.length);
+  return {
+    line: end.line,
+    column: end.column,
+    detail: `Expected closing delimiter for ${opener.char} opened at line ${opener.line}, column ${opener.column}.`
+  };
+}
+function locateSyntaxError(source, error) {
+  const rawMessage = error instanceof Error ? error.message : String(error);
+  const delimiter = delimiterDiagnostic(source);
+  const token = tokenDiagnostic(source, rawMessage);
+  const stack = stackLine(error);
+  const position = token ?? (delimiter && rawMessage.includes("Expected") ? delimiter : null) ?? (stack ? { line: stack, column: 1 } : null) ?? delimiter ?? { line: 1, column: 1 };
+  const detail = token ? "The parser failed at this token." : delimiter?.detail;
+  return {
+    message: rawMessage,
+    line: position.line,
+    column: position.column,
+    detail,
+    excerpt: excerpt(source, position.line, position.column)
+  };
+}
+function readStringLiteral(source, start) {
+  const quote = source[start];
+  if (quote !== '"' && quote !== "'" && quote !== "`")
+    return null;
+  let escaped = false;
+  for (let index = start + 1;index < source.length; index += 1) {
+    const char = source[index];
+    if (!escaped && char === quote) {
+      return { end: index + 1, value: source.slice(start, index + 1) };
+    }
+    escaped = !escaped && char === "\\";
+    if (char !== "\\")
+      escaped = false;
+  }
+  return null;
+}
+function skipWhitespace(source, index) {
+  let cursor = index;
+  while (cursor < source.length && /\s/.test(source[cursor]))
+    cursor += 1;
+  return cursor;
+}
+function findExpressionEnd(source, start) {
+  const stack = [];
+  let quote = "";
+  let escaped = false;
+  for (let index = start;index < source.length; index += 1) {
+    const char = source[index];
+    const next = source[index + 1];
+    if (quote) {
+      if (quote === "//" && char === `
+`) {
+        quote = "";
+      } else if (quote === "/*" && char === "*" && next === "/") {
+        quote = "";
+        index += 1;
+      } else if (quote !== "//" && quote !== "/*" && !escaped && char === quote) {
+        quote = "";
+      }
+      escaped = !escaped && quote !== "//" && quote !== "/*" && char === "\\";
+      if (char !== "\\")
+        escaped = false;
+      continue;
+    }
+    if (char === "/" && next === "/") {
+      quote = "//";
+      index += 1;
+      continue;
+    }
+    if (char === "/" && next === "*") {
+      quote = "/*";
+      index += 1;
+      continue;
+    }
+    if (char === '"' || char === "'" || char === "`") {
+      quote = char;
+      escaped = false;
+      continue;
+    }
+    if (char === "{" || char === "[" || char === "(") {
+      stack.push(char);
+      continue;
+    }
+    if (char === "}" || char === "]" || char === ")") {
+      if (stack.length === 0)
+        return index;
+      stack.pop();
+      continue;
+    }
+    if (char === "," && stack.length === 0)
+      return index;
+  }
+  return source.length;
+}
+function isSingleStringLiteral(source) {
+  const start = skipWhitespace(source, 0);
+  const literal = readStringLiteral(source, start);
+  return Boolean(literal && skipWhitespace(source, literal.end) === source.length);
+}
+function transformDynamicPropExpressions(source) {
+  const edits = [];
+  const keyPattern = /(^|[,{]\s*)(\$[A-Za-z_$][\w$]*)\s*:/g;
+  let match;
+  while (match = keyPattern.exec(source)) {
+    const colon = source.indexOf(":", match.index + match[1].length);
+    const valueStart = skipWhitespace(source, colon + 1);
+    const valueEnd = findExpressionEnd(source, valueStart);
+    const rawValue = source.slice(valueStart, valueEnd);
+    if (!rawValue.trim() || isSingleStringLiteral(rawValue))
+      continue;
+    edits.push({
+      start: valueStart,
+      end: valueEnd,
+      value: JSON.stringify(rawValue.trim())
+    });
+  }
+  if (edits.length === 0)
+    return source;
+  let transformed = source;
+  for (let index = edits.length - 1;index >= 0; index -= 1) {
+    const edit = edits[index];
+    transformed = `${transformed.slice(0, edit.start)}${edit.value}${transformed.slice(edit.end)}`;
+  }
+  return transformed;
+}
+function formatSlexKitDiagnostic(diagnostic) {
+  const detail = diagnostic.detail ? `
+${diagnostic.detail}` : "";
+  return `${diagnostic.message} at line ${diagnostic.line}, column ${diagnostic.column}.${detail}
+${diagnostic.excerpt}`;
+}
+function diagnoseSlexKitSource(source, error) {
+  return locateSyntaxError(source, error);
+}
+function parseSlexSource(source) {
+  try {
+    const parseSource = transformDynamicPropExpressions(source);
+    return {
+      ok: true,
+      value: new Function(`"use strict";
+return (
+${parseSource}
+);`)()
+    };
+  } catch (error) {
+    const diagnostic = diagnoseSlexKitSource(source, error);
+    return {
+      ok: false,
+      diagnostic,
+      error: new SlexKitSyntaxError(diagnostic)
+    };
+  }
+}
+var defaultRuntimeUrl = typeof document !== "undefined" && typeof document.currentScript === "object" && document.currentScript && "src" in document.currentScript ? String(document.currentScript.src || "") : undefined;
+function setSlexKitRuntimeUrl(url) {
+  defaultRuntimeUrl = url || undefined;
+}
+var schedulingSnapshot = {
+  setTimeout: typeof globalThis.setTimeout === "function" ? globalThis.setTimeout.bind(globalThis) : undefined,
+  clearTimeout: typeof globalThis.clearTimeout === "function" ? globalThis.clearTimeout.bind(globalThis) : undefined,
+  setInterval: typeof globalThis.setInterval === "function" ? globalThis.setInterval.bind(globalThis) : undefined,
+  clearInterval: typeof globalThis.clearInterval === "function" ? globalThis.clearInterval.bind(globalThis) : undefined,
+  requestAnimationFrame: typeof globalThis.requestAnimationFrame === "function" ? globalThis.requestAnimationFrame.bind(globalThis) : undefined,
+  cancelAnimationFrame: typeof globalThis.cancelAnimationFrame === "function" ? globalThis.cancelAnimationFrame.bind(globalThis) : undefined
+};
+var canvasSnapshot = {
+  getContext: typeof HTMLCanvasElement !== "undefined" ? HTMLCanvasElement.prototype.getContext : undefined,
+  offscreenCanvas: typeof OffscreenCanvas !== "undefined" ? OffscreenCanvas : undefined
+};
+setSlexKitRuntimeUrl(import.meta.url);
+var parseSlexSourceApi = parseSlexSource;
+
+// src/index.ts
+var dataBase = new URL("./data/", import.meta.url);
+async function readDataFile(name) {
+  return readFile(new URL(name, dataBase), "utf-8");
+}
+var manifest = JSON.parse(await readDataFile("slexkit-ai-manifest.json"));
+function stringArg(args, key) {
+  const value = args[key];
+  return typeof value === "string" ? value : "";
+}
+function optionalStringArg(args, key) {
+  const value = args[key];
+  return typeof value === "string" && value ? value : undefined;
+}
+function jsonSchema(properties, required = []) {
+  return {
+    type: "object",
+    properties,
+    required,
+    additionalProperties: false
+  };
+}
+function pageMatches(page, query) {
+  const needle = query.toLowerCase();
+  return [
+    page.id,
+    page.group,
+    page.title,
+    page.summary,
+    page.href,
+    page.rawHref,
+    page.sourcePath,
+    page.body
+  ].some((value) => value.toLowerCase().includes(needle));
+}
+function findPage(args) {
+  const slug = optionalStringArg(args, "slug");
+  const url = optionalStringArg(args, "url");
+  if (url) {
+    const normalized = url.replace(/^https?:\/\/[^/]+/, "");
+    return manifest.pages.find((page) => page.rawHref === normalized || page.href === normalized || page.rawHref === url || page.href === url);
+  }
+  if (slug) {
+    return manifest.pages.find((page) => page.id === slug || page.id.endsWith(`/${slug}`) || page.rawHref.endsWith(`/${slug}.md`));
+  }
+  return;
+}
+function searchPages(args) {
+  const group = optionalStringArg(args, "group");
+  const query = optionalStringArg(args, "query");
+  return manifest.pages.filter((page) => !group || page.group.toLowerCase() === group.toLowerCase()).filter((page) => !query || pageMatches(page, query)).map(({ body: _body, ...page }) => page);
+}
+function collectComponentUsage(value, found = new Set) {
+  if (!value || typeof value !== "object")
+    return [...found].sort();
+  for (const [key, child] of Object.entries(value)) {
+    const colon = key.indexOf(":");
+    if (colon > 0)
+      found.add(key.slice(0, colon));
+    collectComponentUsage(child, found);
+  }
+  return [...found].sort();
+}
+function sourceFromTemplate(template) {
+  if (template === "calculator") {
+    return `{
+  slex: "0.1",
+  namespace: "calculator",
+  g: { a: 10, b: 5 },
+  layout: {
+    "card:calc": {
+      title: "Calculator",
+      "input:a": { label: "A", "$value": "String(g.a)", onchange: "g.a = Number($event || 0)" },
+      "input:b": { label: "B", "$value": "String(g.b)", onchange: "g.b = Number($event || 0)" },
+      "stat:sum": { label: "Sum", "$value": "g.a + g.b" }
+    }
+  }
+}`;
+  }
+  if (template === "toolhost-form") {
+    return `{
+  slex: "0.1",
+  namespace: "approval_form",
+  g: { approved: false, reason: "" },
+  layout: {
+    "card:approval": {
+      title: "Review request",
+      "checkbox:approved": { label: "Approve", "$checked": "g.approved", onchange: "g.approved = Boolean($event)" },
+      "input:reason": { label: "Reason", "$value": "g.reason", onchange: "g.reason = String($event || '')" },
+      "submit:actions": { submitLabel: "Submit", ignoreLabel: "Ignore", returnKeys: ["approved", "reason"] }
+    }
+  }
+}`;
+  }
+  if (template === "host-integration") {
+    return `import { createSlexKitMarkdownRuntimeHost } from "slexkit";
+import "slexkit/style.css";
+
+const runtime = createSlexKitMarkdownRuntimeHost({
+  mode: "secure",
+  secureFrame: { runtimeUrl: "/runtime.js" }
+});
+
+runtime.mountBlock({
+  artifactId: "message-1",
+  blockId: "message-1:block-1",
+  source,
+  container
+});`;
+  }
+  return `{
+  slex: "0.1",
+  namespace: "status",
+  g: { done: 3, total: 4 },
+  layout: {
+    "card:summary": {
+      title: "Status",
+      "text:count": { "$text": "g.done + '/' + g.total + ' complete'" },
+      "progress:bar": { "$value": "g.done / g.total * 100" }
+    }
+  }
+}`;
+}
+var tools = [
+  {
+    name: "slexkitDocs",
+    description: "Search or fetch SlexKit Markdown docs. Raw docs are .md files with explicit slex fences; no .mdx routes are used.",
+    inputSchema: jsonSchema({
+      query: { type: "string", description: "Search text. Searches titles, summaries, URLs, source paths, and body text." },
+      group: { type: "string", description: "Optional group filter: Guides, Components, Runtime, ToolHost, Security, Packages, Icons." },
+      slug: { type: "string", description: "Optional page id or slug to fetch, such as components/card or card." },
+      url: { type: "string", description: "Optional href or raw .md URL to fetch." }
+    }),
+    handler(args) {
+      const page = findPage(args);
+      if (page)
+        return { version: manifest.version, page };
+      return { version: manifest.version, pages: searchPages(args) };
+    }
+  },
+  {
+    name: "slexkitExamples",
+    description: "Browse SlexKit component examples, ToolHost examples, and host integration snippets.",
+    inputSchema: jsonSchema({
+      type: { type: "string", description: "Optional component type, such as card, input, stat, or submit." },
+      template: { type: "string", enum: ["status", "calculator", "toolhost-form", "host-integration"], description: "Optional generated example template." }
+    }),
+    handler(args) {
+      const template = optionalStringArg(args, "template");
+      if (template) {
+        const source = sourceFromTemplate(template);
+        const parsed = template === "host-integration" ? { ok: true } : parseSlexSourceApi(source);
+        return { template, source, valid: parsed.ok };
+      }
+      const type = optionalStringArg(args, "type");
+      const components = manifest.components.filter((component) => !type || component.type === type);
+      if (type && components.length === 0) {
+        return { error: "component_not_found", type, available: manifest.components.map((component) => component.type) };
+      }
+      return {
+        components: components.map((component) => ({
+          type: component.type,
+          title: component.title,
+          summary: component.summary,
+          rawHref: component.rawHref,
+          examples: component.examples.map((example) => ({
+            id: example.id,
+            title: example.title,
+            description: example.description,
+            source: JSON.stringify(example.source, null, 2)
+          }))
+        }))
+      };
+    }
+  },
+  {
+    name: "slexkitValidate",
+    description: "Parse Slex source and return diagnostics plus component usage.",
+    inputSchema: jsonSchema({ source: { type: "string", description: "Slex object literal source." } }, ["source"]),
+    handler(args) {
+      const source = stringArg(args, "source");
+      const parsed = parseSlexSourceApi(source);
+      if (!parsed.ok) {
+        return {
+          ok: false,
+          diagnostic: parsed.diagnostic
+        };
+      }
+      return {
+        ok: true,
+        componentUsage: collectComponentUsage(parsed.value)
+      };
+    }
+  }
+];
+var toolByName = new Map(tools.map((tool) => [tool.name, tool]));
+function send(message) {
+  process.stdout.write(`${JSON.stringify(message)}
+`);
+}
+function respond(id, result) {
+  send({ jsonrpc: "2.0", id, result });
+}
+function respondError(id, code, message, data) {
+  send({ jsonrpc: "2.0", id, error: { code, message, data } });
+}
+async function handleRequest(request) {
+  if (request.id === undefined && request.method.startsWith("notifications/"))
+    return;
+  if (request.method === "initialize") {
+    respond(request.id, {
+      protocolVersion: "2025-06-18",
+      capabilities: { tools: {} },
+      serverInfo: { name: "@slexkit/mcp", version: manifest.version }
+    });
+    return;
+  }
+  if (request.method === "tools/list") {
+    respond(request.id, {
+      tools: tools.map(({ name, description, inputSchema }) => ({ name, description, inputSchema }))
+    });
+    return;
+  }
+  if (request.method === "tools/call") {
+    const params = request.params ?? {};
+    const name = typeof params.name === "string" ? params.name : "";
+    const args = params.arguments && typeof params.arguments === "object" ? params.arguments : {};
+    const tool = toolByName.get(name);
+    if (!tool) {
+      respondError(request.id, -32602, `Unknown tool: ${name}`, { available: [...toolByName.keys()] });
+      return;
+    }
+    const result = await tool.handler(args);
+    respond(request.id, {
+      content: [{ type: "text", text: typeof result === "string" ? result : JSON.stringify(result, null, 2) }],
+      structuredContent: result
+    });
+    return;
+  }
+  respondError(request.id, -32601, `Method not found: ${request.method}`);
+}
+var rl = createInterface({ input: process.stdin, crlfDelay: Infinity });
+rl.on("line", (line) => {
+  const trimmed = line.trim();
+  if (!trimmed)
+    return;
+  (async () => {
+    try {
+      await handleRequest(JSON.parse(trimmed));
+    } catch (error) {
+      respondError(null, -32700, error instanceof Error ? error.message : String(error));
+    }
+  })();
+});
+
+//# debugId=A2A380ED9FA68E9464756E2164756E21