slidemind 0.0.27

package/.claude-plugin/plugin.json

@@ -0,0 +1,23 @@
+{
+  "name": "slidemind",
+  "version": "0.0.24",
+  "description": "Connect Claude Code, Codex & opencode to the slidemind PowerPoint add-in to build and edit native, on-brand PowerPoint decks against the active corporate design.",
+  "author": {
+    "name": "statworx"
+  },
+  "homepage": "https://github.com/STATWORX/intern-slidemind-cli",
+  "keywords": [
+    "presentation",
+    "slides",
+    "powerpoint",
+    "office-addin",
+    "slidemind"
+  ],
+  "skills": "./skills",
+  "mcpServers": {
+    "slidemind": {
+      "command": "node",
+      "args": ["${CLAUDE_PLUGIN_ROOT}/src/mcp/server.mjs"]
+    }
+  }
+}

package/CLAUDE.md

@@ -0,0 +1,137 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project purpose
+
+This repository (`STATWORX/intern-slidemind-cli`) publishes **slidemind** — the companion npm package and Claude Code / Codex / opencode plugin for the **slidemind PowerPoint add-in** (coming to the Microsoft Office Store). It connects a coding agent to a running PowerPoint over the add-in's local bridge so the agent can build and edit native, on-brand `.pptx` decks against whatever corporate design the add-in has active. It is **brand-agnostic**: the corporate design, the layout palette, and the OOXML render all live in the add-in, not here.
+
+The package contains two layers:
+
+1. **An installable skill** (canonical markdown + assets) that ships into a coding-agent harness so the agent knows how to plan, compose, and review slides on-brand — reading every brand rule from the add-in's design bundle.
+2. **A Node CLI + MCP server** (`slidemind`) that exposes the add-in bridge (render `.pptx`, push slides into an open window, search the brand engine) to the user and the agent directly.
+
+Both drive the same add-in bridge, so an agent and a human end up producing the same artefact: native PowerPoint slides on the active corporate design.
+
+## Distribution
+
+The package is published to **public npm** as `slidemind` (`publishConfig.access: public`; license `UNLICENSED` — publicly installable, proprietary). The source lives in a private GitHub repo (`STATWORX/intern-slidemind-cli`); the npm tarball is the install artifact. The CLI is a thin client — the corporate design and the OOXML render live in the slidemind add-in and require an open host — so there is nothing secret in the tarball.
+
+Install + register with a harness:
+
+```bash
+npm install -g slidemind
+slidemind init --for all          # claude | codex | opencode | all | none
+```
+
+`npx slidemind <command>` runs it without a global install. `slidemind update` is a thin wrapper over `npm install -g slidemind@latest` (`--ref <version>` to pin, `--for <target>` to control the redeploy). The `files` whitelist in `package.json` controls what ships (`bin/ src/ skills/ .claude-plugin/ CLAUDE.md README.md`); `archive/`, `docs/`, `scripts/`, and `test/` are excluded.
+
+> The previous account-free channel (a private Azure Blob container + shared read SAS + `scripts/install.sh` curl-bootstrap) has been **retired** — see `archive/scripts/install.sh`. npm is the sole channel now.
+
+## Releasing
+
+Releases are **automatic on every push to `main`**. The workflow at `.github/workflows/release.yml` runs and:
+
+1. If `package.json`'s version was manually bumped (and no tag exists for that version yet) → tags THAT version.
+2. Otherwise → bumps the patch by 1, commits the bumped `package.json` back to `main`, then tags the new version. (No infinite loop: GitHub doesn't trigger workflows from commits made with the default `GITHUB_TOKEN`, and the workflow also skips if the actor is `github-actions[bot]`.)
+3. In both cases → creates a GitHub Release with auto-generated notes, then **`npm publish --access public`**.
+
+The publish step is gated on the `NPM_TOKEN` repo secret (an npm automation token with publish rights to `slidemind`): until it's set the workflow warns and skips publish (so tagging/releases keep working during rollout); once set, a publish failure fails the build. So most of the time you just merge to `main` and a new patch release falls out to npm.
+
+For a **minor or major** bump, run the local helper before pushing:
+
+```bash
+node scripts/release.mjs --minor        # 0.0.1 -> 0.1.0
+node scripts/release.mjs --major        # 0.0.1 -> 1.0.0
+node scripts/release.mjs 0.5.0          # explicit
+node scripts/release.mjs --minor --dry-run
+git push                                # workflow tags + releases
+```
+
+The script bumps `package.json` and commits — it does not tag (CI does that). It refuses to run on a dirty tree.
+
+Teammates pick up the release with `npm install -g slidemind@latest` (or `slidemind update` if already installed); pin with `slidemind@X.Y.Z` / `slidemind update --ref X.Y.Z`.
+
+> **One-time GitHub setup:** the workflow uses the default `GITHUB_TOKEN`. If branch-protection rules on `main` block bot pushes, allow the `github-actions[bot]` actor (or relax "require pull request before merging" for that bot).
+
+## Repository layout
+
+```
+slidemind/
+├── package.json                  npm package metadata, single bin: slidemind
+├── README.md                     end-user quickstart
+├── CLAUDE.md                     this file
+├── .claude-plugin/
+│   └── plugin.json               Claude Code plugin manifest
+├── bin/
+│   └── slidemind.mjs             CLI dispatcher (presentations, download-bundle, init, build, build-pptx, push, search, install)
+├── skills/                       canonical, installable skill payload — thin CLI workflow glue only
+│   └── create-slides/
+│       └── SKILL.md              the whole skill: host gate + intake/plan + create flow + CLI⇄in-app command map.
+│                                 Brand AND the authoring workflow craft (create/edit/composition/layouts/
+│                                 authoring/build-export) are READ from the materialized bundle — owned by the add-in.
+├── src/                          implementation of the slidemind CLI
+│   ├── bridge/                   add-in local-bridge: client.mjs, bundle.mjs (materialize), build-and-push.mjs (server render)
+│   ├── builders/                 build.mjs (HTML preview), resolve-skill.mjs (→ bundle), primitives.json (fallback)
+│   ├── mcp/                      MCP server: list/push + slidemind_search_engine / slidemind_download_result
+│   └── installers/               per-harness installers: claude.mjs, codex.mjs, opencode.mjs, lib.mjs
+├── archive/                      retired code/assets (local exporter, icon library, brand design files) — NOT shipped
+├── decks/                        the user's working decks; sources are slides/*.jsx, design via .bundle-ref.json
+├── docs/slidemind-cli-connect/   the connect architecture (bridge contract, bundle, engine, phasing)
+└── test/                         node:test suites (bridge client/bundle/build-and-push/resolve-skill/lint/packaging)
+```
+
+The skill at the **root** of `skills/` is deliberate: that's the layout Claude Code, Codex (0.128+), and opencode all expect for skill auto-discovery — `<harness-root>/skills/<name>/SKILL.md`. There's a single skill (`create-slides`); it gets copied into each harness as `slidemind-create-slides` and owns the user-facing plan / create / edit / render workflow. It is **brand-agnostic** — every brand rule lives in the per-CD bundle's `design.md`, which the skill points the agent at. (Pre-skills opencode versions used an `agent/` shim under `~/.config/opencode/`; the installer removes any leftover from those installs on every run.)
+
+We **do not** ship separate slash commands. Earlier versions had a top-level `commands/` directory that became `/slidemind:plan` etc. on Claude Code and `~/.codex/prompts/slidemind-*.md` on Codex. The Codex prompts mechanism is broken in 0.117+ ([openai/codex#15941](https://github.com/openai/codex/issues/15941)) and officially deprecated in favour of skills, so we collapsed everything into the skill itself. Re-running `slidemind init` actively wipes legacy command/prompt entries on every harness.
+
+## CLI surface
+
+```bash
+slidemind presentations            # list PowerPoint windows registered with the add-in
+slidemind download-bundle [deck]   # materialize the active corporate design's bundle locally
+slidemind new <name>               # scaffold ./decks/<name>/
+slidemind build <deck>             # build self-contained HTML preview
+slidemind build-pptx <deck>        # render native .pptx via the add-in (HOST REQUIRED)
+slidemind push <deck>              # render + push slides into a running PowerPoint (HOST REQUIRED)
+slidemind search "<query>"         # search the brand engine for imagery (HOST REQUIRED)
+slidemind init --for <target>   # install skill into claude | codex | opencode | all
+slidemind uninstall --for <target>
+```
+
+`<deck>` resolves as: absolute path → `./<arg>` if it exists → `./decks/<arg>`. The decks directory is `./decks/` by default; override with `SLIDEMIND_DECKS=/abs/path`.
+
+**The design truth lives in the add-in, not the CLI.** The `.pptx` is rendered server-side over the local bridge (no local exporter), the corporate design is fetched as a bundle, and brand imagery comes from the add-in's engine. So `create`/`build-pptx`/`push`/`search` all hard-require an **open PowerPoint host with the slidemind add-in and an active corporate design**. See `docs/slidemind-cli-connect/`.
+
+## Design system ground rules
+
+The corporate design is **served by the add-in, not shipped by the CLI.** `slidemind download-bundle` materializes it (keyed by the deck's `.bundle-ref.json`) into `${XDG_CACHE_HOME:-~/.cache}/slidemind/bundles/<presFP>/`:
+
+- `design.md` — the **single source of brand rules** (tokens, type scale, layout palette, the authoring contract, and a `### Brand Image Sources` block). **Read it; never restate it.**
+- `corporate-design.css` — the design tokens to link/inline and compose with token classes.
+- `layouts/*.jsx` + `layouts/layouts.css` — the closed layout palette to compose against.
+- `assets/`, `engines.json` — brand assets and the searchable image/icon engines.
+
+The skill is **brand-agnostic workflow guidance** and must not duplicate any brand rule — `scripts/check-skill-parity.mjs` (`npm run lint:parity`) fails the build if a hardcoded color, design token, or layout name leaks into a skill doc.
+
+## Sanity rules when editing slides
+
+- One default export per slide file, composing one bundle layout (Mode A) or a blank-content layout with freeform `children` (Mode B) — exactly as the bundle's `design.md` prescribes. No imports — layouts are globals in slide scope at build time.
+- No hardcoded colors, sizes, or fonts in slide files. Everything goes through the tokens in the bundle's `corporate-design.css`.
+- **Never add a layout.** The layout palette is the closed set in `<bundle>/layouts/` — read-only. Need markup a layout doesn't expose? Build it as Mode B children of the blank-content layout the bundle's `design.md` names — never a new layout file.
+- Re-run `slidemind push <deck>` (or `build-pptx`) after any `.jsx` change — the .pptx is rendered server-side, not edited by hand; the HTML preview is generated.
+- For generic concept icons/images, use the brand engine: `slidemind_search_engine` → pick a result → `slidemind_download_result` (writes into the deck's `assets/`). Don't invent SVGs. The full authoring workflow is read from the materialized bundle's `workflow/*.md` (owned by the add-in).
+
+## Build commands (terse reference)
+
+```bash
+slidemind download-bundle <deck>  # materialize the corporate design locally (do this first)
+slidemind build <deck>            # HTML preview (reads the materialized bundle)
+slidemind build <deck> --open     # HTML + open in browser
+slidemind build-pptx <deck>       # native PPTX rendered server-side via the add-in (host required)
+slidemind push <deck>             # render + push into a running PowerPoint (host required)
+slidemind search "<query>"        # search the brand engine for imagery (host required)
+npm run lint:parity               # assert the skill carries no brand rules (CI guard)
+```
+
+No linter beyond the parity guard, `node --test` for the suite, no package manager beyond npm itself. The HTML preview is self-contained except for React + Babel-standalone pulled from a CDN on first load.

package/README.md

@@ -0,0 +1,100 @@
+# slidemind
+
+Connect Claude Code, Codex, and opencode to the **slidemind PowerPoint add-in** — so your coding agent can build and edit native, on-brand PowerPoint decks against your active corporate design, without leaving the terminal.
+
+This is the companion CLI for the slidemind PowerPoint add-in (coming to the Microsoft Office Store). The add-in owns the corporate design and the native `.pptx` render; slidemind is the bridge that lets a coding agent drive it. It ships two things:
+
+1. **A CLI + MCP server** that talks to a running PowerPoint over the add-in's local bridge — render native `.pptx`, push slides straight into an open window, and search the active design's brand engine for imagery.
+2. **An installable skill** for Claude Code, Codex, and opencode — so the agent in your editor knows how to drive that bridge and compose slides on-brand from the design bundle the add-in serves.
+
+## Install
+
+From public npm. macOS / Linux / Windows; requires **Node 18+**.
+
+```bash
+npm install -g slidemind
+slidemind init --for all      # register the MCP server + skill into Claude Code / Codex / opencode
+```
+
+`slidemind init --for <claude|codex|opencode|all|none>` scopes the harness deployment (`none` installs the CLI only). `slidemind --version` confirms it's on your `PATH`.
+
+One-off, without a global install:
+
+```bash
+npx slidemind <command>
+```
+
+### Updating
+
+```bash
+slidemind update                 # = npm install -g slidemind@latest, then redeploy the skill
+slidemind update --ref 0.1.0     # pin a specific version
+slidemind update --for codex     # redeploy into one harness (or --for none to skip)
+```
+
+Equivalently: `npm install -g slidemind@latest && slidemind init --for all`.
+
+> **Heads up:** the design system and the `.pptx` render now live in the **slidemind PowerPoint add-in** — the CLI is a thin client. `build-pptx`, `push`, `download-bundle`, and `search` require an open PowerPoint window with the add-in loaded and an active corporate design. See [`docs/slidemind-cli-connect/`](./docs/slidemind-cli-connect/).
+
+## Quick start
+
+```bash
+slidemind new my-deck             # scaffold ./decks/my-deck/
+slidemind build my-deck           # build self-contained HTML
+slidemind build-pptx my-deck      # render native .pptx via the add-in (host required)
+slidemind search "shield"         # search the brand engine for imagery (host required)
+```
+
+Decks live under `./decks/` in your current working directory. Each deck is one folder: `decks/<name>/slides/*.jsx`.
+
+## Pushing slides into an open PowerPoint
+
+If you have PowerPoint open with the **slidemind add-in** loaded, you can build a deck and stream its slides straight into the running window — no `.pptx` file written to disk:
+
+```bash
+slidemind presentations                   # list registered PowerPoint windows (presId, title, fileName)
+slidemind push my-deck                    # append my-deck after the current slides
+slidemind push my-deck --to <presId>      # required if more than one PowerPoint window is open
+slidemind push my-deck --at 0             # insert after slide 1 (0-based index)
+slidemind push my-deck --replace          # delete every existing slide first (destructive — confirm!)
+slidemind push my-deck --slides 02,05,07  # push only a subset of source slides
+```
+
+If `slidemind presentations` returns nothing, the add-in isn't running — open PowerPoint with the slidemind add-in and an active corporate design, then retry. (Rendering is server-side now, so `build-pptx` needs a host too.)
+
+## Export formats at a glance
+
+| Command | Output | When to use |
+|---|---|---|
+| `slidemind build <deck>` | `decks/<deck>/presentation.html` | Self-contained HTML (browser) |
+| `slidemind build-pptx <deck>` | `decks/<deck>/<deck>.pptx` | Editable PowerPoint file |
+| `slidemind push <deck>` | (streamed via add-in) | Live insertion into an open PowerPoint window |
+
+## Icon / image search
+
+`slidemind search "<query>"` searches the active corporate design's **brand engine** (icons/images) over the local bridge — proxied to the open PowerPoint task pane, so it returns the same results the in-app design agent sees (an open host is required). It prints a `searchId` plus numbered results; the agent then fetches a chosen result into the deck's `assets/` via the MCP tool `slidemind_download_result`. The agent-facing flow (`slidemind_search_engine` → `slidemind_download_result`) is owned by the add-in's design bundle and read by the skill. There is no local icon library anymore.
+
+## Install into a coding-agent harness
+
+Pick a target and run:
+
+```bash
+slidemind init --for claude        # ~/.claude/skills/slidemind-create-slides/
+slidemind init --for codex         # ~/.codex/skills/slidemind-create-slides/
+slidemind init --for opencode      # ~/.config/opencode/{agent,slidemind}/
+slidemind init --for all
+```
+
+Each installer drops the slidemind skill files into the harness-specific location. After install, your agent auto-discovers the `slidemind-create-slides` skill and loads it on demand whenever you ask for a slide, deck, or presentation. The skill owns the entire plan → create → edit workflow — there are no separate slash commands to remember.
+
+Add `--link` to symlink instead of copy (useful while hacking on slidemind itself).
+
+To remove:
+
+```bash
+slidemind uninstall --for <target>
+```
+
+## Project layout
+
+See [CLAUDE.md](./CLAUDE.md) for the full repo tour and the design-system ground rules.