@hyperfixi/mcp-server 2.1.0 → 2.2.0

package/dist/index.js

@@ -8077,7 +8077,7 @@ function createInlineExtractor() {
     const fs = await import("fs");
     const path = await import("path");
     const crypto = await import("crypto");
-    const { glob } = await import("./esm-QH3OJYW7.js");
+    const { glob } = await import("./esm-LUPOYJFX.js");
     const globs = [
       "**/*.html",
       "**/*.htm",
@@ -8539,6 +8539,57 @@ function createSchemaLookup(schemas) {
 
 // src/tools/lse-pipeline.ts
 var lsePipelineTools = [
+  // ── Phase 7.5: LLM-Native LSE tools ──────────────────────────────────────
+  {
+    name: "execute_lse",
+    description: "Execute LSE bracket syntax directly. Parses the LSE, compiles to JavaScript, and returns the execution result. Use this when an LLM has generated LSE and you want to run it.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        lse: {
+          type: "string",
+          description: "LSE bracket syntax: [command role:value ...]"
+        }
+      },
+      required: ["lse"]
+    }
+  },
+  {
+    name: "validate_lse",
+    description: "Validate LSE bracket syntax or protocol JSON without executing. Returns diagnostics (errors, warnings) and the normalized LSE. Use for pre-flight checks before execution.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        lse: {
+          type: "string",
+          description: "LSE bracket syntax to validate"
+        },
+        protocol: {
+          type: "object",
+          description: "Protocol JSON to validate (alternative to lse)"
+        }
+      }
+    }
+  },
+  {
+    name: "translate_lse",
+    description: "Translate LSE bracket syntax to natural language in a specified target language. Returns the natural-language hyperscript equivalent. Supports all 24 languages.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        lse: {
+          type: "string",
+          description: "LSE bracket syntax: [command role:value ...]"
+        },
+        language: {
+          type: "string",
+          description: "Target language code (e.g., en, ja, es, ko, ar, zh)"
+        }
+      },
+      required: ["lse", "language"]
+    }
+  },
+  // ── Existing pipeline tools ───────────────────────────────────────────────
   {
     name: "lse_from_hyperscript",
     description: "Parse hyperscript code (any of 24 languages) to LSE bracket syntax and protocol JSON. Use this to get a structured representation for LLM modification or cross-language translation. Returns both bracket syntax (human-readable) and protocol JSON (machine-readable).",
@@ -8586,6 +8637,12 @@ var lsePipelineTools = [
 async function handleLsePipelineTool(name, args) {
   try {
     switch (name) {
+      case "execute_lse":
+        return await handleExecuteLse(args);
+      case "validate_lse":
+        return await handleValidateLse(args);
+      case "translate_lse":
+        return await handleTranslateLse(args);
       case "lse_from_hyperscript":
         return await handleFromHyperscript(args);
       case "lse_to_hyperscript":
@@ -8736,6 +8793,115 @@ async function handleToHyperscript(args) {
   }
   return jsonResponse(result);
 }
+async function handleExecuteLse(args) {
+  const lseInput = args.lse;
+  if (!lseInput || typeof lseInput !== "string") {
+    return errorResponse("Missing required parameter: lse");
+  }
+  const { parseExplicit: parseExplicit2, renderExplicit: renderExplicit2, toProtocolJSON: toProtocolJSON2 } = await import("@lokascript/framework");
+  let node;
+  try {
+    node = parseExplicit2(lseInput);
+  } catch (e) {
+    return errorResponse(`LSE parse error: ${e instanceof Error ? e.message : String(e)}`);
+  }
+  const normalizedLse = renderExplicit2(node);
+  const protocol = toProtocolJSON2(node);
+  let js;
+  try {
+    const { CompilationService } = await import("@lokascript/compilation-service");
+    const service = await CompilationService.create();
+    const compileResult = service.compile({ explicit: normalizedLse });
+    js = compileResult.ok ? compileResult.js : void 0;
+  } catch {
+  }
+  return jsonResponse({
+    ok: true,
+    lse: normalizedLse,
+    protocol,
+    js,
+    note: js ? "Compiled successfully" : "Compilation service unavailable \u2014 parsed and validated only"
+  });
+}
+async function handleValidateLse(args) {
+  const lseInput = typeof args.lse === "string" ? args.lse : void 0;
+  const protocolInput = typeof args.protocol === "object" && args.protocol ? args.protocol : void 0;
+  if (!lseInput && !protocolInput) {
+    return errorResponse("Provide `lse` (bracket syntax) or `protocol` (JSON).");
+  }
+  const { parseExplicit: parseExplicit2, renderExplicit: renderExplicit2, validateProtocolJSON: validateProtocolJSON2 } = await import("@lokascript/framework");
+  const diagnostics = [];
+  if (lseInput) {
+    try {
+      const node = parseExplicit2(lseInput);
+      const normalized = renderExplicit2(node);
+      return jsonResponse({
+        valid: true,
+        normalized,
+        diagnostics: []
+      });
+    } catch (e) {
+      diagnostics.push({
+        severity: "error",
+        code: "PARSE_ERROR",
+        message: e instanceof Error ? e.message : String(e)
+      });
+      return jsonResponse({ valid: false, diagnostics });
+    }
+  }
+  if (protocolInput) {
+    const protoDiags = validateProtocolJSON2(protocolInput);
+    const hasErrors = protoDiags.some((d) => d.severity === "error");
+    return jsonResponse({
+      valid: !hasErrors,
+      diagnostics: protoDiags
+    });
+  }
+  return jsonResponse({ valid: false, diagnostics });
+}
+async function handleTranslateLse(args) {
+  const lseInput = args.lse;
+  const language = args.language;
+  if (!lseInput || typeof lseInput !== "string") {
+    return errorResponse("Missing required parameter: lse");
+  }
+  if (!language || typeof language !== "string") {
+    return errorResponse("Missing required parameter: language");
+  }
+  try {
+    const { parseExplicit: parseExplicit2, renderExplicit: renderExplicit2 } = await import("@lokascript/framework");
+    const { translate } = await import("@lokascript/semantic");
+    const node = parseExplicit2(lseInput);
+    const normalized = renderExplicit2(node);
+    const action = node.action;
+    const roles = node.roles;
+    const parts = [action];
+    const roleEntries = roles instanceof Map ? [...roles.entries()] : Object.entries(roles || {});
+    for (const [role, value] of roleEntries) {
+      const val = typeof value === "object" && value !== null ? value.value ?? value : value;
+      if (role === "patient") {
+        parts.push(String(val));
+      } else if (role === "destination") {
+        parts.push("on", String(val));
+      } else if (role === "source") {
+        parts.push("from", String(val));
+      } else {
+        parts.push(String(val));
+      }
+    }
+    const english = parts.join(" ");
+    const translated = translate(english, "en", language);
+    return jsonResponse({
+      ok: true,
+      language,
+      translated,
+      lse: normalized,
+      english
+    });
+  } catch (e) {
+    return errorResponse(`Translation error: ${e instanceof Error ? e.message : String(e)}`);
+  }
+}
 
 // src/resources/content.ts
 function getCommandsReference() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperfixi/mcp-server",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "Model Context Protocol server for HyperFixi hyperscript development",
   "type": "module",
   "main": "dist/index.js",