@drunkcoding/agents-and-skills 0.0.1 → 0.0.3

package/.claude-plugin/marketplace.json

@@ -1,5 +1,5 @@
 {
-  "name": "neptune",
+  "name": "drunkcoding",
   "owner": {
     "name": "steven",
     "email": "steven.hoang@transwap.com"
@@ -12,7 +12,7 @@
       "name": "tech-graph",
       "source": "./plugins/tech-graph",
       "description": "6-step wizard for technical diagrams (SVG/PNG) via fireworks-tech-graph",
-      "version": "0.0.1",
+      "version": "0.0.3",
       "category": "diagram",
       "keywords": [
         "diagram",
@@ -21,6 +21,21 @@
         "uml",
         "flowchart"
       ]
+    },
+    {
+      "name": "html-effectiveness",
+      "source": "./plugins/html-effectiveness",
+      "description": "Generate self-contained interactive HTML reports from 20 upstream templates via a conversational agent.",
+      "version": "0.0.3",
+      "category": "reports",
+      "keywords": [
+        "html",
+        "report",
+        "status",
+        "incident",
+        "slide-deck",
+        "decision-matrix"
+      ]
     }
   ]
 }

package/README.md

@@ -9,18 +9,49 @@ Published on npm as [`@drunkcoding/agents-and-skills`](https://www.npmjs.com/pac
 | Plugin | Description |
 |--------|-------------|
 | [`tech-graph`](plugins/tech-graph) | 6-step wizard for technical diagrams (SVG + PNG). |
+| [`html-effectiveness`](plugins/html-effectiveness) | Conversational agent that generates self-contained interactive HTML reports from 20 templates. |
 
 ## Install
 
 ### Claude Code marketplace
 
+Add the marketplace once:
+
 ```text
 /plugin marketplace add drunkcoding/agents-and-skills
-/plugin install <plugin-name>@neptune
+```
+
+Then install any plugin individually:
+
+```text
+/plugin install tech-graph@drunkcoding
+/plugin install html-effectiveness@drunkcoding
+```
+
+Reload after install:
+
+```text
+/reload-plugins
 ```
 
 Only the plugin you install loads; others stay dormant.
 
+#### Project-scoped install
+
+Install into a project's `.claude/` instead of your user profile:
+
+```text
+/plugin install tech-graph@drunkcoding --scope project
+```
+
+#### Manage installed plugins
+
+```text
+/plugin list                 # see installed plugins
+/plugin uninstall <name>     # remove
+/plugin marketplace update   # pull latest manifest
+```
+
 ### npm / npx
 
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@drunkcoding/agents-and-skills",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "Personal collection of Claude Code skills and agents, installable via `npx skills`.",
   "keywords": [
     "claude-code",

package/plugins/html-effectiveness/.claude-plugin/plugin.json

@@ -0,0 +1,13 @@
+{
+  "name": "html-effectiveness",
+  "displayName": "HTML Effectiveness Reports",
+  "version": "0.0.3",
+  "description": "Generate self-contained interactive HTML reports from 20 upstream templates via a conversational agent.",
+  "author": "Steven Hoang",
+  "skills": [
+    "skills/html-effectiveness"
+  ],
+  "agents": [
+    "agents/report-builder.md"
+  ]
+}

package/plugins/html-effectiveness/README.md

@@ -0,0 +1,23 @@
+# html-effectiveness
+
+Generate self-contained interactive HTML reports (status, incident, PR writeup, decision matrix, slide deck, code review, research explainer, etc.) from 20 upstream templates.
+
+## Usage
+
+Invoke the `report-builder` agent. It will pick a template, gather slot data conversationally, and render to `docs/reports/YYYY-MM-DD-<slug>.html`.
+
+Override output dir in repo `CLAUDE.md`:
+
+```
+html-effectiveness.reportDir: my/custom/reports
+```
+
+## Sync upstream
+
+Re-fetch templates from `ThariqS/html-effectiveness`:
+
+```bash
+node plugins/html-effectiveness/scripts/sync-upstream.js
+```
+
+See `docs/template-gallery.md` for the full pattern catalog.

package/plugins/html-effectiveness/assets/base.css

@@ -0,0 +1,31 @@
+/* Theme variables, typography, print baseline. Populated from upstream during Task 7. */
+:root {
+  --bg: #ffffff;
+  --fg: #111111;
+  --muted: #666666;
+  --accent: #2563eb;
+  --border: #e5e7eb;
+  --radius: 6px;
+  --font: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
+  --mono: ui-monospace, "SF Mono", Menlo, Monaco, Consolas, monospace;
+  --transition: 150ms ease;
+}
+@media (prefers-color-scheme: dark) {
+  :root {
+    --bg: #0b0b0c;
+    --fg: #f5f5f7;
+    --muted: #9aa0a6;
+    --accent: #60a5fa;
+    --border: #2a2a2c;
+  }
+}
+* { box-sizing: border-box; }
+html, body { margin: 0; padding: 0; background: var(--bg); color: var(--fg); font-family: var(--font); }
+a { color: var(--accent); text-decoration: none; }
+a:hover { text-decoration: underline; }
+@media print {
+  details { display: block; }
+  details > summary { display: none; }
+  [hidden] { display: revert !important; }
+  body { background: white; color: black; }
+}

package/plugins/html-effectiveness/assets/base.js

@@ -0,0 +1,11 @@
+// Shared interactions: theme toggle, search, nav, copy-on-click. Populated from upstream during Task 7.
+(function () {
+  document.addEventListener('click', (e) => {
+    const t = e.target.closest('[data-copy]');
+    if (!t) return;
+    const text = t.getAttribute('data-copy');
+    navigator.clipboard?.writeText(text);
+    t.setAttribute('data-copied', '1');
+    setTimeout(() => t.removeAttribute('data-copied'), 1000);
+  });
+})();

package/plugins/html-effectiveness/assets/charts.js

@@ -0,0 +1 @@
+// Inline SVG chart helpers. Opt-in via manifest.extra_js. Populated from upstream during Task 7.

package/plugins/html-effectiveness/assets/components.css

@@ -0,0 +1,10 @@
+/* Shared components: cards, timeline, kanban, matrix, swatches, slides. Populated from upstream during Task 7. */
+.report { max-width: 1200px; margin: 0 auto; padding: 2rem 1rem; }
+.report header h1 { font-size: 1.75rem; margin: 0 0 .25rem; }
+.report header .subtitle { color: var(--muted); margin: 0 0 1.5rem; }
+.card { border: 1px solid var(--border); border-radius: var(--radius); padding: 1rem; transition: border-color var(--transition); }
+.stats { display: grid; grid-template-columns: repeat(auto-fit, minmax(180px, 1fr)); gap: 1rem; margin: 0 0 2rem; }
+.stat { display: flex; flex-direction: column; gap: .25rem; }
+.stat .value { font-size: 1.5rem; font-weight: 600; }
+.stat .label { color: var(--muted); font-size: .875rem; }
+.stat .delta { font-size: .75rem; }

package/plugins/html-effectiveness/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "@local/html-effectiveness",
+  "private": true,
+  "version": "0.1.0",
+  "type": "module"
+}

package/plugins/html-effectiveness/scripts/mustache.js

@@ -0,0 +1,90 @@
+// Hand-rolled mustache subset: {{var}}, {{{raw}}}, {{#section}}…{{/section}}, {{^inverted}}…{{/inverted}}
+// Zero runtime dependencies.
+
+const ESCAPE_MAP = { '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' };
+const escapeHtml = (s) => String(s).replace(/[&<>"']/g, (c) => ESCAPE_MAP[c]);
+
+function tokenize(template) {
+  const tokens = [];
+  const re = /\{\{(\{?)([\^#\/]?)\s*([\w.-]+)\s*\}?\}\}/g;
+  let lastIndex = 0;
+  let m;
+  while ((m = re.exec(template)) !== null) {
+    if (m.index > lastIndex) tokens.push({ type: 'text', value: template.slice(lastIndex, m.index) });
+    const [, triple, sigil, name] = m;
+    if (sigil === '#') tokens.push({ type: 'section', name });
+    else if (sigil === '^') tokens.push({ type: 'inverted', name });
+    else if (sigil === '/') tokens.push({ type: 'close', name });
+    else if (triple === '{') tokens.push({ type: 'raw', name });
+    else tokens.push({ type: 'var', name });
+    lastIndex = re.lastIndex;
+  }
+  if (lastIndex < template.length) tokens.push({ type: 'text', value: template.slice(lastIndex) });
+  return tokens;
+}
+
+function parse(tokens, end = null) {
+  const nodes = [];
+  while (tokens.length) {
+    const t = tokens.shift();
+    if (t.type === 'close') {
+      if (t.name !== end) throw new Error(`Mismatched close tag: expected ${end}, got ${t.name}`);
+      return nodes;
+    }
+    if (t.type === 'section' || t.type === 'inverted') {
+      const children = parse(tokens, t.name);
+      nodes.push({ ...t, children });
+    } else {
+      nodes.push(t);
+    }
+  }
+  if (end !== null) throw new Error(`Unclosed section: ${end}`);
+  return nodes;
+}
+
+function lookup(ctxStack, name) {
+  if (name === '.') return ctxStack[ctxStack.length - 1];
+  const parts = name.split('.');
+  for (let i = ctxStack.length - 1; i >= 0; i--) {
+    let cur = ctxStack[i];
+    let ok = true;
+    for (const p of parts) {
+      if (cur == null || typeof cur !== 'object' || !Object.prototype.hasOwnProperty.call(cur, p)) { ok = false; break; }
+      cur = cur[p];
+    }
+    if (ok) return cur;
+  }
+  return undefined;
+}
+
+function emit(nodes, ctxStack) {
+  let out = '';
+  for (const n of nodes) {
+    if (n.type === 'text') out += n.value;
+    else if (n.type === 'var') {
+      const v = lookup(ctxStack, n.name);
+      out += v == null ? '' : escapeHtml(v);
+    } else if (n.type === 'raw') {
+      const v = lookup(ctxStack, n.name);
+      out += v == null ? '' : String(v);
+    } else if (n.type === 'section') {
+      const v = lookup(ctxStack, n.name);
+      if (Array.isArray(v)) {
+        for (const item of v) out += emit(n.children, [...ctxStack, item]);
+      } else if (v && (typeof v !== 'object' || Object.keys(v).length > 0)) {
+        out += emit(n.children, [...ctxStack, v]);
+      }
+    } else if (n.type === 'inverted') {
+      const v = lookup(ctxStack, n.name);
+      const empty = v == null || v === false || (Array.isArray(v) && v.length === 0);
+      if (empty) out += emit(n.children, ctxStack);
+    }
+  }
+  return out;
+}
+
+export function render(template, data) {
+  const tokens = tokenize(template);
+  const tree = parse(tokens);
+  return emit(tree, [data]);
+}

package/plugins/html-effectiveness/scripts/render.js

@@ -0,0 +1,176 @@
+#!/usr/bin/env node
+// CLI + library: render a template + data into a self-contained HTML file.
+// Exit codes: 0 ok, 1 generic, 2 template-not-found, 3 slot schema mismatch, 4 fs write error.
+
+import { readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { dirname, resolve, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { parseArgs } from 'node:util';
+import { render as mustache } from './mustache.js';
+
+const SCRIPT_DIR = dirname(fileURLToPath(import.meta.url));
+const PLUGIN_ROOT = dirname(SCRIPT_DIR);
+
+const ASSET_BUNDLES = {
+  base: { css: 'assets/base.css', js: 'assets/base.js' },
+  components: { css: 'assets/components.css' },
+  charts: { js: 'assets/charts.js' },
+};
+
+function validateSlot(templateId, slotPath, schema, value) {
+  if (schema.required && (value === undefined || value === null)) {
+    const err = new Error(`${templateId}:${slotPath} required but missing`);
+    err.code = 3;
+    throw err;
+  }
+  if (value === undefined || value === null) return;
+  const type = schema.type;
+  if (type === 'string' || type === 'html') {
+    if (typeof value !== 'string') {
+      const err = new Error(`${templateId}:${slotPath} expected string got ${typeof value}`);
+      err.code = 3;
+      throw err;
+    }
+  } else if (type === 'number') {
+    if (typeof value !== 'number') {
+      const err = new Error(`${templateId}:${slotPath} expected number got ${typeof value}`);
+      err.code = 3;
+      throw err;
+    }
+  } else if (type === 'boolean') {
+    if (typeof value !== 'boolean') {
+      const err = new Error(`${templateId}:${slotPath} expected boolean got ${typeof value}`);
+      err.code = 3;
+      throw err;
+    }
+  } else if (type === 'array') {
+    if (!Array.isArray(value)) {
+      const err = new Error(`${templateId}:${slotPath} expected array got ${typeof value}`);
+      err.code = 3;
+      throw err;
+    }
+    if (schema.of) {
+      value.forEach((item, i) => {
+        for (const [k, subType] of Object.entries(schema.of)) {
+          const subSchema = typeof subType === 'string' ? { type: subType } : subType;
+          validateSlot(templateId, `${slotPath}[${i}].${k}`, subSchema, item?.[k]);
+        }
+      });
+    }
+  } else if (type === 'object') {
+    if (typeof value !== 'object' || Array.isArray(value)) {
+      const err = new Error(`${templateId}:${slotPath} expected object got ${typeof value}`);
+      err.code = 3;
+      throw err;
+    }
+  }
+}
+
+function validate(templateId, slots, data) {
+  for (const [name, schemaRaw] of Object.entries(slots)) {
+    const schema = typeof schemaRaw === 'string' ? { type: schemaRaw } : schemaRaw;
+    validateSlot(templateId, name, schema, data[name]);
+  }
+}
+
+function loadAssets(pluginRoot, bundles, extraJs) {
+  const css = [];
+  const js = [];
+  for (const name of bundles || []) {
+    const b = ASSET_BUNDLES[name];
+    if (!b) continue;
+    if (b.css) css.push(readFileSync(join(pluginRoot, b.css), 'utf8'));
+    if (b.js) js.push(readFileSync(join(pluginRoot, b.js), 'utf8'));
+  }
+  if (extraJs) js.push(readFileSync(join(pluginRoot, extraJs), 'utf8'));
+  return { css: css.join('\n'), js: js.join('\n') };
+}
+
+function escapeForTitle(s) {
+  return String(s).replace(/[&<>"']/g, (c) => ({
+    '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;',
+  }[c]));
+}
+
+export function renderReport({ templateId, data, outPath, manifestPath, pluginRoot }) {
+  const root = pluginRoot || PLUGIN_ROOT;
+  const mPath = manifestPath || join(root, 'templates/manifest.json');
+  const manifest = JSON.parse(readFileSync(mPath, 'utf8'));
+  const entry = manifest[templateId];
+  if (!entry) {
+    const ids = Object.keys(manifest).filter((k) => k !== '_meta');
+    const err = new Error(`template not found: ${templateId}. valid: ${ids.join(', ')}`);
+    err.code = 2;
+    throw err;
+  }
+
+  validate(templateId, entry.slots, data);
+
+  const tmplRelPath = entry.tmpl || `templates/${templateId}.html.tmpl`;
+  const tmpl = readFileSync(join(root, tmplRelPath), 'utf8');
+  const body = mustache(tmpl, data);
+
+  const { css, js } = loadAssets(root, entry.asset_bundles, entry.extra_js);
+  const title = escapeForTitle(data.title || entry.title || 'Report');
+
+  const html = `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width,initial-scale=1">
+<title>${title}</title>
+<style>${css}</style>
+</head>
+<body>
+${body}
+<script>${js}</script>
+</body>
+</html>
+`;
+
+  try {
+    mkdirSync(dirname(outPath), { recursive: true });
+    writeFileSync(outPath, html, 'utf8');
+    const sidecar = {
+      template: templateId,
+      rendered_at: new Date().toISOString(),
+      render_version: '0.1.0',
+      data,
+    };
+    writeFileSync(outPath + '.data.json', JSON.stringify(sidecar, null, 2), 'utf8');
+  } catch (e) {
+    const err = new Error(`failed to write ${outPath}: ${e.message}`);
+    err.code = 4;
+    throw err;
+  }
+
+  return outPath;
+}
+
+function cli() {
+  const { values } = parseArgs({
+    options: {
+      template: { type: 'string' },
+      data: { type: 'string' },
+      out: { type: 'string' },
+    },
+  });
+  if (!values.template || !values.data || !values.out) {
+    process.stderr.write('usage: render.js --template=<id> --data=<json-path> --out=<html-path>\n');
+    process.exit(1);
+  }
+  try {
+    const data = JSON.parse(readFileSync(resolve(values.data), 'utf8'));
+    const finalPath = renderReport({
+      templateId: values.template,
+      data,
+      outPath: resolve(values.out),
+    });
+    process.stdout.write(finalPath + '\n');
+  } catch (e) {
+    process.stderr.write((e.stack || e.message) + '\n');
+    process.exit(e.code ?? 1);
+  }
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) cli();

package/plugins/html-effectiveness/templates/manifest.json

@@ -0,0 +1,7 @@
+{
+  "_meta": {
+    "upstream_repo": "ThariqS/html-effectiveness",
+    "upstream_sha": "PENDING",
+    "extracted_at": "PENDING"
+  }
+}

package/plugins/html-effectiveness/tests/fixtures/_canned.data.json

@@ -0,0 +1,7 @@
+{
+  "title": "Demo <Report>",
+  "items": [
+    { "name": "alpha", "html": "<b>bold</b>" },
+    { "name": "beta", "html": "<i>italic</i>" }
+  ]
+}

package/plugins/html-effectiveness/tests/fixtures/_canned.html.tmpl

@@ -0,0 +1,7 @@
+<main class="report">
+  <header><h1>{{title}}</h1></header>
+  <ul>
+    {{#items}}<li>{{name}}: {{{html}}}</li>{{/items}}
+  </ul>
+  {{^items}}<p>No items.</p>{{/items}}
+</main>

package/plugins/html-effectiveness/tests/fixtures/_canned.manifest.json

@@ -0,0 +1,18 @@
+{
+  "_meta": { "upstream_repo": "test", "upstream_sha": "test", "extracted_at": "test" },
+  "_canned": {
+    "title": "Canned",
+    "use_cases": ["test"],
+    "pattern": "test",
+    "tmpl": "fixtures/_canned.html.tmpl",
+    "slots": {
+      "title": { "type": "string", "required": true },
+      "items": {
+        "type": "array",
+        "of": { "name": "string", "html": "html" }
+      }
+    },
+    "asset_bundles": [],
+    "extra_js": null
+  }
+}

package/plugins/html-effectiveness/tests/mustache.test.js

@@ -0,0 +1,47 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { render } from '../scripts/mustache.js';
+
+test('renders bare variable, escaped by default', () => {
+  assert.equal(render('Hello {{name}}', { name: 'World' }), 'Hello World');
+});
+
+test('escapes HTML special chars in {{var}}', () => {
+  assert.equal(
+    render('{{x}}', { x: '<script>alert(1)</script>' }),
+    '&lt;script&gt;alert(1)&lt;/script&gt;'
+  );
+});
+
+test('triple-stash {{{raw}}} bypasses escaping', () => {
+  assert.equal(render('{{{html}}}', { html: '<b>x</b>' }), '<b>x</b>');
+});
+
+test('section iterates array with sub-context', () => {
+  const tmpl = '{{#items}}[{{name}}]{{/items}}';
+  assert.equal(render(tmpl, { items: [{ name: 'a' }, { name: 'b' }] }), '[a][b]');
+});
+
+test('inverted section renders only when falsy/empty', () => {
+  assert.equal(render('{{^items}}empty{{/items}}', { items: [] }), 'empty');
+  assert.equal(render('{{^items}}empty{{/items}}', { items: [{}] }), '');
+});
+
+test('missing key renders as empty string, not "undefined"', () => {
+  assert.equal(render('x={{missing}}', {}), 'x=');
+});
+
+test('nested sections respect inherited context', () => {
+  const tmpl = '{{#a}}{{#b}}{{x}}{{/b}}{{/a}}';
+  assert.equal(render(tmpl, { a: { b: [{ x: 'ok' }] } }), 'ok');
+});
+
+test('falsy section (false, null, undefined, empty array) renders nothing', () => {
+  for (const val of [false, null, undefined, []]) {
+    assert.equal(render('{{#x}}body{{/x}}', { x: val }), '');
+  }
+});
+
+test('preserves literal text around tags', () => {
+  assert.equal(render('a {{x}} b', { x: '1' }), 'a 1 b');
+});

package/plugins/html-effectiveness/tests/render.test.js

@@ -0,0 +1,118 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { renderReport } from '../scripts/render.js';
+
+const here = dirname(fileURLToPath(import.meta.url));
+const fixtures = join(here, 'fixtures');
+
+function setup() {
+  const out = mkdtempSync(join(tmpdir(), 'htmleff-'));
+  return {
+    out,
+    cleanup: () => rmSync(out, { recursive: true, force: true }),
+  };
+}
+
+test('renders canned template into self-contained HTML', () => {
+  const { out, cleanup } = setup();
+  try {
+    const outPath = join(out, 'demo.html');
+    renderReport({
+      templateId: '_canned',
+      data: JSON.parse(readFileSync(join(fixtures, '_canned.data.json'), 'utf8')),
+      outPath,
+      manifestPath: join(fixtures, '_canned.manifest.json'),
+      pluginRoot: dirname(fixtures),
+    });
+    const html = readFileSync(outPath, 'utf8');
+    assert.ok(html.startsWith('<!doctype html>'), 'starts with doctype');
+    assert.ok(html.includes('<title>Demo &lt;Report&gt;</title>'), 'title escaped in head');
+    assert.ok(html.includes('Demo &lt;Report&gt;</h1>'), 'title escaped in body');
+    assert.ok(html.includes('<b>bold</b>'), 'html slot rendered raw');
+    assert.ok(!html.match(/\{\{[^}]+\}\}/), 'no leftover mustache markers');
+    assert.ok(!html.includes('<link'), 'no external link');
+    assert.ok(!html.match(/<script\s+src=/i), 'no external script src');
+  } finally {
+    cleanup();
+  }
+});
+
+test('writes sidecar .data.json next to output', () => {
+  const { out, cleanup } = setup();
+  try {
+    const outPath = join(out, 'demo.html');
+    const data = JSON.parse(readFileSync(join(fixtures, '_canned.data.json'), 'utf8'));
+    renderReport({
+      templateId: '_canned',
+      data,
+      outPath,
+      manifestPath: join(fixtures, '_canned.manifest.json'),
+      pluginRoot: dirname(fixtures),
+    });
+    const sidecarPath = outPath + '.data.json';
+    const sidecar = JSON.parse(readFileSync(sidecarPath, 'utf8'));
+    assert.equal(sidecar.template, '_canned');
+    assert.deepEqual(sidecar.data, data);
+    assert.ok(sidecar.rendered_at);
+  } finally {
+    cleanup();
+  }
+});
+
+test('throws on missing required slot with template:slot context', () => {
+  const { out, cleanup } = setup();
+  try {
+    assert.throws(
+      () => renderReport({
+        templateId: '_canned',
+        data: { items: [] },
+        outPath: join(out, 'x.html'),
+        manifestPath: join(fixtures, '_canned.manifest.json'),
+        pluginRoot: dirname(fixtures),
+      }),
+      /_canned:title.*required/,
+    );
+  } finally {
+    cleanup();
+  }
+});
+
+test('throws on unknown template id with valid-ids list', () => {
+  const { out, cleanup } = setup();
+  try {
+    assert.throws(
+      () => renderReport({
+        templateId: 'does-not-exist',
+        data: {},
+        outPath: join(out, 'x.html'),
+        manifestPath: join(fixtures, '_canned.manifest.json'),
+        pluginRoot: dirname(fixtures),
+      }),
+      /template not found.*_canned/i,
+    );
+  } finally {
+    cleanup();
+  }
+});
+
+test('inverted section renders fallback when array empty', () => {
+  const { out, cleanup } = setup();
+  try {
+    const outPath = join(out, 'empty.html');
+    renderReport({
+      templateId: '_canned',
+      data: { title: 'Empty', items: [] },
+      outPath,
+      manifestPath: join(fixtures, '_canned.manifest.json'),
+      pluginRoot: dirname(fixtures),
+    });
+    const html = readFileSync(outPath, 'utf8');
+    assert.ok(html.includes('No items.'));
+  } finally {
+    cleanup();
+  }
+});

package/plugins/tech-graph/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "tech-graph",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "Step-by-step wizard for generating technical diagrams as SVG+PNG.",
   "author": {
     "name": "steven"

package/plugins/tech-graph/README.md

@@ -7,8 +7,8 @@ Step-by-step wizard for generating technical diagrams (architecture, flowchart,
 From inside Claude Code:
 
 ```text
-/plugin marketplace add <user>/neptune
-/plugin install tech-graph@neptune
+/plugin marketplace add <user>/agents-and-skills
+/plugin install tech-graph@drunkcoding
 ```
 
 Then run `/tech-graph` (or `/tech-graph "auth flow"` to seed a topic).