dreamcontext 0.5.4 → 0.7.0

package/dist/skill-packs/catalog.json

@@ -352,6 +352,50 @@
         "security"
       ],
       "alwaysApply": false
+    },
+    {
+      "name": "excalidraw",
+      "file": "excalidraw/SKILL.md",
+      "description": "Generate or extend Obsidian Excalidraw (.excalidraw.md) boards — lay out images/screenshots, text, shapes, arrows, frames, lanes and grids — by writing a small JSON spec and running a deterministic script that emits valid plugin markup (near-zero tokens, always renders). Embeds local images via the plugin's sha1 wikilink trick (no base64). Triggers: 'draw this in excalidraw', 'make an excalidraw board', 'excalidraw diagram', 'funnel map board', 'embed screenshots into excalidraw', 'excalidraw çiz', 'excalidraw board oluştur'.",
+      "tags": [
+        "excalidraw",
+        "obsidian",
+        "diagram",
+        "board",
+        "visualization",
+        "screenshots",
+        "funnel-map",
+        "drawing"
+      ],
+      "alwaysApply": false,
+      "bundleDir": true
+    },
+    {
+      "name": "video-watching",
+      "file": "video-watching/SKILL.md",
+      "description": "Load when the user hands over a video file/link or asks to watch/analyze a video, extract a transcript, or 'bu videoda ne var'. Turns a video into a time-mapped transcript with on-screen visuals (slides, UI, charts, text) described inline, then reasons about it. Triggers: 'watch this video', 'videoyu izle/analiz et', 'transkript çıkar', 'video transcript'.",
+      "tags": [
+        "video",
+        "transcript",
+        "whisper",
+        "ffmpeg",
+        "frames",
+        "ocr",
+        "marketing-teardown",
+        "media"
+      ],
+      "alwaysApply": false,
+      "bundleDir": true,
+      "requiresBinaries": [
+        "whisper-cpp",
+        "ffmpeg",
+        "yt-dlp (remote links only)"
+      ],
+      "crossPackDeps": [
+        "growth (marketing-video teardown handoff)",
+        "meta-marketing (ad-creative teardown handoff)",
+        "design/onboarding-design (app-demo / FTE reconstruction handoff)"
+      ]
     }
   ],
   "agents": [

package/dist/skill-packs/excalidraw/SKILL.md

@@ -0,0 +1,202 @@
+---
+name: excalidraw
+description: >-
+  Generate or extend Obsidian Excalidraw (.excalidraw.md) boards in this vault — lay out
+  images/screenshots, text labels, shapes, arrows, frames, lanes and grids — by writing a small
+  JSON spec and letting a deterministic script emit valid plugin markup (so it costs ~no tokens and
+  always renders). Embeds local images via the plugin's sha1 wikilink trick (no base64). Triggers:
+  '/excalidraw', 'draw this in excalidraw', 'make an excalidraw board', 'excalidraw diagram',
+  'funnel map board', 'embed screenshots into excalidraw', 'add images to an excalidraw file',
+  'excalidraw çiz', 'excalidraw board oluştur', 'ekran görüntülerini excalidraw a ekle'.
+---
+
+# Excalidraw board generator (Obsidian)
+
+Write `.excalidraw.md` files that render natively in this vault's Obsidian Excalidraw plugin.
+**Do not hand-author the scene JSON.** Build a small spec and run the generator — it produces the
+frontmatter, `## Text Elements`, `## Embedded Files`, and the `%% ## Drawing … %%` JSON, with
+correct sha1 image links, fractional z-indices, and deterministic seeds (clean git diffs).
+
+## The one trick that makes images work
+An image element references `fileId` = **sha1 of the image file**. The `## Embedded Files` section
+maps `<sha1>: [[image.png]]`. The plugin resolves the picture from the vault via that wikilink —
+**no base64 needed.** The generator computes the sha1 and writes both sides for you.
+
+## Usage
+
+### CLI (most common)
+```bash
+node .claude/skills/excalidraw/scripts/build_excalidraw.js <spec.json> [--out <path.excalidraw.md>]
+```
+Write a spec JSON, then run it. The script prints `elements/images/texts` counts on success.
+
+### JS API (for pipelines that generate many boards)
+```js
+const path = require('path');
+// skill lives at <project>/.claude/skills/excalidraw/ — adjust leading ../ count to match your script's depth from project root
+const { buildExcalidraw, lane, grid } = require(path.resolve(__dirname, '../.claude/skills/excalidraw/scripts/build_excalidraw.js'));
+buildExcalidraw({ out: path.resolve(__dirname, '../boards/Board.excalidraw.md'), elements: [ ...lane({ title, images, x, y, thumbW }) ] });
+```
+
+## File layout
+
+### Single board (default)
+Keep the spec next to the generated board but clearly separated:
+```
+boards/
+├── MyBoard.excalidraw.md      ← generated deliverable; do not hand-edit
+└── _spec/
+    └── MyBoard.json           ← source of truth; edit this, then regenerate
+```
+The `.excalidraw.md` is **disposable** — it is fully derived from the spec. If the two ever
+disagree, the spec wins. Commit both (the board for Obsidian/GitHub preview, the spec for
+reproducibility), but only edit the spec.
+
+### Multi-board pipeline
+When a single generator produces several boards, isolate it in a `pipeline/` folder so the
+deliverable boards stay at the top of the project and are easy to open in Obsidian:
+```
+boards/
+├── Overview.excalidraw.md     ← generated
+├── Funnel.excalidraw.md       ← generated
+├── Pricing.excalidraw.md      ← generated
+└── pipeline/
+    ├── generate.js            ← single regen entrypoint: `node pipeline/generate.js`
+    ├── shared-style.js        ← shared palette / helpers
+    └── spec/
+        ├── Overview.json      ← source spec for Overview board
+        ├── Funnel.json        ← source spec for Funnel board
+        └── Pricing.json       ← source spec for Pricing board
+```
+- **Generated files** (`*.excalidraw.md`) live one level above `pipeline/` — open them in Obsidian without navigating into a sub-folder.
+- **Source specs** live in `pipeline/spec/` — one JSON per board.
+- **Single entrypoint**: `node pipeline/generate.js` rebuilds every board. No per-board manual commands.
+
+### Many boards from shared data (recipe)
+Use this pattern when multiple boards pull from the same data set (e.g. one board per product, per region, or per funnel step):
+
+```js
+// pipeline/generate.js  (lives at boards/pipeline/generate.js)
+const path = require('path');
+const ROOT  = path.resolve(__dirname, '..');          // boards/ directory
+// ../../ = project root (boards/ → project/); adjust if boards/ is nested deeper
+const { buildExcalidraw, lane } = require(path.resolve(__dirname, '../../.claude/skills/excalidraw/scripts/build_excalidraw.js'));
+const style  = require(path.resolve(__dirname, 'shared-style.js'));
+const items  = require(path.resolve(__dirname, 'spec/items.json'));  // shared data
+
+for (const item of items) {
+  const elements = style.buildItemBoard(item);        // per-item spec logic
+  buildExcalidraw({
+    out: path.resolve(ROOT, `${item.slug}.excalidraw.md`),
+    elements,
+  });
+  console.log('wrote', item.slug);
+}
+```
+
+```js
+// pipeline/shared-style.js  (lives at boards/pipeline/shared-style.js)
+const path = require('path');
+// ../../ = project root (boards/ → project/); adjust if boards/ is nested deeper
+const { card, connector, sectionTitle } = require(path.resolve(__dirname, '../../.claude/skills/excalidraw/scripts/lib/style.js'));
+
+exports.buildItemBoard = (item) => [
+  sectionTitle({ x: 0, y: 0, text: item.name, fontSize: 40 }),
+  // … common layout using item fields
+];
+```
+
+Key conventions:
+- `ROOT = path.resolve(__dirname, '..')` pins paths relative to the generator file, not the working directory. The generator works correctly wherever it is invoked from.
+- Each item produces exactly one board; the mapping is `items.json → <slug>.excalidraw.md`.
+- `shared-style.js` owns the layout logic — boards stay visually consistent; change the style once, regenerate all.
+- Add a `package.json` script or `Makefile` alias so the command is always `npm run boards` (or similar) and never has to be rediscovered.
+
+## Spec schema
+```jsonc
+{
+  "out": "./boards/Board.excalidraw.md",    // prefer __dirname-relative in JS generators; relative to cwd for CLI
+  "vaultRoot": "/abs/vault",                  // optional; auto-detected by walking up to `.obsidian`
+  "attachDir": "Attachments",                 // external images get copied here (relative to board dir)
+  "wikilinkMode": "basename",                 // "basename" (default) or "path" (vault-relative)
+  "background": "#ffffff",
+  "elements": [ /* ElementSpec… */ ]
+}
+```
+
+**Paths in generators**: always use `path.resolve(__dirname, ...)` for `out` and image `path` fields — never
+hardcode absolute paths. This keeps the generator portable: move the folder and it still runs.
+
+### Element types
+- `text`     — `{ x, y, text, fontSize?, color?, width?, align?, fontFamily? }` (fontFamily 1=hand, 2=normal, 3=code). **Set `width` for any caption/label that must stay inside a column or card** → the text WRAPS to that width (autoResize off) and its height is computed from the wrapped line count. Omit `width` only for short single-line text you want sized to content (it renders on one line and will overlap neighbours if long).
+- `image`    — `{ x, y, path, width? , height? }` — give ONE of width/height; the other is derived from aspect. `path` is an absolute file path.
+- `rectangle`/`ellipse`/`diamond` — `{ x, y, width, height, strokeColor?, backgroundColor?, fillStyle?(solid|hachure|cross-hatch), strokeWidth?, roundness?(true=rounded) }`
+- `line`/`arrow` — `{ points: [[x1,y1],[x2,y2],…], strokeColor?, strokeWidth?, endArrow?, startArrow? }` (coords are absolute; arrows default to an end arrowhead)
+- `frame`    — `{ x, y, width, height, name }`
+
+### Layout helpers (JS API) — dimension-aware, never gap/overlap
+Both read each image's real pixel size at layout time, so every caption **hugs its own image's bottom**
+(no fixed-aspect guess → no big gap under a short screenshot, no overlap under a tall one). They return
+an `ElementSpec[]` you spread with `...`, and that array also carries `.height`, `.width`, and **`.nextY`**
+so you can stack lanes/grids/sections without doing height math by hand.
+- `lane({ title, images:[{path, caption}], x, y, thumbW, gap, captionSize, captionGap })` → titled horizontal
+  strip; caption wraps to `thumbW` under each thumb. Ideal for **funnel step maps** (one lane per funnel).
+- `grid({ images:[{path, caption}], x, y, cols, thumbW, gapX, gapY, captionSize })` → wrapping grid; each
+  row sizes to its tallest image, each caption hugs its image.
+- `thumbHeight(path, thumbW)` → the on-board height a thumbnail of width `thumbW` will get (exported for
+  custom layouts that need to place captions/rows themselves).
+```js
+const a = lane({ title:'Pilates', images, x:60, y:120, thumbW:150 });
+const b = lane({ title:'Fasting', images2, x:60, y:a.nextY, thumbW:150 }); // stacks under `a`, no overlap
+buildExcalidraw({ out, elements:[ ...a, ...b ] });
+```
+House-style `card()` labels are also vertically centered correctly even when the label **wraps** to the card width.
+
+## House style (`scripts/lib/style.js`) — learned from the vault's presentation boards
+Match the team's look by default. The builder now defaults text to **Excalifont (fontFamily 5)**.
+`style.js` exports the palette + ready-made builders so boards look hand-drawn and consistent:
+
+- **`PALETTE`** (semantic, = Excalidraw's native swatches): `green` benefit/go · `red` pain/risk ·
+  `blue` system/flow · `purple` core service · `yellow` processing · `mint` result · `gray` muted.
+  Each is `{ fill, stroke }`. `INK` = `#1e1e1e` (the default 2px card outline). Fills are **solid**,
+  rects are **always rounded**.
+- **`card({x,y,w,h,text,color,fontSize})`** → rounded filled rect + centered label, grouped (move as one).
+- **`node(...)`** → smaller card for flow steps.
+- **`sectionTitle({x,y,text,fontSize})`** → big plain header (no box), like "Configuration" / "Flow".
+- **`connector({from,to,label,double,dashed})`** → labeled arrow between two points.
+- **`annotate({from,to,text})`** → short arrow to a side-spec note (the "90sec / deepseek…" pattern).
+- **`column({x,y,items,color})`** → vertical stack of cards (benefit/risk lists). `items` may be
+  strings or `{text,color}`.
+- **`hub({cx,cy,label,spokes})`** → central node + satellites with arrows (the "Layer + APIs" pattern).
+- **`bullets({x,y,items})`** → one left-aligned bulleted text block (their spec-list pattern).
+- Edge helpers `center/rightOf/leftOf/topOf/bottomOf(x,y,w,h)` to wire connectors to card edges.
+
+Compose these into a `buildExcalidraw({ out, elements })` call. Runnable example: `examples/style_board.js`.
+Conventions: color nodes by ROLE, label every arrow, put specs in side-annotations, use big plain
+section titles to break the board into "slides", keep one idea per card.
+
+## Rules & gotchas
+- **Unique image filenames.** Obsidian resolves `[[name.png]]` by basename; if two different files
+  share a name anywhere in the vault the link is ambiguous. Name screenshots uniquely
+  (e.g. `bm-pilates-2707-step-03.png`) or use `"wikilinkMode": "path"`.
+- Images must live inside the vault. External paths are auto-copied into `attachDir`.
+- Output is uncompressed JSON inside `%% … %%`. The plugin reads it; on its first save it may
+  re-compress — that's expected and harmless.
+- Re-running with the same `out` + same spec yields a byte-stable file (seeds are derived from the
+  output path), so boards diff cleanly in git.
+- **Self-contained / portable.** No `npm install` — `build_excalidraw.js` uses only Node builtins +
+  the vendored `scripts/lib/*` (fractional-indexing, imagesize, style). Copy `.claude/skills/excalidraw/`
+  into any project and it works. `vaultRoot` auto-detects `.obsidian`; with none it falls back to the
+  board's own folder, so the `.excalidraw.md` is still written (it just renders inside Obsidian).
+
+## Verify
+Run the bundled examples from the skill folder (they use skill-relative paths + a bundled `sample.png`,
+so they work in any project):
+```bash
+cd .claude/skills/excalidraw
+node scripts/build_excalidraw.js examples/hello.spec.json   # spec-driven: text/shapes/image → examples/Hello Excalidraw.excalidraw.md
+node examples/style_board.js                                # JS API: card/connector/lane house style → examples/Style Demo.excalidraw.md
+```
+Then open the resulting board in Obsidian (Excalidraw view) to confirm it renders.
+
+See `reference/format.md` for the exact `.excalidraw.md` anatomy reverse-engineered from this vault.

package/dist/skill-packs/excalidraw/examples/hello.spec.json

@@ -0,0 +1,14 @@
+{
+  "out": "examples/Hello Excalidraw.excalidraw.md",
+  "background": "#ffffff",
+  "elements": [
+    { "type": "text", "x": 0, "y": -70, "text": "excalidraw skill — portable smoke test", "fontSize": 28, "color": "#1971c2" },
+    { "type": "text", "x": 0, "y": -28, "text": "Give a text a width and it wraps to that width (no overlap). The image embeds via sha1 wikilink — no base64. Only skill-relative paths, so this runs in any project.", "fontSize": 15, "color": "#868e96", "width": 540 },
+    { "type": "rectangle", "x": 0, "y": 40, "width": 260, "height": 140, "strokeColor": "#1e1e1e", "backgroundColor": "#a5d8ff", "fillStyle": "solid", "strokeWidth": 2, "roundness": true },
+    { "type": "text", "x": 24, "y": 96, "text": "rounded rect\n+ fill", "fontSize": 20, "color": "#1e1e1e" },
+    { "type": "ellipse", "x": 340, "y": 40, "width": 160, "height": 140, "strokeColor": "#2f9e44", "backgroundColor": "#b2f2bb", "fillStyle": "hachure" },
+    { "type": "arrow", "points": [[260, 110], [340, 110]], "strokeColor": "#e8590c", "strokeWidth": 3 },
+    { "type": "text", "x": 0, "y": 220, "text": "embedded image (resolved from vault by sha1 wikilink):", "fontSize": 16, "color": "#555", "width": 420 },
+    { "type": "image", "x": 0, "y": 250, "path": "examples/sample.png", "width": 320 }
+  ]
+}

package/dist/skill-packs/excalidraw/examples/style_board.js

@@ -0,0 +1,31 @@
+// style_board.js — house-style demo. Run from anywhere:  node examples/style_board.js
+// Shows card/connector/sectionTitle + the dimension-aware lane() (captions hug images, .nextY stacks).
+const path = require('path');
+const { buildExcalidraw, lane } = require(path.join(__dirname, '..', 'scripts', 'build_excalidraw.js'));
+const { card, connector, sectionTitle, rightOf, leftOf, bottomOf, topOf } = require(path.join(__dirname, '..', 'scripts', 'lib', 'style.js'));
+
+const SAMPLE = path.join(__dirname, 'sample.png');
+const els = [];
+const P = (...a) => els.push(...a.flat());
+
+// --- flow row with labeled connectors (color nodes by role) ---
+P(sectionTitle({ x: 0, y: 0, text: 'House style', fontSize: 40 }));
+const A = { x: 0, y: 90, w: 220, h: 84 }, B = { x: 360, y: 90, w: 220, h: 84 }, C = { x: 720, y: 90, w: 220, h: 84 };
+P(card({ ...A, text: 'input', color: 'blue' }));
+P(card({ ...B, text: 'core service', color: 'purple' }));
+P(card({ ...C, text: 'result', color: 'mint' }));
+P(connector({ from: rightOf(A.x, A.y, A.w, A.h), to: leftOf(B.x, B.y, B.w, B.h), label: 'request' }));
+P(connector({ from: rightOf(B.x, B.y, B.w, B.h), to: leftOf(C.x, C.y, C.w, C.h), label: 'response' }));
+
+// --- a dimension-aware lane: captions hug each image, .nextY gives the next free row ---
+const imgs = [
+  { path: SAMPLE, caption: 'lane() reads the real image size, so this caption hugs the bottom and wraps to the thumb width — no gap, no overlap.' },
+  { path: SAMPLE, caption: 'second thumb' },
+  { path: SAMPLE, caption: 'third thumb' },
+];
+const strip = lane({ title: 'lane()  — funnel-step style strip', images: imgs, x: 0, y: 220, thumbW: 200 });
+P(strip);
+P(sectionTitle({ x: 0, y: strip.nextY, text: 'stacked below via strip.nextY', fontSize: 22, color: '#868e96' }));
+
+buildExcalidraw({ out: path.join(__dirname, 'Style Demo.excalidraw.md'), elements: els, background: '#fbfbfb' });
+console.log('style demo →', path.join(__dirname, 'Style Demo.excalidraw.md'));

package/dist/skill-packs/excalidraw/package.json

@@ -0,0 +1,5 @@
+{
+  "type": "commonjs",
+  "private": true,
+  "description": "Scopes the excalidraw skill's vendored scripts to CommonJS so `require()` works even when the host project sets \"type\": \"module\". No dependencies — scripts use only Node builtins + vendored lib/."
+}

package/dist/skill-packs/excalidraw/reference/format.md

@@ -0,0 +1,93 @@
+# Obsidian `.excalidraw.md` format (reverse-engineered from this vault)
+
+Source files inspected: `lina/excalidraw/Lina Web Funnel.excalidraw.md` (decompressed),
+`Lina Web Funnel Benchmark.excalidraw.md`. Plugin: `zsviczian/obsidian-excalidraw-plugin`.
+
+## File anatomy
+```
+---
+
+excalidraw-plugin: parsed
+tags: [excalidraw]
+
+---
+==⚠  Switch to EXCALIDRAW VIEW … ⚠== …saving hint…
+
+
+# Excalidraw Data
+
+## Text Elements
+<text content> ^<elementId>      ← one block per text element, blank line between
+
+## Embedded Files
+<sha1>: [[image filename.png]]    ← maps fileId → vault image, blank line between
+
+%%
+## Drawing
+```json
+{ "type":"excalidraw", "version":2, "source":"…", "elements":[…], "appState":{…}, "files":{} }
+```
+%%
+```
+- `## Drawing` may be ` ```compressed-json ` (LZString.compressToBase64) **or** ` ```json `
+  (uncompressed). The plugin reads both. We emit uncompressed JSON — readable, no deps.
+- The whole drawing block is wrapped in `%% … %%` (Obsidian comment) so it hides in reading view.
+- `## Text Elements` and `## Embedded Files` sit **before** the `%%`.
+
+## Image embedding (the key mechanism)
+- An image element is `{"type":"image", "fileId":"<sha1>", …, "scale":[1,1], "status":"pending", "crop":null}`.
+- `fileId` is the **sha1 of the image file's bytes**.
+- The `## Embedded Files` line `<sha1>: [[file.png]]` is what the plugin uses to load the picture
+  from the vault. **The scene `files` object can be empty (`{}`)** — no base64 dataURL required.
+- `crop` is optional (only when the user cropped). `null` shows the whole image.
+
+## Ground-truth image element (decompressed from the vault)
+```json
+{
+  "id":"GtJwnnEj","type":"image","x":-147.3,"y":-290.5,"width":118.8,"height":469,
+  "angle":0,"strokeColor":"transparent","backgroundColor":"transparent","fillStyle":"solid",
+  "strokeWidth":2,"strokeStyle":"solid","roughness":1,"opacity":100,"groupIds":[],"frameId":null,
+  "index":"a0","roundness":null,"seed":2054545386,"version":188,"versionNonce":1261541290,
+  "isDeleted":false,"boundElements":[],"updated":1779266944741,"link":null,"locked":false,
+  "status":"pending","fileId":"3eaa974da433f70ba06cb3fb2587b486d6143d32","scale":[1,1],
+  "crop":{ "x":713.7,"y":0,"width":871.3,"height":3440,"naturalWidth":2283,"naturalHeight":3440 },
+  "hasTextLink":false
+}
+```
+…and its `## Embedded Files` line:
+```
+3eaa974da433f70ba06cb3fb2587b486d6143d32: [[Pasted Image 20260515130812_941.png]]
+```
+
+## z-order: fractional indices
+- Every element has a string `index` (`"a0"`, `"a1"`, …) — fractional indexing, compared
+  lexicographically. We generate them with the vendored `fractional-indexing` lib
+  (`generateNKeysBetween(null,null,N)`), which matches the vault output exactly.
+- Excalidraw's `restore()` (run by the plugin on load) repairs invalid/missing indices, but we emit
+  valid ascending ones anyway.
+
+## appState
+Minimal is fine: `{"gridSize":null,"gridStep":5,"gridModeEnabled":false,"viewBackgroundColor":"#ffffff"}`.
+
+## House style (measured from MemoryOS High Level / Personalization Module / Research)
+The vault's presentation boards share one fingerprint — `scripts/lib/style.js` encodes it:
+- **Font:** Excalifont, `fontFamily: 5`, for ~100% of text. Sizes form a scale: ~16 labels, ~20 body,
+  ~28 sub-headers, ~44–50 section titles (scaled up on large zoomed-out canvases).
+- **Fills:** `fillStyle: "solid"` exclusively (never hachure). **Every rectangle is rounded.**
+- **Ink:** `strokeColor: "#1e1e1e"`, `strokeWidth: 2` dominant (1 for fine/secondary).
+- **Semantic palette** (Excalidraw native swatches): green `#b2f2bb`/`#2f9e44` (benefit/go),
+  red `#ffc9c9`/`#e03131` (pain/risk), blue `#a5d8ff`/`#1971c2` (system/flow), purple `#d0bfff`/`#6741d9`
+  (core service), yellow `#ffec99`/`#f08c00` (processing), mint `#96f2d7`/`#0c8599` (result),
+  pale variants `#ebfbee`/`#e7f5ff`/`#f3f0ff` for backdrops.
+- **Patterns:** rounded-card (rect + centered label, grouped) · color nodes by role · ellipse = actor,
+  diamond = decision, container-rect groups sub-states · arrows almost always single end-arrowhead,
+  labeled inline ("req", "msg+ctx") · side-annotation arrows to spec notes · big plain section titles
+  ("Configuration", "Flow") · benefit/risk **card columns** · hub-and-spoke concept maps · bulleted
+  spec lists as one text block. Heavy use of embedded screenshots in research murals (huge canvases,
+  29+ groups) — exactly the funnel-map use case.
+
+## Tooling note
+The `yctimlin/mcp_excalidraw` MCP server was evaluated and rejected for this vault: it needs a
+running localhost canvas server and exports excalidraw.com JSON / PNG / share-URLs — it does **not**
+write Obsidian `.excalidraw.md` with the `## Embedded Files` wikilink section. Hand-generating the
+file (this skill) is the correct, dependency-light path for bulk-embedding local screenshots.