@markdy/language-server 0.7.15

package/LICENSE

@@ -0,0 +1 @@
+MIT

package/README.md

@@ -0,0 +1,15 @@
+# @markdy/language-server
+
+Language Server Protocol (LSP) server for MarkdyScript.
+
+Current capabilities:
+- parse diagnostics from `@markdy/core`
+- actor-aware action completion
+- hover docs for common actions
+- document symbols for scenes, actors, defs, and seqs
+
+Run on stdio:
+
+```sh
+npx @markdy/language-server
+```

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/index.js

@@ -0,0 +1,367 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { ParseError, parse } from "@markdy/core";
+import {
+  CompletionItemKind,
+  createConnection,
+  DiagnosticSeverity,
+  ProposedFeatures,
+  SymbolKind,
+  TextDocumentSyncKind,
+  TextDocuments
+} from "vscode-languageserver/node.js";
+import { TextDocument } from "vscode-languageserver-textdocument";
+var connection = createConnection(ProposedFeatures.all);
+var documents = new TextDocuments(TextDocument);
+var UNIVERSAL_ACTIONS = [
+  "enter",
+  "exit",
+  "move",
+  "fade_in",
+  "fade_out",
+  "scale",
+  "rotate",
+  "shake",
+  "say",
+  "throw",
+  "play"
+];
+var FIGURE_ACTIONS = [
+  "punch",
+  "kick",
+  "wave",
+  "nod",
+  "jump",
+  "bounce",
+  "face",
+  "rotate_part",
+  "pose"
+];
+var SYSTEM_ACTIONS = ["request", "response", "emit"];
+var KEYWORDS = [
+  "scene",
+  "actor",
+  "asset",
+  "var",
+  "def",
+  "seq",
+  "preset",
+  "import",
+  "camera"
+];
+var SEMANTIC_TOKEN_TYPES = ["keyword", "variable", "method", "class"];
+var SEMANTIC_TOKEN_TYPE_INDEX = new Map(
+  SEMANTIC_TOKEN_TYPES.map((type, i) => [type, i])
+);
+var ACTION_DOCS = {
+  enter: "Slide actor in from edge. Params: `from`, `dur`, `ease`.",
+  exit: "Slide actor out to edge. Params: `to`, `dur`, `ease`.",
+  move: "Move actor to coordinate. Params: `to=(x,y)`, `dur`, `ease`.",
+  fade_in: "Fade actor opacity to 1. Params: `dur`, `ease`.",
+  fade_out: "Fade actor opacity to 0. Params: `dur`, `ease`.",
+  say: "Show a speech bubble. Params: `text`, `dur`.",
+  play: "Expand sequence on actor. Params: `seqName, ...args`.",
+  request: "Draw an outbound flow edge. Params: `to`, `label`, `dur`, `style`.",
+  response: "Draw a return flow edge. Params: `to`, `label`, `dur`, `style`.",
+  emit: "Draw async fire-and-forget flow edge. Params: `to`, `label`, `dur`, `style=fire_and_forget`.",
+  pan: "Move camera center. Params: `to=(x,y)`, `dur`, `ease`.",
+  zoom: "Change camera zoom. Params: `to`, `dur`, `ease`.",
+  shake: "Shake actor/camera. Params: `intensity`, `dur`."
+};
+function extractActors(text) {
+  const actors = [];
+  const lines = text.split(/\r?\n/);
+  for (let i = 0; i < lines.length; i++) {
+    const m = /^actor\s+(\w+)\s*=\s*([\w.]+)\(/.exec(lines[i].trim());
+    if (!m) continue;
+    actors.push({ name: m[1], type: m[2], line: i });
+  }
+  return actors;
+}
+function getActionsForActorType(actorType) {
+  const out = [...UNIVERSAL_ACTIONS];
+  if (actorType === "figure") out.push(...FIGURE_ACTIONS);
+  if (actorType === "service" || actorType === "db" || actorType === "queue" || actorType === "client") {
+    out.push(...SYSTEM_ACTIONS);
+  }
+  return out;
+}
+function lineRange(doc, lineNumber) {
+  const line = Math.max(0, Math.min(lineNumber, doc.lineCount - 1));
+  const text = doc.getText({
+    start: { line, character: 0 },
+    end: { line, character: 1e4 }
+  });
+  return {
+    start: { line, character: 0 },
+    end: { line, character: Math.max(1, text.length) }
+  };
+}
+function parseWarningsToDiagnostics(warnings, doc) {
+  return warnings.map((w) => ({
+    severity: DiagnosticSeverity.Warning,
+    range: lineRange(doc, w.line - 1),
+    message: w.message,
+    source: "markdy"
+  }));
+}
+function validateTextDocument(document) {
+  const text = document.getText();
+  const diagnostics = [];
+  try {
+    const ast = parse(text);
+    diagnostics.push(...parseWarningsToDiagnostics(ast.warnings, document));
+  } catch (err) {
+    if (err instanceof ParseError) {
+      diagnostics.push({
+        severity: DiagnosticSeverity.Error,
+        range: lineRange(document, err.line - 1),
+        message: err.message.replace(/^Line \d+:\s*/, ""),
+        source: "markdy"
+      });
+    } else if (err instanceof Error) {
+      diagnostics.push({
+        severity: DiagnosticSeverity.Error,
+        range: lineRange(document, 0),
+        message: err.message,
+        source: "markdy"
+      });
+    }
+  }
+  connection.sendDiagnostics({ uri: document.uri, diagnostics });
+}
+function getLinePrefix(doc, position) {
+  const lineStart = doc.offsetAt({ line: position.line, character: 0 });
+  const at = doc.offsetAt(position);
+  return doc.getText().slice(lineStart, at);
+}
+function toMethodCompletion(action) {
+  return {
+    label: action,
+    kind: CompletionItemKind.Method,
+    detail: "Markdy action",
+    documentation: ACTION_DOCS[action] ?? void 0,
+    insertText: `${action}()`
+  };
+}
+function getTokenAtPosition(doc, position) {
+  const lineText = doc.getText({
+    start: { line: position.line, character: 0 },
+    end: { line: position.line, character: 1e4 }
+  });
+  const idx = Math.min(position.character, lineText.length);
+  const left = lineText.slice(0, idx).match(/[A-Za-z_][\w.]*$/)?.[0] ?? "";
+  const rightMatch = lineText.slice(idx).match(/^[\w.]*/);
+  const right = rightMatch ? rightMatch[0] : "";
+  const token = `${left}${right}`;
+  return token || null;
+}
+function pushSemanticToken(data, state, line, char, length, type) {
+  const tokenType = SEMANTIC_TOKEN_TYPE_INDEX.get(type);
+  if (tokenType === void 0) return;
+  const deltaLine = line - state.line;
+  const deltaStart = deltaLine === 0 ? char - state.char : char;
+  data.push(deltaLine, deltaStart, length, tokenType, 0);
+  state.line = line;
+  state.char = char;
+}
+function buildSemanticTokenData(document) {
+  const data = [];
+  const cursor = { line: 0, char: 0 };
+  const text = document.getText();
+  const actors = new Set(extractActors(text).map((a) => a.name));
+  const lines = text.split(/\r?\n/);
+  for (let line = 0; line < lines.length; line++) {
+    const content = lines[line];
+    const head = content.trim();
+    for (const keyword of KEYWORDS) {
+      const idx = head.indexOf(keyword);
+      if (idx === 0) {
+        const start = content.indexOf(keyword);
+        if (start >= 0) pushSemanticToken(data, cursor, line, start, keyword.length, "keyword");
+      }
+    }
+    for (const name of actors) {
+      const match = new RegExp(`\\b${name}\\b`).exec(content);
+      if (match?.index !== void 0) {
+        pushSemanticToken(data, cursor, line, match.index, name.length, "variable");
+      }
+    }
+    const actionMatch = /\.\s*([A-Za-z_]\w*)\s*\(/.exec(content);
+    if (actionMatch?.index !== void 0) {
+      const actionName = actionMatch[1];
+      const actionStart = actionMatch.index + actionMatch[0].indexOf(actionName);
+      pushSemanticToken(data, cursor, line, actionStart, actionName.length, "method");
+    }
+    const defMatch = /^def\s+([A-Za-z_]\w*)/.exec(head);
+    if (defMatch) {
+      const start = content.indexOf(defMatch[1]);
+      if (start >= 0) pushSemanticToken(data, cursor, line, start, defMatch[1].length, "class");
+    }
+  }
+  return data;
+}
+function buildDocumentSymbols(document) {
+  const symbols = [];
+  const lines = document.getText().split(/\r?\n/);
+  for (let i = 0; i < lines.length; i++) {
+    const raw = lines[i].trim();
+    const scene = /^scene\s+"([^"]+)"/.exec(raw);
+    if (scene) {
+      symbols.push({
+        name: scene[1],
+        detail: "scene",
+        kind: SymbolKind.Namespace,
+        range: lineRange(document, i),
+        selectionRange: lineRange(document, i),
+        children: []
+      });
+      continue;
+    }
+    const actor = /^actor\s+(\w+)\s*=/.exec(raw);
+    if (actor) {
+      symbols.push({
+        name: actor[1],
+        detail: "actor",
+        kind: SymbolKind.Variable,
+        range: lineRange(document, i),
+        selectionRange: lineRange(document, i),
+        children: []
+      });
+      continue;
+    }
+    const seq = /^seq\s+(\w+)/.exec(raw);
+    if (seq) {
+      symbols.push({
+        name: seq[1],
+        detail: "sequence",
+        kind: SymbolKind.Function,
+        range: lineRange(document, i),
+        selectionRange: lineRange(document, i),
+        children: []
+      });
+      continue;
+    }
+    const def = /^def\s+(\w+)/.exec(raw);
+    if (def) {
+      symbols.push({
+        name: def[1],
+        detail: "template",
+        kind: SymbolKind.Class,
+        range: lineRange(document, i),
+        selectionRange: lineRange(document, i),
+        children: []
+      });
+    }
+  }
+  return symbols;
+}
+connection.onInitialize((_params) => ({
+  capabilities: {
+    textDocumentSync: TextDocumentSyncKind.Incremental,
+    completionProvider: {
+      resolveProvider: false,
+      triggerCharacters: [".", "@"]
+    },
+    hoverProvider: true,
+    documentSymbolProvider: true,
+    semanticTokensProvider: {
+      full: true,
+      legend: {
+        tokenTypes: [...SEMANTIC_TOKEN_TYPES],
+        tokenModifiers: []
+      }
+    }
+  }
+}));
+documents.onDidOpen((e) => validateTextDocument(e.document));
+documents.onDidChangeContent((e) => validateTextDocument(e.document));
+connection.onCompletion((params) => {
+  const doc = documents.get(params.textDocument.uri);
+  if (!doc) return [];
+  const actors = extractActors(doc.getText());
+  const actorByName = new Map(actors.map((a) => [a.name, a.type]));
+  const prefix = getLinePrefix(doc, params.position);
+  const actorAction = /(\w+)\.([A-Za-z_]*)$/.exec(prefix);
+  if (actorAction) {
+    const actorName = actorAction[1];
+    const partial = actorAction[2] ?? "";
+    const actorType = actorByName.get(actorName);
+    if (!actorType) return [];
+    return getActionsForActorType(actorType).filter((a) => a.startsWith(partial)).map(toMethodCompletion);
+  }
+  const lineEventPrefix = /@[\d.+]*:\s*$/.test(prefix);
+  if (lineEventPrefix) {
+    return actors.map((a) => ({
+      label: a.name,
+      kind: CompletionItemKind.Variable,
+      detail: `${a.type} actor`,
+      insertText: `${a.name}.`
+    }));
+  }
+  const items = [];
+  for (const keyword of KEYWORDS) {
+    items.push({
+      label: keyword,
+      kind: CompletionItemKind.Keyword,
+      detail: "Markdy keyword"
+    });
+  }
+  for (const actor of actors) {
+    items.push({
+      label: actor.name,
+      kind: CompletionItemKind.Variable,
+      detail: `${actor.type} actor`
+    });
+  }
+  return items;
+});
+connection.onHover((params) => {
+  const doc = documents.get(params.textDocument.uri);
+  if (!doc) return null;
+  const token = getTokenAtPosition(doc, params.position);
+  if (!token) return null;
+  const actor = extractActors(doc.getText()).find((a) => a.name === token);
+  if (actor) {
+    return {
+      contents: {
+        kind: "markdown",
+        value: `**${actor.name}**
+
+Actor type: \`${actor.type}\``
+      }
+    };
+  }
+  if (ACTION_DOCS[token]) {
+    return {
+      contents: {
+        kind: "markdown",
+        value: `**${token}**
+
+${ACTION_DOCS[token]}`
+      }
+    };
+  }
+  if (KEYWORDS.includes(token)) {
+    return {
+      contents: {
+        kind: "markdown",
+        value: `Markdy keyword: \`${token}\``
+      }
+    };
+  }
+  return null;
+});
+connection.onDocumentSymbol((params) => {
+  const doc = documents.get(params.textDocument.uri);
+  if (!doc) return [];
+  return buildDocumentSymbols(doc);
+});
+connection.languages.semanticTokens.on((params) => {
+  const doc = documents.get(params.textDocument.uri);
+  if (!doc) return { data: [] };
+  return { data: buildSemanticTokenData(doc) };
+});
+documents.listen(connection);
+connection.listen();

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@markdy/language-server",
+  "version": "0.7.15",
+  "description": "Language Server Protocol implementation for MarkdyScript.",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "markdy-language-server": "./dist/index.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "keywords": [
+    "markdy",
+    "lsp",
+    "language-server",
+    "markdyscript",
+    "editor"
+  ],
+  "author": "Hoang Yell <hoangyell@gmail.com> (https://hoangyell.com)",
+  "homepage": "https://markdy.com",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/HoangYell/markdy-com.git",
+    "directory": "packages/markdy-language-server"
+  },
+  "bugs": {
+    "url": "https://github.com/HoangYell/markdy-com/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "vscode-languageserver": "^9.0.1",
+    "vscode-languageserver-textdocument": "^1.0.12",
+    "@markdy/core": "0.7.15"
+  },
+  "devDependencies": {
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3"
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "echo \"No tests yet\"",
+    "typecheck": "tsc --noEmit",
+    "lint": "tsc --noEmit"
+  }
+}