@hachej/boring-deck 0.1.20

package/dist/shared/index.d.ts

@@ -0,0 +1,17 @@
+import { P as ParsedDeck } from '../types-Dt_A9RNg.js';
+export { C as CreateDeckPluginOptions, b as DeckError, c as DeckSegment, D as DeckThemeOptions, a as DeckWidgetDefinition, d as DeckWidgetRenderContext, e as DeckWidgetRenderProps, f as ParsedSlide } from '../types-Dt_A9RNg.js';
+import 'react';
+
+declare const DECK_PLUGIN_ID = "deck";
+declare const DECK_PANEL_ID = "deck";
+declare const DECK_LABEL = "Deck";
+declare const DECK_PATH_PREFIX = "deck/";
+
+declare function normalizeDeckPath(path: string): string;
+declare function isDeckMarkdownPath(path: string, pathPrefix?: string): boolean;
+
+declare function splitSlides(input: string): string[];
+declare function parseWidgetAttrs(raw: string): Record<string, string>;
+declare function parseDeckMarkdown(input: string): ParsedDeck;
+
+export { DECK_LABEL, DECK_PANEL_ID, DECK_PATH_PREFIX, DECK_PLUGIN_ID, ParsedDeck, isDeckMarkdownPath, normalizeDeckPath, parseDeckMarkdown, parseWidgetAttrs, splitSlides };

package/dist/shared/index.js

@@ -0,0 +1,265 @@
+// src/shared/constants.ts
+var DECK_PLUGIN_ID = "deck";
+var DECK_PANEL_ID = "deck";
+var DECK_LABEL = "Deck";
+var DECK_PATH_PREFIX = "deck/";
+
+// src/shared/path.ts
+function normalizeDeckPath(path) {
+  const trimmed = path.trim().replace(/\\/g, "/");
+  const noLeadingDot = trimmed.replace(/^\.\//, "");
+  return noLeadingDot.replace(/\/+/g, "/");
+}
+function isDeckMarkdownPath(path, pathPrefix = "deck/") {
+  const normalized = normalizeDeckPath(path);
+  const normalizedPathPrefix = normalizeDeckPath(pathPrefix);
+  const normalizedPrefix = normalizedPathPrefix.endsWith("/") ? normalizedPathPrefix : `${normalizedPathPrefix}/`;
+  if (!normalized.endsWith(".md")) return false;
+  if (normalized.startsWith("/") || /^[A-Za-z]:\//.test(normalized)) return false;
+  if (normalized.split("/").some((segment) => segment === "..")) return false;
+  return normalized.startsWith(normalizedPrefix);
+}
+
+// src/shared/parser.ts
+var TITLE_RX = /^##\s+title:\s*(.+)$/i;
+var YAML_TITLE_RX = /^title:\s*(.+)$/i;
+var YAML_KV_RX = /^[A-Za-z][\w-]*:\s*.*$/;
+var FENCE_RX = /^(```|~~~)/;
+var WIDGET_OPEN = "{{";
+var WIDGET_CLOSE = "}}";
+var WIDGET_NAME_RX = /^[A-Za-z][\w-]*$/;
+var ATTR_KEY_RX = /^[A-Za-z][\w-]*$/;
+function splitSlides(input) {
+  const slides = [];
+  let current = [];
+  let fenceMarker = null;
+  for (const line of input.split("\n")) {
+    const trimmed = line.trim();
+    const fence = FENCE_RX.exec(trimmed);
+    if (fence) {
+      if (fenceMarker === fence[1]) fenceMarker = null;
+      else if (fenceMarker === null) fenceMarker = fence[1];
+    }
+    if (fenceMarker === null && trimmed === "---") {
+      slides.push(current.join("\n").trim());
+      current = [];
+      continue;
+    }
+    current.push(line);
+  }
+  slides.push(current.join("\n").trim());
+  const nonEmpty = slides.filter((slide) => slide.length > 0);
+  if (nonEmpty.length > 0) return nonEmpty;
+  return [""];
+}
+function parseWidgetAttrs(raw) {
+  const parsed = tryParseWidgetAttrs(raw);
+  if (parsed == null) throw new Error(`Malformed widget attrs: ${raw}`);
+  return parsed;
+}
+function parseDeckMarkdown(input) {
+  const lines = input.split("\n");
+  let start = 0;
+  while (start < lines.length && lines[start].trim() === "") start += 1;
+  let title = stripYamlFrontmatter(lines, start);
+  while (start < lines.length && lines[start].trim() === "") start += 1;
+  if (!title && lines[start]?.trim() === "---") {
+    lines.splice(start, 1);
+  }
+  let sawFence = false;
+  for (let i = 0; i < lines.length; i += 1) {
+    const trimmed = lines[i].trim();
+    if (FENCE_RX.test(trimmed)) sawFence = !sawFence;
+    if (!sawFence && trimmed === "---") break;
+    const match = TITLE_RX.exec(trimmed);
+    if (match) {
+      title = title ?? stripQuotes(match[1].trim());
+      lines.splice(i, 1);
+      if (lines[i]?.trim() === "") lines.splice(i, 1);
+      break;
+    }
+  }
+  const slides = splitSlides(lines.join("\n")).map((raw, index, all) => ({
+    index,
+    raw,
+    segments: tokenize(raw, index, all.length)
+  }));
+  return title ? { title, slides } : { slides };
+}
+function stripYamlFrontmatter(lines, start) {
+  if (lines[start]?.trim() !== "---") return void 0;
+  let end = -1;
+  for (let i = start + 1; i < lines.length; i += 1) {
+    if (lines[i].trim() === "---") {
+      end = i;
+      break;
+    }
+  }
+  if (end === -1) return void 0;
+  const fields = lines.slice(start + 1, end);
+  if (fields.length === 0 || !fields.every((line) => YAML_KV_RX.test(line.trim()))) return void 0;
+  const titleLine = fields.find((line) => YAML_TITLE_RX.test(line.trim()));
+  const title = titleLine?.trim().match(YAML_TITLE_RX)?.[1]?.trim();
+  lines.splice(start, end - start + 1);
+  while (start < lines.length && lines[start]?.trim() === "") lines.splice(start, 1);
+  return title ? stripQuotes(title) : void 0;
+}
+function tokenize(markdown, slideIndex, slideCount) {
+  const segments = [];
+  const lines = markdown.split("\n");
+  let fenceMarker = null;
+  for (let lineIndex = 0; lineIndex < lines.length; lineIndex += 1) {
+    const line = lines[lineIndex];
+    const trimmed = line.trim();
+    const fence = FENCE_RX.exec(trimmed);
+    if (fence) {
+      if (fenceMarker === fence[1]) fenceMarker = null;
+      else if (fenceMarker === null) fenceMarker = fence[1];
+      pushMarkdown(segments, line);
+      if (lineIndex < lines.length - 1) pushMarkdown(segments, "\n");
+      continue;
+    }
+    if (fenceMarker) {
+      pushMarkdown(segments, line);
+      if (lineIndex < lines.length - 1) pushMarkdown(segments, "\n");
+      continue;
+    }
+    for (const segment of tokenizeLine(line, slideIndex, slideCount)) {
+      if (segment.type === "markdown") pushMarkdown(segments, segment.text);
+      else segments.push(segment);
+    }
+    if (lineIndex < lines.length - 1) pushMarkdown(segments, "\n");
+  }
+  return segments.length > 0 ? segments : [{ type: "markdown", text: "" }];
+}
+function tokenizeLine(line, _slideIndex, _slideCount) {
+  const segments = [];
+  let markdown = "";
+  let i = 0;
+  while (i < line.length) {
+    if (line[i] === "`") {
+      const tickCount = countRepeated(line, i, "`");
+      const close = line.indexOf("`".repeat(tickCount), i + tickCount);
+      if (close === -1) {
+        markdown += line.slice(i);
+        break;
+      }
+      markdown += line.slice(i, close + tickCount);
+      i = close + tickCount;
+      continue;
+    }
+    if (line.startsWith(WIDGET_OPEN, i)) {
+      const close = line.indexOf(WIDGET_CLOSE, i + WIDGET_OPEN.length);
+      if (close === -1) {
+        markdown += line.slice(i);
+        break;
+      }
+      const raw = line.slice(i, close + WIDGET_CLOSE.length);
+      const parsed = parseWidget(raw, line);
+      if (!parsed) {
+        markdown += raw;
+        i = close + WIDGET_CLOSE.length;
+        continue;
+      }
+      if (markdown) {
+        segments.push({ type: "markdown", text: markdown });
+        markdown = "";
+      }
+      segments.push(parsed);
+      i = close + WIDGET_CLOSE.length;
+      continue;
+    }
+    markdown += line[i];
+    i += 1;
+  }
+  if (markdown) segments.push({ type: "markdown", text: markdown });
+  return segments;
+}
+function parseWidget(raw, line) {
+  const inner = raw.slice(WIDGET_OPEN.length, -WIDGET_CLOSE.length).trim();
+  if (!inner) return null;
+  const firstSpace = inner.search(/\s/);
+  const name = firstSpace === -1 ? inner : inner.slice(0, firstSpace);
+  const attrsRaw = firstSpace === -1 ? "" : inner.slice(firstSpace).trim();
+  if (!WIDGET_NAME_RX.test(name)) return null;
+  let attrs;
+  try {
+    attrs = attrsRaw ? parseWidgetAttrs(attrsRaw) : {};
+  } catch {
+    return null;
+  }
+  return {
+    type: "widget",
+    name,
+    attrs,
+    raw,
+    position: line.trim() === raw.trim() ? "block" : "inline"
+  };
+}
+function tryParseWidgetAttrs(raw) {
+  const attrs = {};
+  let i = 0;
+  while (i < raw.length) {
+    while (i < raw.length && /\s/.test(raw[i])) i += 1;
+    if (i >= raw.length) break;
+    const keyStart = i;
+    while (i < raw.length && /[A-Za-z0-9_-]/.test(raw[i])) i += 1;
+    const key = raw.slice(keyStart, i);
+    if (!ATTR_KEY_RX.test(key)) return null;
+    while (i < raw.length && /\s/.test(raw[i])) i += 1;
+    if (raw[i] !== "=") return null;
+    i += 1;
+    while (i < raw.length && /\s/.test(raw[i])) i += 1;
+    if (raw[i] !== '"') return null;
+    i += 1;
+    let value = "";
+    let closed = false;
+    while (i < raw.length) {
+      const char = raw[i];
+      if (char === "\\") {
+        const next = raw[i + 1];
+        if (next === void 0) return null;
+        value += next;
+        i += 2;
+        continue;
+      }
+      if (char === '"') {
+        i += 1;
+        closed = true;
+        break;
+      }
+      value += char;
+      i += 1;
+    }
+    if (!closed) return null;
+    attrs[key] = value;
+  }
+  while (i < raw.length && /\s/.test(raw[i])) i += 1;
+  if (i !== raw.length) return null;
+  return attrs;
+}
+function pushMarkdown(segments, text) {
+  if (text.length === 0) return;
+  const last = segments[segments.length - 1];
+  if (last?.type === "markdown") last.text += text;
+  else segments.push({ type: "markdown", text });
+}
+function stripQuotes(value) {
+  return value.replace(/^['"]|['"]$/g, "");
+}
+function countRepeated(value, start, needle) {
+  let count = 0;
+  while (value[start + count] === needle) count += 1;
+  return count;
+}
+export {
+  DECK_LABEL,
+  DECK_PANEL_ID,
+  DECK_PATH_PREFIX,
+  DECK_PLUGIN_ID,
+  isDeckMarkdownPath,
+  normalizeDeckPath,
+  parseDeckMarkdown,
+  parseWidgetAttrs,
+  splitSlides
+};

package/dist/types-Dt_A9RNg.d.ts

@@ -0,0 +1,57 @@
+import { ReactNode } from 'react';
+
+interface DeckError {
+    type: "storage" | "parse" | "render" | "widget" | "conflict";
+    path?: string;
+    message: string;
+    cause?: unknown;
+}
+interface DeckThemeOptions {
+    aspectRatio?: "16:9" | "4:3";
+    className?: string;
+    slideClassName?: string;
+}
+interface ParsedDeck {
+    title?: string;
+    slides: ParsedSlide[];
+}
+interface ParsedSlide {
+    index: number;
+    raw: string;
+    segments: DeckSegment[];
+}
+type DeckSegment = {
+    type: "markdown";
+    text: string;
+} | {
+    type: "widget";
+    name: string;
+    attrs: Record<string, string>;
+    raw: string;
+    position: "block" | "inline";
+};
+interface DeckWidgetRenderContext {
+    path?: string;
+    slideIndex: number;
+    slideCount: number;
+    mode: "read" | "edit" | "present";
+}
+interface DeckWidgetRenderProps<TAttrs = Record<string, string>> {
+    attrs: TAttrs;
+    rawAttrs: Record<string, string>;
+    context: DeckWidgetRenderContext;
+}
+interface DeckWidgetDefinition<TAttrs = Record<string, string>> {
+    name: string;
+    display?: "block" | "inline";
+    parse?: (attrs: Record<string, string>) => TAttrs;
+    render: (props: DeckWidgetRenderProps<TAttrs>) => ReactNode;
+}
+interface CreateDeckPluginOptions {
+    pathPrefix?: string;
+    widgets?: DeckWidgetDefinition[];
+    theme?: DeckThemeOptions;
+    onError?: (error: DeckError) => void;
+}
+
+export type { CreateDeckPluginOptions as C, DeckThemeOptions as D, ParsedDeck as P, DeckWidgetDefinition as a, DeckError as b, DeckSegment as c, DeckWidgetRenderContext as d, DeckWidgetRenderProps as e, ParsedSlide as f };

package/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "@hachej/boring-deck",
+  "version": "0.1.20",
+  "type": "module",
+  "license": "MIT",
+  "description": "Front-only markdown deck plugin scaffold for Boring workspace.",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/hachej/boring-ui"
+  },
+  "homepage": "https://github.com/hachej/boring-ui",
+  "boring": {
+    "label": "Deck",
+    "front": "dist/front/index.js"
+  },
+  "pi": {
+    "skills": [
+      "skills/deck-authoring"
+    ],
+    "systemPrompt": "Deck files live under deck/*.md. When the user asks to open a deck, create or locate the deck markdown file, then call exec_ui with { kind: 'openSurface', params: { kind: 'workspace.open.path', target: '<deck/path.md>' } }. Use the deck-authoring skill when writing or editing deck content."
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "skills",
+    "README.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/front/index.d.ts",
+      "import": "./dist/front/index.js"
+    },
+    "./front": {
+      "types": "./dist/front/index.d.ts",
+      "import": "./dist/front/index.js"
+    },
+    "./shared": {
+      "types": "./dist/shared/index.d.ts",
+      "import": "./dist/shared/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "sideEffects": false,
+  "dependencies": {
+    "@hachej/boring-ui-kit": "workspace:*",
+    "lucide-react": "^1.8.0",
+    "react-markdown": "^10.1.0",
+    "remark-gfm": "^4.0.1"
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run --passWithNoTests",
+    "lint": "pnpm run typecheck",
+    "clean": "rm -rf dist .tsbuildinfo"
+  },
+  "peerDependencies": {
+    "@hachej/boring-workspace": "workspace:*",
+    "react": "^18.0.0 || ^19.0.0",
+    "react-dom": "^18.0.0 || ^19.0.0"
+  },
+  "devDependencies": {
+    "@hachej/boring-workspace": "workspace:*",
+    "@testing-library/jest-dom": "^6.9.1",
+    "@testing-library/react": "^16.3.2",
+    "@types/react": "^19.0.0",
+    "@types/react-dom": "^19.0.0",
+    "@vitejs/plugin-react": "^4.0.0",
+    "jsdom": "^29.0.2",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.4.0",
+    "vitest": "^3.1.3"
+  }
+}

package/skills/deck-authoring/SKILL.md

@@ -0,0 +1,73 @@
+---
+description: Author, edit, or open markdown slide decks in Boring workspaces.
+---
+
+# deck-authoring
+
+Use this skill when authoring or editing markdown slide decks for
+`@hachej/boring-deck`.
+
+## File location and opening decks
+
+- deck files live under `deck/*.md` by default
+- the host app may configure a different prefix, but you should preserve the
+  existing project convention you see in the workspace
+- when the user says “open me a deck” or asks to view a deck, do not say you
+  lack UI tools if `exec_ui` is available; create or locate the deck markdown
+  file, then call:
+
+```json
+{
+  "kind": "openSurface",
+  "params": {
+    "kind": "workspace.open.path",
+    "target": "deck/intro.md"
+  }
+}
+```
+
+- use the exact deck path as `target`; the deck plugin's surface resolver opens
+  matching markdown paths in the deck panel
+
+## Slide structure
+
+- write decks as normal markdown
+- `---` on its own line splits slides
+- keep one deck-wide canvas in mind (`16:9` by default; some hosts use `4:3`)
+- slides should stay concise and presentation-friendly
+
+## Widget syntax
+
+Custom components use moustache syntax:
+
+```md
+{{WidgetName key="value"}}
+```
+
+Examples:
+
+```md
+Welcome {{Badge text="draft"}}
+
+{{Kpi label="Revenue" value="$12.4M"}}
+```
+
+Rules:
+- preserve any existing host-provided widget names and attrs
+- do not silently rewrite host-specific widget syntax into a different format
+- keep inline widgets inline when they appear inside a sentence or paragraph
+
+## Authoring guidance
+
+- prefer short slide titles and tight bullet lists
+- avoid wall-of-text slides
+- keep markdown valid and simple
+- use fenced code blocks for code samples
+- do not use MDX or raw HTML as a replacement for widgets
+
+## Safety / compatibility
+
+- preserve existing slide separators when editing an existing deck
+- do not delete custom widgets just because you do not understand them
+- if a deck already has app-specific components, keep their syntax intact unless
+  the user explicitly asks for a migration