@lifeaitools/rdc-skills 0.24.8 → 0.24.10

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "rdc",
-  "version": "0.24.8",
+  "version": "0.24.10",
   "description": "RDC typed-agent dispatch skill suite for Claude Code — plan, build, review, overnight unattended builds with work-item tracking and TDD enforcement.",
   "author": {
     "name": "LIFEAI",

package/git-sha.json

@@ -1,3 +1,3 @@
 {
-  "sha": "f6df094e61e5c0ece0ac8149e97142c78d04a21c"
+  "sha": "059f644001fd458a08a98fbe92deec0d50db135b"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lifeaitools/rdc-skills",
-  "version": "0.24.8",
+  "version": "0.24.10",
   "description": "RDC typed-agent dispatch skill suite for Claude Code - plan, build, review, overnight builds",
   "keywords": [
     "claude-code",
@@ -37,6 +37,8 @@
     "test:truth-gate": "node tests/run-evidence-gate.test.mjs && node tests/work-item-exit-gate-l2.test.mjs && node tests/work-item-exit-gate-l3.test.mjs && node tests/require-work-item-on-commit.test.mjs && node tests/harness-gates.test.mjs",
     "test:mcp": "node tests/mcp.test.mjs",
     "test:mcp:remote": "node tests/mcp.test.mjs --remote",
+    "test:channel-formatter": "node tests/channel-formatter.contract.test.mjs",
+    "test:channel-formatter:remote": "node tests/channel-formatter.contract.test.mjs --remote",
     "mcp": "node bin/rdc-skills-mcp.mjs",
     "rebuild-mcp": "node scripts/rebuild-mcp.mjs",
     "prepack": "node scripts/prepack.mjs"

package/scripts/install-rdc-skills.js

@@ -88,6 +88,9 @@ const projectRoot = projectRootArg || codexRoot || detectedLifeaiRoot;
 
 const PLUGIN_KEY   = 'rdc-skills@rdc-skills';
 const MARKETPLACE  = 'rdc-skills';
+const NPM_PACKAGE  = '@lifeaitools/rdc-skills';
+const MCP_NAME     = 'rdc-skills-mcp';
+const MCP_PORT     = '3110';
 
 // ── Logging ───────────────────────────────────────────────────────────────────
 const ok   = msg => console.log(`  \x1b[32m✓\x1b[0m ${msg}`);
@@ -95,6 +98,10 @@ const info = msg => console.log(`  \x1b[36m→\x1b[0m ${msg}`);
 const warn = msg => console.log(`  \x1b[33m⚠\x1b[0m ${msg}`);
 const fail = msg => console.log(`  \x1b[31m✗\x1b[0m ${msg}`);
 
+function run(cmd, options = {}) {
+  return execSync(cmd, { encoding: 'utf8', stdio: 'pipe', ...options }).trim();
+}
+
 // ── Filesystem helpers ────────────────────────────────────────────────────────
 function copyDir(src, dst, ext) {
   if (!fs.existsSync(src)) { warn(`Source not found: ${src}`); return 0; }
@@ -248,6 +255,76 @@ function buildPluginCache(cacheDir, version, gitSha) {
   }
 }
 
+function getPm2Process(name) {
+  try {
+    const list = JSON.parse(run('pm2 jlist'));
+    return Array.isArray(list) ? list.find((p) => p.name === name) || null : null;
+  } catch {
+    return null;
+  }
+}
+
+function isGlobalNpmRdcSkillsPath(scriptPath) {
+  if (!scriptPath) return false;
+  const normalized = scriptPath.replace(/\\/g, '/').toLowerCase();
+  return normalized.includes('/node_modules/@lifeaitools/rdc-skills/');
+}
+
+function packageRootFromMcpScript(scriptPath) {
+  return scriptPath ? path.resolve(path.dirname(scriptPath), '..') : null;
+}
+
+function readInstalledPackageVersion(scriptPath) {
+  const packageRoot = packageRootFromMcpScript(scriptPath);
+  if (!packageRoot) return null;
+  return readJson(path.join(packageRoot, 'package.json'), {}).version || null;
+}
+
+function syncGlobalMcpInstall(version) {
+  const proc = getPm2Process(MCP_NAME);
+  if (!proc) {
+    info('[2.9] MCP pkg    — PM2 process not registered yet; start handled below');
+    return;
+  }
+
+  const scriptPath = proc.pm2_env?.pm_exec_path || proc.pm_exec_path || '';
+  if (!isGlobalNpmRdcSkillsPath(scriptPath)) {
+    info(`[2.9] MCP pkg    — PM2 uses source checkout, not global npm (${scriptPath || 'unknown path'})`);
+    return;
+  }
+
+  const installedVersion = readInstalledPackageVersion(scriptPath);
+  if (installedVersion === version) {
+    ok(`[2.9] MCP pkg    — global ${NPM_PACKAGE}@${version} already installed`);
+    return;
+  }
+
+  let stopped = false;
+  let installed = false;
+  try {
+    info(`[2.9] MCP pkg    — updating global ${NPM_PACKAGE} ${installedVersion || '?'} → ${version}`);
+    run(`pm2 stop ${MCP_NAME}`);
+    stopped = true;
+    run(`npm install -g ${NPM_PACKAGE}@${version}`);
+    installed = true;
+    ok(`[2.9] MCP pkg    — installed global ${NPM_PACKAGE}@${version}`);
+  } catch (e) {
+    warn(`[2.9] MCP pkg    — global install failed (${String(e.message || e).split('\n')[0]})`);
+    if (String(e.message || '').includes('EBUSY')) {
+      info('       PM2 was stopped first; if EBUSY persists, another Node/npm process still holds the package directory.');
+    }
+  } finally {
+    if (stopped) {
+      try {
+        run(`pm2 restart ${MCP_NAME} --update-env`, { env: { ...process.env, PORT: MCP_PORT } });
+        ok(`[2.9] MCP pkg    — pm2 restarted ${MCP_NAME}${installed ? '' : ' (previous install restored)'}`);
+      } catch (e) {
+        warn(`[2.9] MCP pkg    — pm2 restart failed (${String(e.message || e).split('\n')[0]})`);
+      }
+    }
+  }
+}
+
 // ── User-skills cleanup ───────────────────────────────────────────────────────
 // Older installer versions wrote skill files directly to ~/.claude/skills/user/.
 // Claude Code loads that directory AND the plugin cache, so any rdc skills left
@@ -753,8 +830,6 @@ function buildHooksConfig(hooksDir, profile = 'core') {
 // under PM2 as `rdc-skills-mcp` on PORT=3110, and prints the claude.ai connector
 // line. Every failure here WARNs — it must never abort the installer.
 function registerMcpServer() {
-  const MCP_NAME = 'rdc-skills-mcp';
-  const MCP_PORT = '3110';
   const binPath = path.join(repoRoot, 'bin', 'rdc-skills-mcp.mjs');
   const connector = 'https://rdc-skills.regendevcorp.com/mcp';
 
@@ -907,12 +982,6 @@ async function main() {
     info(`       created settings.json`);
   }
 
-  // Read version + git SHA once
-  const pkg     = readJson(path.join(repoRoot, 'package.json'));
-  const version = pkg.version || '0.7.0';
-  let   gitSha  = '';
-  try { gitSha = execSync('git rev-parse HEAD', { cwd: repoRoot, encoding: 'utf8', stdio: 'pipe' }).trim(); } catch {}
-
   // 0. Pull latest
   try {
     const before = execSync('git rev-parse HEAD', { cwd: repoRoot, encoding: 'utf8', stdio: 'pipe' }).trim();
@@ -923,6 +992,13 @@ async function main() {
     warn('[0/6] git pull failed — installing from local copy');
   }
 
+  // Read version + git SHA after pull so plugin caches and the MCP install do
+  // not stamp the pre-update checkout.
+  const pkg     = readJson(path.join(repoRoot, 'package.json'));
+  const version = pkg.version || '0.7.0';
+  let   gitSha  = '';
+  try { gitSha = execSync('git rev-parse HEAD', { cwd: repoRoot, encoding: 'utf8', stdio: 'pipe' }).trim(); } catch {}
+
   // 0.5a. User-skills cleanup — remove any rdc: skills from ~/.claude/skills/user/
   // (older installer versions wrote there; plugin cache is the only authoritative source)
   {
@@ -1000,6 +1076,11 @@ async function main() {
     info('[2.6] MCP        — rdc-skills endpoint already registered (claude + codex)');
   }
 
+  // If the live MCP is served from the global npm package, update that exact
+  // install before restarting PM2. Windows otherwise holds the package tree open
+  // and `npm install -g` can fail with EBUSY.
+  syncGlobalMcpInstall(version);
+
   // 2.7. Symlinks in regen-root/.claude/skills/ (FS MCP + claude.ai access)
   if (codexRoot) {
     const skillsLinkDir = path.join(codexRoot, '.claude', 'skills');

package/skills/channel-formatter/SKILL.md

@@ -107,6 +107,12 @@ skills named in the scope boundary.
 > doc" → **`rdc:convert`**. "format this content the Word way / write it for LinkedIn" →
 > this skill. The Word/DOCX and PDF sections below describe target structure only; producing
 > the actual `.docx`/`.pdf` artifact is `rdc:convert` / `rdc:brochure`, not channel-formatter.
+>
+> Specialist routing:
+> - Office/Markdown file conversion → `rdc:convert`
+> - HTML/folder/zip/URL to PDF brochure rendering → `rdc:brochure`
+> - Brochurify orchestration jobs → `rdc:brochurify`
+> - Brochure JSX using `@lifeai/brochure-kit` → `lifeai-brochure-author`
 
 ---
 

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

@@ -0,0 +1,251 @@
+#!/usr/bin/env node
+/**
+ * Contract/system test for rdc:channel-formatter content repurposing.
+ *
+ * This does not test LLM prose generation. rdc:channel-formatter is an
+ * instruction skill served by the MCP, not an executable formatter function.
+ * What this test proves is that local and live MCP discovery return the
+ * expected skill and that the served skill body contains the required
+ * social-pack, campaign-pack, and source-fidelity contracts an agent must obey.
+ *
+ * Every MCP call is written to a JSONL audit log under .rdc/reports/.
+ */
+
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { getSkillBody, listSkills, searchSkills } from '../lib/catalog.mjs';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = path.resolve(__dirname, '..');
+const BIN = path.join(REPO_ROOT, 'bin', 'rdc-skills-mcp.mjs');
+const TEST_PORT = parseInt(process.env.TEST_PORT || '3198', 10);
+const LOCAL = `http://127.0.0.1:${TEST_PORT}/mcp`;
+const LOCAL_HEALTH = `http://127.0.0.1:${TEST_PORT}/health`;
+const REMOTE = 'https://rdc-skills.regendevcorp.com/mcp';
+const REPORT_DIR = path.join(REPO_ROOT, '.rdc', 'reports');
+const REPORT_FILE = path.join(
+  REPORT_DIR,
+  `channel-formatter-contract-${new Date().toISOString().replace(/[:.]/g, '-')}.jsonl`,
+);
+
+fs.mkdirSync(REPORT_DIR, { recursive: true });
+
+let pass = 0;
+let fail = 0;
+const failures = [];
+
+function log(event) {
+  fs.appendFileSync(REPORT_FILE, `${JSON.stringify({ ts: new Date().toISOString(), ...event })}\n`);
+}
+
+function check(name, condition, detail = '') {
+  if (condition) {
+    pass++;
+    log({ kind: 'assertion', name, status: 'pass', detail });
+  } else {
+    fail++;
+    failures.push(`${name}${detail ? ` - ${detail}` : ''}`);
+    log({ kind: 'assertion', name, status: 'fail', detail });
+  }
+}
+
+function resultText(json) {
+  return json?.result?.content?.[0]?.text || '';
+}
+
+function summarizeText(text) {
+  return {
+    length: text.length,
+    hasChannelFormatter: text.includes('channel-formatter'),
+    hasSocialPack: text.includes('social-pack'),
+    hasCampaignPack: text.includes('campaign-pack'),
+    hasStrictFormat: text.includes('strict-format'),
+    hasSourceFidelity: text.includes('Source-Fidelity'),
+    hasUnsupportedClaims: text.includes('unsupported claims') || text.includes('Do not invent statistics'),
+    hasChannelPackUsage: text.includes('<channel|pack>'),
+    hasLinkedIn: text.includes('LinkedIn'),
+    hasTwitterThread: text.includes('Twitter/X thread'),
+    hasSlack: text.includes('Slack/Teams'),
+  };
+}
+
+async function mcp(url, label, body) {
+  const request = {
+    method: body.method,
+    tool: body.params?.name || null,
+    arguments: body.params?.arguments || null,
+  };
+  const res = await fetch(url, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      Accept: 'application/json, text/event-stream',
+      'User-Agent': 'rdc-channel-formatter-contract-test',
+    },
+    body: JSON.stringify(body),
+  });
+  const raw = await res.text();
+  let json = null;
+  if (raw.includes('data:')) {
+    for (const line of raw.split('\n')) {
+      if (line.startsWith('data:')) json = JSON.parse(line.slice(5).trim());
+    }
+  } else if (raw.trim()) {
+    json = JSON.parse(raw);
+  }
+  const text = resultText(json);
+  log({
+    kind: 'mcp_call',
+    label,
+    url,
+    request,
+    status: res.status,
+    response: {
+      hasError: Boolean(json?.error),
+      text: summarizeText(text),
+      resultKeys: json?.result ? Object.keys(json.result) : [],
+    },
+  });
+  return { status: res.status, json, text };
+}
+
+async function waitHealth(url) {
+  for (let i = 0; i < 40; i++) {
+    try {
+      const res = await fetch(url);
+      if (res.ok) return await res.json();
+    } catch {
+      // wait and retry
+    }
+    await new Promise((resolve) => setTimeout(resolve, 150));
+  }
+  throw new Error(`health check timed out: ${url}`);
+}
+
+function inspectFormatterBody(body, prefix) {
+  const required = [
+    ['usage <channel|pack>', '<channel|pack>'],
+    ['social-pack mode', 'social-pack'],
+    ['campaign-pack mode', 'campaign-pack'],
+    ['exec-pack mode', 'exec-pack'],
+    ['launch-pack mode', 'launch-pack'],
+    ['strict-format mode', 'strict-format'],
+    ['long-source extraction', 'Long-Source Extraction'],
+    ['source-fidelity rules', 'Source-Fidelity'],
+    ['unsupported-claims guard', 'unsupported claims'],
+    ['LinkedIn pack output', 'LinkedIn thought-leadership post'],
+    ['Twitter thread pack output', 'Twitter/X thread'],
+    ['Slack pack output', 'Slack/Teams internal share'],
+    ['convert delegate', 'rdc:convert'],
+    ['brochure delegate', 'rdc:brochure'],
+    ['brochurify delegate', 'rdc:brochurify'],
+    ['brochure author delegate', 'lifeai-brochure-author'],
+  ];
+  for (const [name, needle] of required) {
+    check(`${prefix}: body contains ${name}`, body.includes(needle), needle);
+  }
+}
+
+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']) {
+    check(`unit: specialist present ${specialist}`, names.includes(specialist));
+  }
+  const results = searchSkills('turn this article into social posts');
+  check('unit: search top hit is channel-formatter', results[0]?.name === 'channel-formatter', results[0]?.name || 'none');
+  inspectFormatterBody(getSkillBody('channel-formatter') || '', 'unit');
+}
+
+async function endpointChecks(url, label) {
+  await mcp(url, label, {
+    jsonrpc: '2.0',
+    id: `${label}-init`,
+    method: 'initialize',
+    params: {
+      protocolVersion: '2024-11-05',
+      capabilities: {},
+      clientInfo: { name: 'rdc-channel-formatter-contract-test', version: '1' },
+    },
+  });
+
+  const list = await mcp(url, label, {
+    jsonrpc: '2.0',
+    id: `${label}-list`,
+    method: 'tools/call',
+    params: { name: 'rdc_skill_list', arguments: {} },
+  });
+  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']) {
+    check(`${label}: list includes ${specialist}`, names.includes(specialist));
+  }
+
+  const search = await mcp(url, label, {
+    jsonrpc: '2.0',
+    id: `${label}-search-social`,
+    method: 'tools/call',
+    params: { name: 'rdc_skill_search', arguments: { query: 'turn this article into social posts' } },
+  });
+  const searchPayload = JSON.parse(search.text || '{"results":[]}');
+  check(
+    `${label}: article-to-social search routes to channel-formatter`,
+    searchPayload.results[0]?.name === 'channel-formatter',
+    searchPayload.results[0]?.name || 'none',
+  );
+
+  const get = await mcp(url, label, {
+    jsonrpc: '2.0',
+    id: `${label}-get-formatter`,
+    method: 'tools/call',
+    params: { name: 'rdc_skill_get', arguments: { name: 'channel-formatter', variant: 'cli' } },
+  });
+  inspectFormatterBody(get.text, label);
+}
+
+async function main() {
+  log({ kind: 'test_start', reportFile: REPORT_FILE });
+  unitChecks();
+
+  const proc = spawn('node', [BIN], {
+    env: { ...process.env, PORT: String(TEST_PORT) },
+    stdio: 'ignore',
+  });
+  try {
+    const health = await waitHealth(LOCAL_HEALTH);
+    log({ kind: 'health', label: 'integration', health });
+    check('integration: local test server healthy', health.status === 'ok');
+    await endpointChecks(LOCAL, 'integration');
+  } finally {
+    proc.kill();
+  }
+
+  if (process.env.REMOTE || process.argv.includes('--remote')) {
+    const health = await (await fetch('https://rdc-skills.regendevcorp.com/health')).json();
+    log({ kind: 'health', label: 'systems', health });
+    check('systems: remote version is at least 0.24.8', /^0\.(2[4-9]|[3-9]\d)\./.test(health.version), health.version);
+    check('systems: remote skill count includes full catalog', health.skills >= 29, String(health.skills));
+    await endpointChecks(REMOTE, 'systems');
+  } else {
+    log({ kind: 'systems_skipped', reason: 'set REMOTE=1 or pass --remote' });
+  }
+
+  log({ kind: 'test_end', pass, fail, failures });
+  console.log(`channel-formatter contract: ${pass} passed, ${fail} failed`);
+  console.log(`audit log: ${REPORT_FILE}`);
+  if (fail) {
+    for (const failure of failures) console.log(`FAIL: ${failure}`);
+    process.exit(1);
+  }
+}
+
+main().catch((error) => {
+  log({ kind: 'fatal', message: error?.message || String(error), stack: error?.stack || '' });
+  console.error(error);
+  process.exit(1);
+});
+