@markdy/cli 0.7.28 → 0.8.0

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { SceneAST } from '@markdy/core';
+import { DiagramAST } from '@markdy/core';
 import { Server } from 'node:http';
 
 interface CliIo {
@@ -15,8 +15,7 @@ interface RunResult {
 type LoadedScene = {
     filePath: string;
     source: string;
-    ast: SceneAST;
-    imports: Record<string, SceneAST>;
+    ast: DiagramAST;
 };
 declare function runCli(argv: string[], io?: CliIo, runtime?: CliRuntime): Promise<RunResult>;
 declare function buildStandaloneHtml(scene: LoadedScene): Promise<string>;

package/dist/index.js

@@ -1,8 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { PRESETS, PRESET_NAMES, parse, registerActorPack } from "@markdy/core";
-import { systemsPack } from "@markdy/stdlib-systems";
+import { parse } from "@markdy/core";
 import { createRequire } from "module";
 import { basename, dirname, extname, join, resolve, sep } from "path";
 import { fileURLToPath, pathToFileURL } from "url";
@@ -11,152 +10,126 @@ import { readdir, readFile, stat, writeFile } from "fs/promises";
 import { spawn } from "child_process";
 
 // src/format.ts
-var BARE_TOKEN_RE = /^[\p{L}\p{N}_.$#/+:-]+$/u;
-var MODIFIER_KEYS = ["scale", "rotate", "opacity", "size", "z"];
 function formatScene(ast) {
-  const sections = [];
-  sections.push(formatSceneHeader(ast));
-  const vars = Object.entries(ast.vars);
-  if (vars.length > 0) {
-    sections.push(vars.map(([name, value]) => `var ${name} = ${value}`).join("\n"));
-  }
-  if (ast.imports.length > 0) {
-    sections.push(ast.imports.map(formatImportDecl).join("\n"));
-  }
-  const assets = Object.entries(ast.assets);
-  if (assets.length > 0) {
-    sections.push(
-      assets.map(([name, def]) => `asset ${name} = ${def.type}(${formatToken(def.value)})`).join("\n")
-    );
-  }
-  const actors = Object.entries(ast.actors);
-  if (actors.length > 0) {
-    sections.push(actors.map(([name, actor]) => formatActorDecl(name, actor)).join("\n"));
-  }
-  const defs = Object.entries(ast.defs);
-  if (defs.length > 0) {
-    sections.push(defs.map(([name, def]) => formatTemplateDef(name, def)).join("\n\n"));
-  }
-  const seqs = Object.entries(ast.seqs);
-  if (seqs.length > 0) {
-    sections.push(seqs.map(([name, seq]) => formatSequenceDef(name, seq)).join("\n\n"));
-  }
-  const timeline = formatTimeline(ast);
-  if (timeline) {
-    sections.push(timeline);
-  }
-  return `${sections.filter(Boolean).join("\n\n")}
-`;
-}
-function formatSceneHeader(ast) {
-  const parts = [
-    `scene width=${formatNumber(ast.meta.width)}`,
-    `height=${formatNumber(ast.meta.height)}`,
-    `fps=${formatNumber(ast.meta.fps)}`,
-    `bg=${ast.meta.bg}`
-  ];
-  if (ast.meta.duration !== void 0) {
-    parts.push(`duration=${formatNumber(ast.meta.duration)}`);
-  }
-  return parts.join(" ");
-}
-function formatImportDecl(decl) {
-  return `import ${JSON.stringify(decl.path)} as ${decl.namespace}`;
-}
-function formatActorDecl(name, actor) {
-  const ctor = `${actor.type}(${actor.args.map(formatToken).join(", ")})`;
-  const position = actor.anchor ? `at ${actor.anchor}` : `at (${formatNumber(actor.x)}, ${formatNumber(actor.y)})`;
-  const modifiers = MODIFIER_KEYS.flatMap((key) => {
-    const value = actor[key];
-    return value === void 0 ? [] : [`${key}=${formatNumber(value)}`];
-  }).join(", ");
-  return modifiers.length > 0 ? `actor ${name} = ${ctor} ${position} with ${modifiers}` : `actor ${name} = ${ctor} ${position}`;
-}
-function formatTemplateDef(name, def) {
-  const args = def.bodyArgs.map(formatTemplateArg).join(", ");
-  return `def ${name}(${def.params.join(", ")}) {
-  ${def.actorType}(${args})
-}`;
-}
-function formatTemplateArg(arg) {
-  return arg.startsWith("${") && arg.endsWith("}") ? arg : formatToken(arg);
-}
-function formatSequenceDef(name, seq) {
-  const lines = seq.events.map((event) => {
-    const params = event.paramsRaw.trim();
-    const suffix = params ? `(${params})` : "()";
-    return `  @+${formatNumber(event.offset)}: $.${event.action}${suffix}`;
-  });
-  return `seq ${name}(${seq.params.join(", ")}) {
-${lines.join("\n")}
-}`;
-}
-function formatTimeline(ast) {
-  if (ast.events.length === 0 && ast.chapters.length === 0) {
-    return "";
-  }
-  const blocks = [];
-  const topLevelEvents = ast.events.filter((event) => event.chapter === void 0);
-  for (const event of topLevelEvents) {
-    blocks.push({ line: event.line, text: formatEvent(event) });
-  }
-  const chaptersByLine = [...ast.chapters].sort((a, b) => a.startLine - b.startLine);
-  for (let index = 0; index < chaptersByLine.length; index++) {
-    const chapter = chaptersByLine[index];
-    const nextStartLine = chaptersByLine[index + 1]?.startLine ?? Number.POSITIVE_INFINITY;
-    const events = ast.events.filter(
-      (event) => event.chapter === chapter.name && event.line > chapter.startLine && event.line < nextStartLine
-    ).sort((a, b) => a.line - b.line);
-    blocks.push({ line: chapter.startLine, text: formatChapter(chapter, events) });
-  }
-  return blocks.sort((a, b) => a.line - b.line).map((block) => block.text).join("\n\n");
-}
-function formatChapter(chapter, events) {
-  const body = events.length > 0 ? `
-${events.map((event) => `  ${formatEvent(event)}`).join("\n")}
-` : "\n";
-  return `scene ${JSON.stringify(chapter.name)} {${body}}`;
-}
-function formatEvent(event) {
-  const params = Object.entries(event.params).map(([key, value]) => `${key}=${formatParamValue(value)}`).join(", ");
-  return `@${formatNumber(event.time)}: ${event.actor}.${event.action}(${params})`;
-}
-function formatParamValue(value) {
-  if (Array.isArray(value)) {
-    return `(${value.map(formatTupleValue).join(", ")})`;
-  }
-  if (typeof value === "number") {
-    return formatNumber(value);
-  }
-  if (typeof value === "string") {
-    return formatToken(value);
+  const lines = [];
+  const sceneParts = [`scene`];
+  if (ast.meta.title) sceneParts.push(JSON.stringify(ast.meta.title));
+  sceneParts.push(`theme=${ast.meta.theme}`);
+  if (ast.meta.width !== 1280) sceneParts.push(`width=${ast.meta.width}`);
+  if (ast.meta.height !== 720) sceneParts.push(`height=${ast.meta.height}`);
+  if (ast.meta.fps !== 60) sceneParts.push(`fps=${ast.meta.fps}`);
+  if (ast.meta.duration !== void 0) sceneParts.push(`duration=${ast.meta.duration}`);
+  lines.push(sceneParts.join(" "));
+  if (ast.meta.direction !== "LR") {
+    lines.push(`layout ${ast.meta.direction}`);
+  }
+  for (const style of Object.values(ast.styles)) {
+    lines.push(formatStyle(style));
+  }
+  for (const node of Object.values(ast.nodes)) {
+    lines.push(formatNode(node));
+  }
+  for (const edge of ast.edges) {
+    lines.push(formatEdge(edge));
+  }
+  for (const group of Object.values(ast.groups)) {
+    lines.push(formatGroup(group));
+  }
+  for (const pattern of Object.values(ast.patterns)) {
+    lines.push(`pattern ${pattern.name}(${pattern.params.join(", ")}):`);
+    for (const cue of pattern.body) {
+      lines.push(`  ${formatCue(cue)}`);
+    }
+    lines.push("");
   }
-  if (typeof value === "boolean") {
-    return value ? "true" : "false";
+  for (const beat of ast.beats) {
+    lines.push(formatBeat(beat));
+    lines.push("");
   }
-  return JSON.stringify(value);
+  return `${lines.join("\n").trim()}
+`;
 }
-function formatTupleValue(value) {
-  if (typeof value === "number") return formatNumber(value);
-  if (typeof value === "string") return formatToken(value);
+function formatStyle(style) {
+  const props = Object.entries(style.props).map(([k, v]) => `${k}=${formatValue(v)}`).join(" ");
+  return `style ${style.name} = ${props}`;
+}
+function formatNode(node) {
+  let line = `${node.kind} ${node.id}`;
+  if (node.label !== node.id && node.label) line += ` ${JSON.stringify(node.label)}`;
+  if (node.style) line += ` style=${node.style}`;
+  return line;
+}
+function formatEdge(edge) {
+  const op = edge.kind === "request" ? "->" : edge.kind === "response" ? "<-" : edge.kind === "event" ? "~>" : "--";
+  const [left, right] = edge.kind === "response" ? [edge.to, edge.from] : [edge.from, edge.to];
+  let chain = `${left} ${op} ${right}`;
+  if (edge.label) chain += ` ${JSON.stringify(edge.label)}`;
+  return `edge ${edge.id}: ${chain}`;
+}
+function formatGroup(group) {
+  const label = group.label ? ` ${JSON.stringify(group.label)}` : "";
+  return `group ${group.id}${label}: ${group.members.join(" ")}`;
+}
+function formatBeat(beat) {
+  const label = beat.label ? ` ${JSON.stringify(beat.label)}` : "";
+  const lines = [`beat ${beat.name}${label}:`];
+  for (const cue of beat.cues) {
+    lines.push(`  ${formatCue(cue)}`);
+  }
+  return lines.join("\n");
+}
+function formatCue(cue) {
+  if (cue.kind === "parallel") {
+    return cue.cues.map(formatCue).join(" & ");
+  }
+  if (cue.kind === "flow") {
+    let chain = "";
+    for (let i = 0; i < cue.segments.length; i++) {
+      const seg = cue.segments[i];
+      const op = seg.op === "request" ? "->" : seg.op === "response" ? "<-" : seg.op === "event" ? "~>" : "--";
+      const [left, right] = seg.op === "response" ? [seg.to, seg.from] : [seg.from, seg.to];
+      if (i === 0) chain += left;
+      chain += ` ${op} ${right}`;
+      if (seg.label) chain += ` ${JSON.stringify(seg.label)}`;
+    }
+    if (cue.dur !== void 0) chain += ` dur=${cue.dur}s`;
+    return chain;
+  }
+  if (cue.kind === "show" || cue.kind === "hide") {
+    let line = `${cue.kind} ${cue.targets.join(" ")}`;
+    if (cue.kind === "show" && cue.stagger !== void 0) line += ` stagger=${cue.stagger}s`;
+    if (cue.dur !== void 0) line += ` dur=${cue.dur}s`;
+    return line;
+  }
+  if (cue.kind === "glow") {
+    let line = `glow ${cue.targets.join(" ")}`;
+    if (cue.color) line += ` color=${cue.color}`;
+    if (cue.strength !== void 0) line += ` strength=${cue.strength}`;
+    if (cue.dur !== void 0) line += ` dur=${cue.dur}s`;
+    return line;
+  }
+  if (cue.kind === "focus") {
+    let line = `focus ${cue.targets.join(" ")}`;
+    if (cue.zoom !== void 0) line += ` zoom=${cue.zoom}`;
+    if (cue.dur !== void 0) line += ` dur=${cue.dur}s`;
+    return line;
+  }
+  if (cue.kind === "use") {
+    const args = Object.entries(cue.args).map(([k, v]) => k.startsWith("__pos_") ? v : `${k}=${v}`).join(", ");
+    return `use ${cue.pattern}(${args})`;
+  }
+  return "";
+}
+function formatValue(value) {
+  if (typeof value === "number") return String(value);
+  if (typeof value === "string") return value;
   return JSON.stringify(value);
 }
-function formatToken(value) {
-  return BARE_TOKEN_RE.test(value) ? value : JSON.stringify(value);
-}
-function formatNumber(value) {
-  return Number.isInteger(value) ? String(value) : String(round3(value));
-}
-function round3(value) {
-  return Math.round(value * 1e3) / 1e3;
-}
 
 // src/index.ts
 var DEFAULT_PORT = 4242;
-var IMPORT_RE = /^import\s+"([^"]+)"\s+as\s+(\w+)\s*$/;
 var MARKDY_EXT = ".markdy";
 var PACKAGE_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
-registerActorPack(systemsPack);
 async function runCli(argv, io = defaultIo(), runtime = defaultRuntime()) {
   const parsed = parseArgv(argv);
   if (hasFlag(parsed, "help")) {
@@ -205,7 +178,7 @@ async function lintCommand(parsed, io) {
     try {
       const scene = await loadSceneFromFile(file, cache);
       io.stdout(`OK   ${file}`);
-      warningCount += printWarnings(scene.ast.warnings, file, io);
+      warningCount += printWarnings(scene.ast.diagnostics, file, io);
     } catch (error) {
       errorCount++;
       io.stderr(`FAIL ${file}`);
@@ -302,37 +275,23 @@ async function explainCommand(parsed, io) {
   const summary = [
     `File: ${scene.filePath}`,
     `Viewport: ${scene.ast.meta.width}\xD7${scene.ast.meta.height} @ ${scene.ast.meta.fps}fps`,
-    `Background: ${scene.ast.meta.bg}`,
-    `Duration: ${scene.ast.meta.duration ?? 0}s`,
-    `Actors: ${Object.keys(scene.ast.actors).length}`,
-    `Events: ${scene.ast.events.length}`,
-    `Chapters: ${scene.ast.chapters.length > 0 ? scene.ast.chapters.map((chapter) => chapter.name).join(", ") : "(none)"}`,
-    `Imports: ${scene.ast.imports.length > 0 ? scene.ast.imports.map((item) => `${item.namespace} -> ${item.path}`).join(", ") : "(none)"}`,
-    `Warnings: ${scene.ast.warnings.length}`
+    `Theme: ${scene.ast.meta.theme}`,
+    `Duration: ${scene.ast.meta.duration ?? "(auto)"}`,
+    `Nodes: ${Object.keys(scene.ast.nodes).length}`,
+    `Beats: ${scene.ast.beats.map((b) => b.name).join(", ") || "(none)"}`,
+    `Diagnostics: ${scene.ast.diagnostics.length}`
   ];
   io.stdout(summary.join("\n"));
-  if (scene.ast.warnings.length > 0) {
-    printWarnings(scene.ast.warnings, scene.filePath, io);
+  if (scene.ast.diagnostics.length > 0) {
+    printWarnings(scene.ast.diagnostics, scene.filePath, io);
   }
   return { exitCode: 0 };
 }
 async function newCommand(parsed, io) {
-  const presetOrTarget = parsed.positionals[0];
-  const second = parsed.positionals[1];
+  const target = parsed.positionals[0] ?? "scene.markdy";
   const force = hasFlag(parsed, "force");
-  let presetName = "basic";
-  let target = "scene.markdy";
-  if (presetOrTarget) {
-    if (PRESET_NAMES.includes(presetOrTarget)) {
-      presetName = presetOrTarget;
-      target = second ?? target;
-    } else {
-      target = presetOrTarget;
-    }
-  }
   const resolvedTarget = resolve(target);
-  const content = presetName === "basic" ? defaultSceneTemplate() : `preset ${presetName}
-`;
+  const content = defaultSceneTemplate();
   if (!force && await exists(resolvedTarget)) {
     io.stderr(`markdy new: target already exists: ${resolvedTarget} (pass --force to overwrite)`);
     return { exitCode: 1 };
@@ -395,10 +354,9 @@ async function checkAllCommand(parsed, io) {
 async function launchPlayground(parsed, io, runtime, scene) {
   const portFlag = getStringFlag(parsed, "port");
   const preferredPort = portFlag ? Number(portFlag) : DEFAULT_PORT;
-  const code = scene?.source ?? PRESETS.explainer([]);
-  const imports = scene?.imports ?? {};
+  const code = scene?.source ?? defaultSceneTemplate();
   const sourcePath = scene?.filePath;
-  const server = await startPreviewServer(code, imports, sourcePath, preferredPort);
+  const server = await startPreviewServer(code, sourcePath, preferredPort);
   const address = server.address();
   const port = typeof address === "object" && address ? address.port : preferredPort;
   const url = `http://127.0.0.1:${port}`;
@@ -408,10 +366,10 @@ async function launchPlayground(parsed, io, runtime, scene) {
   }
   return { exitCode: 0, server };
 }
-async function startPreviewServer(code, imports, sourcePath, preferredPort) {
+async function startPreviewServer(code, sourcePath, preferredPort) {
   const coreDist = resolvePackageDist("@markdy/core");
   const rendererDist = resolvePackageDist("@markdy/renderer-dom");
-  const html = buildPlaygroundHtml(code, imports, sourcePath);
+  const html = buildPlaygroundHtml(code, sourcePath);
   const server = createServer(async (request, response) => {
     try {
       const requestUrl = new URL(request.url ?? "/", "http://127.0.0.1");
@@ -470,32 +428,11 @@ async function loadSceneFromFile(filePath, cache = /* @__PURE__ */ new Map(), st
   const source = await readFile(resolvedPath, "utf8").catch((error) => {
     throw new Error(`Unable to read ${resolvedPath}: ${describeError(error)}`);
   });
-  const imports = await resolveSceneImports(source, resolvedPath, cache, [...stack, resolvedPath]);
-  const ast = parse(source, Object.keys(imports).length > 0 ? { imports } : void 0);
-  const loaded = { filePath: resolvedPath, source, ast, imports };
+  const ast = parse(source);
+  const loaded = { filePath: resolvedPath, source, ast };
   cache.set(resolvedPath, loaded);
   return loaded;
 }
-async function resolveSceneImports(source, filePath, cache, stack) {
-  const imports = {};
-  for (const declaration of scanImports(source)) {
-    const childPath = resolve(dirname(filePath), declaration.path);
-    const child = await loadSceneFromFile(childPath, cache, stack);
-    imports[declaration.namespace] = child.ast;
-  }
-  return imports;
-}
-function scanImports(source) {
-  const imports = [];
-  for (const line of source.split(/\r?\n/)) {
-    const trimmed = line.trim();
-    if (!trimmed.startsWith("import ")) continue;
-    const match = IMPORT_RE.exec(trimmed);
-    if (!match) continue;
-    imports.push({ path: match[1], namespace: match[2] });
-  }
-  return imports;
-}
 async function collectSceneFiles(inputs) {
   const candidates = inputs.length > 0 ? inputs : [process.cwd()];
   const out = /* @__PURE__ */ new Set();
@@ -533,7 +470,7 @@ async function walkMarkdyFiles(root) {
   }
   return files;
 }
-function buildPlaygroundHtml(code, imports, sourcePath) {
+function buildPlaygroundHtml(code, sourcePath) {
   return `<!doctype html>
 <html lang="en">
   <head>
@@ -629,7 +566,7 @@ function buildPlaygroundHtml(code, imports, sourcePath) {
         <strong>Markdy Playground</strong>
         <div><code>${escapeHtml(sourcePath ?? "scratch scene")}</code></div>
       </div>
-      <div>Resolved imports: ${Object.keys(imports).length}</div>
+      <div>MarkdyScript 0.8 diagram playground</div>
     </header>
     <main>
       <section class="editor">
@@ -648,7 +585,6 @@ function buildPlaygroundHtml(code, imports, sourcePath) {
     <script type="module">
       import { createPlayer } from "@markdy/renderer-dom";
 
-      const imports = ${JSON.stringify(imports)};
       const textarea = document.getElementById("code");
       const viewport = document.getElementById("viewport");
       const warnings = document.getElementById("warnings");
@@ -665,10 +601,9 @@ function buildPlaygroundHtml(code, imports, sourcePath) {
           player = createPlayer({
             container: viewport,
             code: textarea.value,
-            imports,
             onWarning(warning) {
               const item = document.createElement("li");
-              item.textContent = \`line \${warning.line}: \${warning.message} (\${warning.kind})\`;
+              item.textContent = \`line \${warning.line}: \${warning.message}\`;
               warnings.appendChild(item);
             }
           });
@@ -731,9 +666,8 @@ async function buildStandaloneHtml(scene) {
       createPlayer({
         container: document.getElementById("app"),
         code: ${JSON.stringify(scene.source)},
-        imports: ${JSON.stringify(scene.imports)},
         onWarning(warning) {
-          console.warn(\`[markdy] line \${warning.line}: \${warning.message} (\${warning.kind})\`);
+          console.warn(\`[markdy] line \${warning.line}: \${warning.message}\`);
         }
       });
     </script>
@@ -750,12 +684,10 @@ function helpText() {
     "  markdy fmt <file-or-dir> [--write | --check]",
     "  markdy render <file.markdy> [--out file.html] [--port 4242] [--no-open]",
     "  markdy explain <file.markdy> [--json]",
-    "  markdy new [preset-name] [target.markdy] [--force]",
+    "  markdy new [target.markdy] [--force]",
     "  markdy docs [--open]",
     "  markdy ai [--open]",
-    "  markdy check-all [dir] [--strict]",
-    "",
-    `Built-in presets: ${PRESET_NAMES.join(", ")}`
+    "  markdy check-all [dir] [--strict]"
   ].join("\n");
 }
 function parseArgv(argv) {
@@ -824,10 +756,10 @@ function getStringFlag(parsed, name) {
   return typeof value === "string" ? value : void 0;
 }
 function printWarnings(warnings, file, io) {
-  for (const warning of warnings) {
-    io.stderr(`WARN ${file}:${warning.line} ${warning.kind} ${warning.message}`);
+  for (const warning of warnings.filter((w) => w.severity === "warning")) {
+    io.stderr(`WARN ${file}:${warning.line} ${warning.message}`);
   }
-  return warnings.length;
+  return warnings.filter((w) => w.severity === "warning").length;
 }
 function stableStringify(value) {
   const seen = /* @__PURE__ */ new WeakSet();
@@ -888,14 +820,16 @@ function describeError(error) {
 }
 function defaultSceneTemplate() {
   return [
-    "scene width=960 height=540 fps=30 bg=#0d1117",
+    'scene "My Architecture" theme=midnight',
+    "layout LR",
     "",
-    'actor title = caption("hello, markdy") at top',
-    "actor hero = figure(#c68642, m, \u{1F60E}) at (480, 360)",
+    "browser Client",
+    "service API",
+    "database DB",
     "",
-    "@0.0: title.fade_in(dur=0.4)",
-    "@0.4: hero.enter(from=bottom, dur=0.5)",
-    '@1.2: hero.say("ship it", dur=1.4)',
+    "beat intro:",
+    "  show $nodes",
+    '  Client -> API "GET /health" -> DB "lookup"',
     ""
   ].join("\n");
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markdy/cli",
-  "version": "0.7.28",
+  "version": "0.8.0",
   "description": "First-party CLI for MarkdyScript: lint, format, explain, render, and local playground tooling.",
   "license": "MIT",
   "type": "module",
@@ -41,9 +41,9 @@
     "access": "public"
   },
   "dependencies": {
-    "@markdy/core": "0.7.28",
-    "@markdy/renderer-dom": "0.7.28",
-    "@markdy/stdlib-systems": "0.7.28"
+    "@markdy/core": "0.8.0",
+    "@markdy/stdlib-systems": "0.8.0",
+    "@markdy/renderer-dom": "0.8.0"
   },
   "devDependencies": {
     "@types/node": "^25.9.5",