@lifeaitools/rdc-skills 0.31.2 → 0.34.0

package/skills/tests/rdc-regen-media.test.json

@@ -1,29 +1,29 @@
-{
-  "manifest_version": 1,
-  "skill": "rdc:regen-media",
-  "description": "Regen Media uses local keyless Codex gpt-image-2 as the primary image-generation path and avoids live generation under RDC_TEST.",
-  "fixture": {
-    "prompt": "rdc:regen-media generate a 2048x1152 homepage hero image",
-    "env": { "RDC_TEST": "1" }
-  },
-  "assertions": {
-    "exit_code": 0,
-    "commits_made": { "min": 0 },
-    "stdout_contains": ["image_gen", "gpt-image-2"]
-  },
-  "acceptance": {
-    "output_contains": [
-      "image_gen",
-      "gpt-image-2",
-      "--enable image_generation",
-      "RDC_TEST"
-    ],
-    "output_not_contains": [
-      "OPENAI_API_KEY=",
-      "generate_gpt_image is the default",
-      "upload completed",
-      "raw MCP"
-    ]
-  },
-  "teardown": { "reset_branch": true }
-}
+{
+  "manifest_version": 1,
+  "skill": "rdc:regen-media",
+  "description": "Regen Media uses local keyless Codex gpt-image-2 as the primary image-generation path and avoids live generation under RDC_TEST.",
+  "fixture": {
+    "prompt": "rdc:regen-media generate a 2048x1152 homepage hero image",
+    "env": { "RDC_TEST": "1" }
+  },
+  "assertions": {
+    "exit_code": 0,
+    "commits_made": { "min": 0 },
+    "stdout_contains": ["image_gen", "gpt-image-2"]
+  },
+  "acceptance": {
+    "output_contains": [
+      "image_gen",
+      "gpt-image-2",
+      "--enable image_generation",
+      "RDC_TEST"
+    ],
+    "output_not_contains": [
+      "OPENAI_API_KEY=",
+      "generate_gpt_image is the default",
+      "upload completed",
+      "raw MCP"
+    ]
+  },
+  "teardown": { "reset_branch": true }
+}

package/skills/watch/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: rdc:watch
+name: watch
 description: "Usage `rdc:watch` — Initialize a live session-log viewer and report its path; open it only during attended, non-test use. Zero infrastructure — pure filesystem + static HTML."
 ---
 

package/skills/workitems/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: rdc:workitems
+name: workitems
 description: "Usage `rdc:workitems [add|done|status|list|query]` — Manual work item CRUD outside the normal build flow: add to backlog, mark done, update status, list open epics, query by label."
 ---
 

package/tests/channel-formatter.contract.test.mjs

@@ -152,7 +152,7 @@ function inspectFormatterBody(body, prefix) {
 function unitChecks() {
   const names = listSkills().map((skill) => skill.name);
   check('unit: channel-formatter in local catalog', names.includes('channel-formatter'));
-  for (const specialist of ['convert', 'brochure', 'rdc-brochurify', 'lifeai-brochure-author']) {
+  for (const specialist of ['convert', 'brochure', 'brochurify', 'lifeai-brochure-author']) {
     check(`unit: specialist present ${specialist}`, names.includes(specialist));
   }
   const results = searchSkills('turn this article into social posts');
@@ -181,7 +181,7 @@ async function endpointChecks(url, label) {
   const catalog = JSON.parse(list.text || '{"skills":[]}');
   const names = catalog.skills.map((skill) => skill.name);
   check(`${label}: list includes channel-formatter`, names.includes('channel-formatter'));
-  for (const specialist of ['convert', 'brochure', 'rdc-brochurify', 'lifeai-brochure-author']) {
+  for (const specialist of ['convert', 'brochure', 'brochurify', 'lifeai-brochure-author']) {
     check(`${label}: list includes ${specialist}`, names.includes(specialist));
   }
 

package/tests/clauth-plugin-postinstall.test.mjs

@@ -0,0 +1,256 @@
+#!/usr/bin/env node
+/**
+ * `scripts/postinstall.js` self-registers `clauth-plugin.json` with the local
+ * clauth supervisor — and must NEVER be able to fail an install.
+ *
+ * The whole point of the file is its failure behaviour, so that is what is
+ * asserted: absent clauth, non-zero register, a spawn that throws, and a
+ * missing manifest all exit 0 with a printed hint. Also asserted is the path
+ * anchor — during `npm i -g` the cwd is not the package root, so a
+ * cwd-relative manifest path would resolve to nothing and silently no-op.
+ *
+ * Registration is STUBBED, never really invoked: the live managed-plugin root
+ * (%APPDATA%/clauth/supervisor/managed-plugins) holds real registered plugins
+ * that the running daemon reads, and a test has no business writing there.
+ */
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import { createRequire } from 'node:module';
+import { existsSync, mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = resolve(__dirname, '..');
+const script = join(REPO_ROOT, 'scripts', 'postinstall.js');
+const require = createRequire(import.meta.url);
+
+// ---------------------------------------------------------------- 0. wiring
+
+const syntax = spawnSync(process.execPath, ['--check', script], { encoding: 'utf8' });
+assert.equal(syntax.status, 0, syntax.stderr);
+
+const packageJson = JSON.parse(readFileSync(join(REPO_ROOT, 'package.json'), 'utf8'));
+assert.equal(
+  packageJson.scripts.postinstall,
+  'node scripts/postinstall.js',
+  'package.json must run the postinstall registrar on install',
+);
+assert.equal(
+  existsSync(join(REPO_ROOT, 'clauth-plugin.json')),
+  true,
+  'the manifest the postinstall registers must exist in the repo',
+);
+
+const postinstall = require(script);
+
+/** A spawnSync stub that records calls and replays canned results. */
+function stubSpawn(results) {
+  const calls = [];
+  const queue = [...results];
+  const spawn = (command, args, options) => {
+    calls.push({ command, args, options });
+    const next = queue.shift();
+    if (typeof next === 'function') return next();
+    return next ?? { status: 0, stdout: '', stderr: '' };
+  };
+  return { spawn, calls };
+}
+
+function collectLog() {
+  const lines = [];
+  return { log: (line) => lines.push(String(line)), lines };
+}
+
+/**
+ * A child env whose ONLY PATH entry is `dir`, so nothing named `clauth` can
+ * resolve. Windows env vars are case-insensitive, so every existing spelling of
+ * PATH has to be dropped first or the original one wins non-deterministically.
+ */
+function envWithOnlyPath(dir) {
+  const env = {};
+  for (const [key, value] of Object.entries(process.env)) {
+    if (/^path$/i.test(key) || key === postinstall.SKIP_ENV) continue;
+    env[key] = value;
+  }
+  env.PATH = dir;
+  return env;
+}
+
+// ------------------------------------------- 1. clauth absent -> exit 0 + hint
+//
+// Run the real script as a child with PATH stripped to an empty directory, so
+// nothing named `clauth` can resolve. This is the end-to-end form of the
+// contract: a box without clauth still gets a successful install.
+
+const emptyPathDir = mkdtempSync(join(tmpdir(), 'rdc-postinstall-nopath-'));
+try {
+  const run = spawnSync(process.execPath, [script], {
+    cwd: REPO_ROOT,
+    encoding: 'utf8',
+    env: envWithOnlyPath(emptyPathDir),
+  });
+  assert.equal(run.status, 0, `postinstall must exit 0 without clauth on PATH:\n${run.stdout}\n${run.stderr}`);
+  assert.match(
+    run.stdout,
+    /clauth not found/,
+    `expected a "clauth not found" hint, got:\n${run.stdout}`,
+  );
+  assert.match(
+    run.stdout,
+    /clauth plugin register/,
+    'the hint must carry the manual command so a human can finish registration',
+  );
+} finally {
+  rmSync(emptyPathDir, { recursive: true, force: true });
+}
+
+// --------------------------------- 2. clauth present -> register invoked right
+
+{
+  const { spawn, calls } = stubSpawn([
+    { status: 0, stdout: '0.33.0\n', stderr: '' }, // --version probe
+    { status: 0, stdout: 'registered\n', stderr: '' }, // plugin register
+  ]);
+  const { log, lines } = collectLog();
+  const result = postinstall.register({ spawn, log });
+
+  assert.equal(result.outcome, 'registered');
+  assert.equal(calls.length, 2, 'expected a --version probe followed by the register call');
+  assert.equal(calls[0].command, 'clauth');
+  assert.deepEqual(calls[0].args.map(unquote), ['--version']);
+
+  assert.equal(calls[1].command, 'clauth');
+  assert.deepEqual(
+    calls[1].args.map(unquote),
+    ['plugin', 'register', join(REPO_ROOT, 'clauth-plugin.json')],
+    'register must be called as `clauth plugin register <package-root>/clauth-plugin.json`',
+  );
+  assert.ok(calls[1].options.timeout > 0, 'the register call must be time-bounded');
+  assert.match(lines.join('\n'), /registered/);
+}
+
+// ------------------------- 3. non-zero register / throwing spawn -> exit 0 + hint
+
+{
+  const { spawn } = stubSpawn([
+    { status: 0, stdout: '0.33.0\n', stderr: '' },
+    { status: 1, stdout: '', stderr: 'manifest rejected: bad schema\n' },
+  ]);
+  const { log, lines } = collectLog();
+  const result = postinstall.register({ spawn, log });
+
+  assert.equal(result.outcome, 'register-failed', 'a non-zero register must not throw');
+  assert.match(lines.join('\n'), /clauth plugin register failed/);
+  assert.match(lines.join('\n'), /manifest rejected: bad schema/, 'the hint should surface why');
+  assert.match(lines.join('\n'), /retry with: clauth plugin register/);
+}
+
+{
+  // spawn itself blowing up (EPERM, locked binary, AV interference) is still exit 0.
+  const { spawn } = stubSpawn([
+    { status: 0, stdout: '0.33.0\n', stderr: '' },
+    () => {
+      throw new Error('EPERM: operation not permitted');
+    },
+  ]);
+  const { log, lines } = collectLog();
+  const result = postinstall.register({ spawn, log });
+
+  assert.equal(result.outcome, 'spawn-failed');
+  assert.match(lines.join('\n'), /EPERM/);
+}
+
+{
+  // clauth on PATH but broken (`--version` non-zero) reads as "not available".
+  const { spawn, calls } = stubSpawn([{ status: 9009, stdout: '', stderr: 'not recognized' }]);
+  const { log, lines } = collectLog();
+  const result = postinstall.register({ spawn, log });
+
+  assert.equal(result.outcome, 'no-clauth');
+  assert.equal(calls.length, 1, 'a failed probe must not go on to attempt registration');
+  assert.match(lines.join('\n'), /clauth not found/);
+}
+
+{
+  // A package root with no manifest is a hint, not a crash.
+  const bare = mkdtempSync(join(tmpdir(), 'rdc-postinstall-bare-'));
+  try {
+    const { spawn, calls } = stubSpawn([]);
+    const { log, lines } = collectLog();
+    const result = postinstall.register({ packageRoot: bare, spawn, log });
+
+    assert.equal(result.outcome, 'no-manifest');
+    assert.equal(calls.length, 0, 'a missing manifest must not spawn anything');
+    assert.match(lines.join('\n'), /not found/);
+  } finally {
+    rmSync(bare, { recursive: true, force: true });
+  }
+}
+
+// ----------------------------------- 4. the manifest path is package-anchored
+//
+// `npm i -g` runs the postinstall from an arbitrary cwd. Anything cwd-relative
+// would resolve to a path that does not exist and register nothing at all.
+
+{
+  assert.equal(
+    postinstall.manifestPath(),
+    join(REPO_ROOT, 'clauth-plugin.json'),
+    'the default manifest path must be the package root, not the cwd',
+  );
+
+  const foreignCwd = mkdtempSync(join(tmpdir(), 'rdc-postinstall-cwd-'));
+  try {
+    const run = spawnSync(process.execPath, [script], {
+      cwd: foreignCwd, // deliberately NOT the package root
+      encoding: 'utf8',
+      env: envWithOnlyPath(foreignCwd),
+    });
+    assert.equal(run.status, 0, `${run.stdout}\n${run.stderr}`);
+    assert.ok(
+      run.stdout.includes(join(REPO_ROOT, 'clauth-plugin.json')),
+      `hint must name the package-root manifest, not a cwd-relative one:\n${run.stdout}`,
+    );
+    assert.ok(
+      !run.stdout.includes(join(foreignCwd, 'clauth-plugin.json')),
+      'the manifest path must never be resolved against the caller cwd',
+    );
+  } finally {
+    rmSync(foreignCwd, { recursive: true, force: true });
+  }
+}
+
+// --------------------------------- 5. the manifest actually ships in the tarball
+//
+// Self-registration is worthless if `clauth-plugin.json` is not in the package
+// the user installed.
+
+{
+  const pack = spawnSync('npm', ['pack', '--dry-run'], {
+    cwd: REPO_ROOT,
+    encoding: 'utf8',
+    shell: process.platform === 'win32',
+  });
+  assert.equal(pack.status, 0, `npm pack --dry-run failed:\n${pack.stdout}\n${pack.stderr}`);
+  const packOutput = `${pack.stdout}\n${pack.stderr}`;
+  assert.match(
+    packOutput,
+    /clauth-plugin\.json/,
+    'clauth-plugin.json must be present in the published tarball',
+  );
+  assert.match(
+    packOutput,
+    /scripts\/postinstall\.js/,
+    'scripts/postinstall.js must be present in the published tarball',
+  );
+}
+
+/** Strip the Windows shell quoting the script applies to spawn args. */
+function unquote(arg) {
+  const s = String(arg);
+  return s.startsWith('"') && s.endsWith('"') ? s.slice(1, -1).replace(/\\"/g, '"') : s;
+}
+
+console.log('clauth plugin postinstall tests — PASS');

package/tests/mcp.test.mjs

@@ -115,7 +115,7 @@ function unitTests() {
   check('unit: resolves bare skill name', resolveSkillName('build') === 'build');
   check('unit: resolves rdc slash skill name', resolveSkillName('rdc:build') === 'build');
   check('unit: resolves leading slash command form', resolveSkillName('/rdc:build') === 'build');
-  check('unit: resolves specialist slash alias', resolveSkillName('rdc:brochurify') === 'rdc-brochurify');
+  check('unit: resolves specialist slash alias', resolveSkillName('rdc:brochurify') === 'brochurify');
   check('unit: resolves non-rdc specialist name', resolveSkillName('lifeai-brochure-author') === 'lifeai-brochure-author');
 
   // Searchability gate — the dimension the first "100% coverage" missed. Every

package/tests/plugin-cache-clean-install.test.mjs

@@ -0,0 +1,76 @@
+/**
+ * Installing REBUILDS the plugin cache from scratch — a skill removed or renamed
+ * upstream must not survive in it.
+ *
+ * Claude Code registers whatever sits in the plugin cache, so anything left behind
+ * there keeps registering. A rename like `skills/rdc-brochurify/` ->
+ * `skills/brochurify/` would otherwise leave the old folder in place and the box
+ * would register BOTH `rdc:brochurify` and the double-namespaced
+ * `rdc:rdc-brochurify` — the shape of the malformed registrations this branch fixes.
+ *
+ * The installer already gets this right: both call sites `fs.rmSync(latestDir, ...)`
+ * immediately before `buildPluginCache(latestDir, ...)`. This test exists to keep it
+ * that way, because the guarantee lives in two separate places and neither states
+ * that it is load-bearing.
+ *
+ * WORTH RECORDING, because it nearly went the other way: the first version of this
+ * file shipped alongside an "obvious" fix to buildPluginCache — clear each payload
+ * directory before copying into it — on the theory that copy-over-merge was leaving
+ * the stale folders. Reverting that fix and re-running left the test GREEN, which is
+ * what exposed the diagnosis as wrong: the wipe already happens one level up, at the
+ * caller. Without that control run, a redundant change and a test that could not
+ * detect its own subject would both have shipped, and the real source of the stale
+ * registrations would have stayed hidden behind an apparent fix.
+ */
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const INSTALLER = path.join(ROOT, 'scripts', 'install-rdc-skills.js');
+
+function runInstaller(claudeHome) {
+  try {
+    return execFileSync(process.execPath, [INSTALLER, '--claude-home', claudeHome, '--skip-hooks'], {
+      encoding: 'utf8', timeout: 300_000, cwd: ROOT,
+    });
+  } catch (err) {
+    return `${err.stdout || ''}${err.stderr || ''}`;
+  }
+}
+
+test('a stale skill directory in the plugin cache does not survive an install', () => {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'rdcskills-home-'));
+
+  const first = runInstaller(home);
+  // The cache carries a version segment: cache/<marketplace>/<plugin>/<version>/skills
+  const cache = path.join(home, 'plugins', 'cache', 'rdc-skills', 'rdc-skills', 'latest', 'skills');
+  assert.ok(fs.existsSync(cache), `expected a plugin skills cache — installer said:\n${first.slice(-800)}`);
+
+  // Plant exactly the shape the defect produces: a skill folder that no longer exists
+  // upstream, carrying the double-namespaced name.
+  const stale = path.join(cache, 'rdc-brochurify');
+  fs.mkdirSync(stale, { recursive: true });
+  fs.writeFileSync(path.join(stale, 'SKILL.md'), '---\nname: rdc-brochurify\n---\nstale\n');
+  assert.ok(fs.existsSync(stale), 'precondition: decoy planted');
+
+  runInstaller(home);
+  assert.ok(!fs.existsSync(stale), 'a skill removed upstream must not survive in the cache');
+  assert.ok(
+    fs.readdirSync(cache).length > 0,
+    'control: the cache must still hold real skills — an empty cache would satisfy the assertion above for the wrong reason',
+  );
+});
+
+test('no rdc-prefixed skill directory ships in the repo', () => {
+  // The plugin is already named `rdc`, so a directory named `rdc-x` registers as
+  // `rdc:rdc-x`. This is the source-side half of the same defect, and it is the half
+  // that actually produced the malformed names.
+  const skills = path.join(ROOT, 'skills');
+  const bad = fs.readdirSync(skills).filter((d) => /^rdc-/.test(d));
+  assert.deepEqual(bad, [], `these register as rdc:rdc-*: ${bad.join(', ')}`);
+});

package/tests/plugin-namespace-names.test.mjs

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+/**
+ * Regression guard: the plugin namespace is applied ONCE.
+ *
+ * `.claude-plugin/plugin.json` declares `"name": "rdc"`. Claude Code registers a
+ * plugin component as `<plugin>:<declared frontmatter name>`. So any component
+ * that ALSO spells the namespace into its own `name:` gets it twice, and the
+ * menu renders `/rdc:rdc:plan` beside `/rdc:plan` — one entry per source.
+ *
+ * That defect was fixed for `commands/` in 643e198 ("the plugin namespace
+ * already says rdc — stop saying it twice") and `skills/` was never migrated,
+ * so 31 skills kept declaring `name: rdc:<x>` and two more carried the
+ * namespace in their DIRECTORY name (`skills/rdc-brochurify/`), composing to
+ * `rdc:rdc-brochurify`.
+ *
+ * Why the existing guards missed it: `tests/manifest-contract-fields.test.mjs`
+ * and `tests/mcp.test.mjs` both assert `!/^rdc:rdc-/` against
+ * `plugin.json.skills_meta[].slash` — a HAND-AUTHORED field that was already
+ * spelled correctly (`rdc:brochurify`). Nothing asserted anything about the
+ * frontmatter `name:` or the directory name, which is what the loader actually
+ * composes from. This test checks the registering artifact, not the aspiration.
+ */
+import assert from 'node:assert/strict';
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const root = resolve(__dirname, '..');
+
+const plugin = JSON.parse(readFileSync(join(root, '.claude-plugin', 'plugin.json'), 'utf8'));
+const PLUGIN = plugin.name;
+assert.ok(PLUGIN, '.claude-plugin/plugin.json must declare a plugin name');
+
+/** Declared `name:` from a markdown frontmatter block, or null when absent. */
+function declaredName(file) {
+  const raw = readFileSync(file, 'utf8').replace(/\r\n/g, '\n');
+  const block = raw.match(/^---\n([\s\S]*?)\n---/);
+  if (!block) return null;
+  const line = block[1].split('\n').find((l) => /^name:\s*/.test(l));
+  return line ? line.replace(/^name:\s*/, '').trim().replace(/^["']|["']$/g, '') : null;
+}
+
+/** Every registering component: its file, the id it composes to, and its source. */
+function components() {
+  const out = [];
+
+  const cmdDir = join(root, 'commands');
+  if (existsSync(cmdDir)) {
+    for (const f of readdirSync(cmdDir).filter((f) => f.endsWith('.md')).sort()) {
+      const file = join(cmdDir, f);
+      out.push({
+        kind: 'command',
+        file: `commands/${f}`,
+        dir: f.replace(/\.md$/, ''),
+        declared: declaredName(file),
+      });
+    }
+  }
+
+  const skillsDir = join(root, 'skills');
+  for (const entry of readdirSync(skillsDir, { withFileTypes: true })) {
+    if (!entry.isDirectory() || entry.name === 'tests') continue;
+    const file = join(skillsDir, entry.name, 'SKILL.md');
+    if (!existsSync(file)) continue;
+    out.push({
+      kind: 'skill',
+      file: `skills/${entry.name}/SKILL.md`,
+      dir: entry.name,
+      declared: declaredName(file),
+    });
+  }
+
+  return out;
+}
+
+const all = components();
+assert.ok(all.length > 0, 'expected at least one plugin component to check');
+
+const offenders = { doublePrefixed: [], dirPrefixed: [] };
+
+for (const c of all) {
+  // The loader falls back to the directory / file stem when `name:` is absent.
+  const effective = c.declared ?? c.dir;
+
+  // 1. The declared name must not repeat the plugin namespace.
+  //    `name: rdc:plan` under plugin `rdc` composes to `rdc:rdc:plan`.
+  if (effective === PLUGIN || effective.startsWith(`${PLUGIN}:`)) {
+    offenders.doublePrefixed.push(`${c.file}  name: ${effective}  ->  ${PLUGIN}:${effective}`);
+  }
+
+  // 2. Same defect, hyphen spelling: a directory named `rdc-brochurify`
+  //    composes to `rdc:rdc-brochurify`.
+  if (effective.startsWith(`${PLUGIN}-`)) {
+    offenders.dirPrefixed.push(`${c.file}  name: ${effective}  ->  ${PLUGIN}:${effective}`);
+  }
+}
+
+assert.deepEqual(
+  offenders.doublePrefixed,
+  [],
+  `these components spell the "${PLUGIN}" namespace twice — the plugin supplies it:\n  ` +
+    offenders.doublePrefixed.join('\n  '),
+);
+
+assert.deepEqual(
+  offenders.dirPrefixed,
+  [],
+  `these components carry the "${PLUGIN}-" namespace in their own name — the plugin supplies it:\n  ` +
+    offenders.dirPrefixed.join('\n  '),
+);
+
+// 3. No two components of the same kind may compose to the same registered id.
+for (const kind of ['command', 'skill']) {
+  const seen = new Map();
+  for (const c of all.filter((c) => c.kind === kind)) {
+    const id = `${PLUGIN}:${c.declared ?? c.dir}`;
+    if (seen.has(id)) {
+      assert.fail(`duplicate ${kind} registration ${id}: ${seen.get(id)} and ${c.file}`);
+    }
+    seen.set(id, c.file);
+  }
+}
+
+console.log(`plugin namespace name tests — PASS (${all.length} components, namespace "${PLUGIN}")`);