@markdy/language-server 0.7.29 → 0.8.1

package/dist/index.js

@@ -2,13 +2,11 @@
 
 // src/index.ts
 import {
-  FIGURE_ONLY_ACTION_NAMES,
+  BEAT_CUE_KEYWORDS,
+  NODE_KINDS,
   ParseError,
-  UNIVERSAL_ACTION_NAMES,
-  parse,
-  registerActorPack
+  parse
 } from "@markdy/core";
-import { SYSTEM_ACTOR_TYPES, SYSTEM_FLOW_ACTIONS, systemsPack } from "@markdy/stdlib-systems";
 import {
   CompletionItemKind,
   createConnection,
@@ -21,387 +19,110 @@ import {
 import { TextDocument } from "vscode-languageserver-textdocument";
 var connection = createConnection(ProposedFeatures.all);
 var documents = new TextDocuments(TextDocument);
-registerActorPack(systemsPack);
-var UNIVERSAL_ACTIONS = [...UNIVERSAL_ACTION_NAMES];
-var FIGURE_ACTIONS = [...FIGURE_ONLY_ACTION_NAMES];
-var SYSTEM_ACTIONS = [...SYSTEM_FLOW_ACTIONS];
-var SYSTEM_TYPES = new Set(SYSTEM_ACTOR_TYPES);
-var ARCHITECTURE_KEYWORDS = /* @__PURE__ */ new Set([
-  "service",
-  "database",
-  "db",
-  "queue",
-  "cache",
-  "api",
-  "user",
-  "client",
-  "cloud",
-  "region",
-  "container",
-  "microservice",
-  "cluster"
-]);
 var KEYWORDS = [
   "scene",
-  "actor",
-  "asset",
-  "var",
-  "def",
-  "seq",
+  "layout",
   "group",
-  "preset",
-  "import",
-  "camera",
-  ...ARCHITECTURE_KEYWORDS
+  "beat",
+  "style",
+  "pattern",
+  "use",
+  "theme",
+  "edge",
+  "LR",
+  "RL",
+  "TB",
+  "BT",
+  "show",
+  "hide",
+  "glow",
+  "focus",
+  ...BEAT_CUE_KEYWORDS,
+  ...NODE_KINDS
 ];
-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`.",
-  spring: "Spring to a coordinate with overshoot. Params: `to=(x,y)`, `stiffness`, `dur`.",
-  follow_path: "Move along an SVG path using CSS motion paths. Params: `path`, `dur`, `rotate`.",
-  pulse: "Scale up and settle back for emphasis. Params: `amount`, `dur`.",
-  glow: "Animate drop-shadow/box-shadow emphasis. Params: `color`, `strength`, `dur`.",
-  ripple: "Emit a transient expanding ring from the actor center. Params: `color`, `size`, `dur`.",
-  blur: "Animate CSS blur. Params: `from`, `to`, `dur`.",
-  line_reveal: "Reveal an actor with a directional clip-path wipe. Params: `from`, `dur`.",
-  mask: "Animate a circular clip-path mask. Params: `from`, `to`, `dur`.",
-  parallax: "Offset an actor by depth for layered movement. Params: `depth`, `by=(x,y)`, `dur`."
-};
-function extractActors(text) {
-  const actors = [];
+function extractNodes(text) {
+  const nodes = [];
   const lines = text.split(/\r?\n/);
   for (let i = 0; i < lines.length; i++) {
     const raw = lines[i].trim();
-    const actor = /^actor\s+(\w+)\s*=\s*([\w.]+)\(/.exec(raw);
-    if (actor) {
-      actors.push({ name: actor[1], type: actor[2], line: i });
-      continue;
+    const m = /^(\w[\w.-]*)\s+(\w[\w.-]*)/.exec(raw);
+    if (!m) continue;
+    if (["scene", "layout", "group", "beat", "style", "pattern", "edge", "use"].includes(m[1])) continue;
+    if (NODE_KINDS.has(m[1].toLowerCase())) {
+      nodes.push({ kind: m[1], name: m[2], line: i });
     }
-    const shorthand = /^(service|database|db|queue|cache|api|user|client|cloud|region|container|microservice|cluster)\s+(\w+)\b/.exec(raw);
-    if (shorthand) {
-      const type = shorthand[1] === "api" ? "service" : shorthand[1] === "user" ? "client" : shorthand[1];
-      actors.push({ name: shorthand[2], type, line: i });
-    }
-  }
-  return actors;
-}
-function getActionsForActorType(actorType) {
-  const out = [...UNIVERSAL_ACTIONS];
-  if (actorType === "figure") out.push(...FIGURE_ACTIONS);
-  if (SYSTEM_TYPES.has(actorType)) {
-    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"
-  }));
+  return nodes;
 }
-function validateTextDocument(document) {
-  const text = document.getText();
-  const diagnostics = [];
+function parseDiagnostics(text) {
   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();
-    const tokens = [];
-    for (const keyword of KEYWORDS) {
-      if (head.startsWith(keyword) && !/\w/.test(head.charAt(keyword.length))) {
-        const start = content.indexOf(keyword);
-        if (start >= 0) tokens.push({ char: start, length: keyword.length, type: "keyword" });
-      }
-    }
-    for (const name of actors) {
-      const match = new RegExp(`\\b${name}\\b`).exec(content);
-      if (match?.index !== void 0) {
-        tokens.push({ char: match.index, length: name.length, type: "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);
-      tokens.push({ char: actionStart, length: actionName.length, type: "method" });
-    }
-    const defMatch = /^def\s+([A-Za-z_]\w*)/.exec(head);
-    if (defMatch) {
-      const start = content.indexOf(defMatch[1]);
-      if (start >= 0) tokens.push({ char: start, length: defMatch[1].length, type: "class" });
-    }
-    tokens.sort((a, b) => a.char - b.char);
-    for (const token of tokens) {
-      pushSemanticToken(data, cursor, line, token.char, token.length, token.type);
+    return ast.diagnostics;
+  } catch (error) {
+    if (error instanceof ParseError) {
+      return [{ severity: "error", message: error.message, line: error.line }];
     }
+    return [{ severity: "error", message: String(error), line: 1 }];
   }
-  return data;
 }
-function buildDocumentSymbols(document) {
+function buildDocumentSymbols(text) {
   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 shorthand = /^(service|database|db|queue|cache|api|user|client|cloud|region|container|microservice|cluster)\s+(\w+)\b/.exec(raw);
-    if (shorthand) {
-      symbols.push({
-        name: shorthand[2],
-        detail: shorthand[1],
-        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: []
-      });
-    }
+  const nodes = extractNodes(text);
+  for (const node of nodes) {
+    symbols.push({
+      name: node.name,
+      kind: SymbolKind.Class,
+      range: { start: { line: node.line, character: 0 }, end: { line: node.line, character: 80 } },
+      selectionRange: { start: { line: node.line, character: 0 }, end: { line: node.line, character: 80 } }
+    });
   }
   return symbols;
 }
-connection.onInitialize((_params) => ({
+connection.onInitialize(() => ({
   capabilities: {
     textDocumentSync: TextDocumentSyncKind.Incremental,
-    completionProvider: {
-      resolveProvider: false,
-      triggerCharacters: [".", "@"]
-    },
-    hoverProvider: true,
+    completionProvider: { triggerCharacters: [" ", ".", ":", "-", ">"] },
     documentSymbolProvider: true,
-    semanticTokensProvider: {
-      full: true,
-      legend: {
-        tokenTypes: [...SEMANTIC_TOKEN_TYPES],
-        tokenModifiers: []
-      }
-    }
+    hoverProvider: true
   }
 }));
-documents.onDidOpen((e) => validateTextDocument(e.document));
-documents.onDidChangeContent((e) => validateTextDocument(e.document));
-documents.onDidClose((e) => {
-  connection.sendDiagnostics({ uri: e.document.uri, diagnostics: [] });
+documents.onDidChangeContent((change) => {
+  const text = change.document.getText();
+  const diagnostics = parseDiagnostics(text).map((d) => ({
+    severity: d.severity === "error" ? DiagnosticSeverity.Error : DiagnosticSeverity.Warning,
+    range: {
+      start: { line: Math.max(0, d.line - 1), character: 0 },
+      end: { line: Math.max(0, d.line - 1), character: 120 }
+    },
+    message: d.message,
+    source: "markdy"
+  }));
+  connection.sendDiagnostics({ uri: change.document.uri, diagnostics });
 });
 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`
-    });
-  }
+  const nodes = extractNodes(doc.getText());
+  const items = [
+    ...KEYWORDS.map((label) => ({ label, kind: CompletionItemKind.Keyword })),
+    ...nodes.map((n) => ({ label: n.name, kind: CompletionItemKind.Variable })),
+    { label: "$nodes", kind: CompletionItemKind.Variable },
+    { label: "$title", kind: CompletionItemKind.Variable }
+  ];
   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);
+  return buildDocumentSymbols(doc.getText());
 });
-connection.languages.semanticTokens.on((params) => {
+connection.onHover((params) => {
   const doc = documents.get(params.textDocument.uri);
-  if (!doc) return { data: [] };
-  return { data: buildSemanticTokenData(doc) };
+  if (!doc) return null;
+  const line = doc.getText().split(/\r?\n/)[params.position.line]?.trim() ?? "";
+  if (line.startsWith("beat ")) return { contents: { kind: "markdown", value: "Named narrative beat with indented cues." } };
+  if (line.includes("->")) return { contents: { kind: "markdown", value: "Request/call flow edge." } };
+  return null;
 });
 documents.listen(connection);
 connection.listen();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@markdy/language-server",
-  "version": "0.7.29",
-  "description": "Language Server Protocol implementation for MarkdyScript.",
+  "version": "0.8.1",
+  "description": "Language Server Protocol implementation for MarkdyScript diagrams.",
   "license": "MIT",
   "type": "module",
   "sideEffects": false,
@@ -26,6 +26,7 @@
     "lsp",
     "language-server",
     "markdyscript",
+    "diagram-as-code",
     "editor"
   ],
   "author": "Hoang Yell <hoangyell@gmail.com> (https://hoangyell.com)",
@@ -44,8 +45,8 @@
   "dependencies": {
     "vscode-languageserver": "^9.0.1",
     "vscode-languageserver-textdocument": "^1.0.12",
-    "@markdy/core": "0.7.29",
-    "@markdy/stdlib-systems": "0.7.29"
+    "@markdy/core": "0.8.1",
+    "@markdy/stdlib-systems": "0.8.1"
   },
   "devDependencies": {
     "tsup": "^8.5.1",