codymaster 4.8.0 → 7.0.0

package/public/dashboard/app.js

@@ -288,6 +288,13 @@
         if (e.target.closest('.project-delete-btn')) return;
         selectedProjectId = el.dataset.projectId || null;
         await refreshData();
+        if (ws && ws.readyState === WebSocket.OPEN) {
+          if (selectedProjectId) {
+            ws.send(JSON.stringify({ action: 'subscribe', projectId: selectedProjectId }));
+          } else {
+            ws.send(JSON.stringify({ action: 'unsubscribe' }));
+          }
+        }
       });
     });
 
@@ -926,7 +933,15 @@
   }
 
   // ── Utilities ──────────────────────────────
-  function esc(str) { const d = document.createElement('div'); d.textContent = str; return d.innerHTML; }
+  function esc(str) {
+    if (str == null) return '';
+    return String(str)
+      .replace(/&/g, '&')
+      .replace(/</g, '&lt;')
+      .replace(/>/g, '&gt;')
+      .replace(/"/g, '&quot;')
+      .replace(/'/g, '&#39;');
+  }
   function formatTimeAgo(dateStr) {
     const ms = Date.now() - new Date(dateStr).getTime();
     const m = Math.floor(ms / 60000), h = Math.floor(ms / 3600000), d = Math.floor(ms / 86400000);
@@ -1250,6 +1265,41 @@
     }
   }
 
+  // ── WebSocket Client ─────────────────────────
+  let ws = null;
+  let wsReconnectTimer = null;
+
+  function connectWs() {
+    const protocol = location.protocol === 'https:' ? 'wss:' : 'ws:';
+    ws = new WebSocket(`${protocol}//${location.host}/ws`);
+
+    ws.onopen = () => {
+      console.log('WS connected');
+      if (selectedProjectId) {
+        ws.send(JSON.stringify({ action: 'subscribe', projectId: selectedProjectId }));
+      }
+    };
+
+    ws.onmessage = (event) => {
+      const msg = JSON.parse(event.data);
+      if (msg.type && msg.type.startsWith('task.')) {
+        refreshData(true);
+      }
+      if (msg.type === 'activity.added') {
+        refreshData(true);
+      }
+    };
+
+    ws.onclose = () => {
+      console.log('WS disconnected, falling back to polling');
+      ws = null;
+    };
+
+    ws.onerror = () => {
+      ws = null;
+    };
+  }
+
   // ── Init ───────────────────────────────────────
   async function init() {
     try {
@@ -1261,6 +1311,7 @@
       updateSyncStatus('synced');
       updateAutoRefreshUI();
       startAutoRefresh();
+      connectWs();
     } catch (err) {
       showToast('error', 'Failed to load: ' + err.message);
       updateSyncStatus('error');

package/scripts/build-skills-lock.mjs

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+/**
+ * Build/refresh skills-lock.json with sha256 + version for every skill.
+ *
+ * Usage:
+ *   node scripts/build-skills-lock.mjs           → rewrite skills-lock.json
+ *   node scripts/build-skills-lock.mjs --check   → exit 1 on drift, no write
+ */
+import fs from 'fs';
+import path from 'path';
+import crypto from 'crypto';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const ROOT = path.resolve(__dirname, '..');
+const SKILLS = path.join(ROOT, 'skills');
+const LOCK = path.join(ROOT, 'skills-lock.json');
+
+const args = new Set(process.argv.slice(2));
+const checkOnly = args.has('--check');
+
+function sha256(file) {
+  return crypto.createHash('sha256').update(fs.readFileSync(file)).digest('hex');
+}
+
+function parseFrontmatter(text) {
+  const m = text.match(/^---\n([\s\S]*?)\n---/);
+  if (!m) return {};
+  const out = {};
+  const v = m[1].match(/^version:\s*['"]?([\w.\-+]+)['"]?\s*$/m);
+  if (v) out.version = v[1];
+  const d = m[1].match(/^deprecated:\s*(true|false)\s*$/m);
+  if (d) out.deprecated = d[1] === 'true';
+  return out;
+}
+
+function buildLock() {
+  const skills = {};
+  if (fs.existsSync(SKILLS)) {
+    for (const name of fs.readdirSync(SKILLS).sort()) {
+      if (!name.startsWith('cm-')) continue;
+      const skillFile = path.join(SKILLS, name, 'SKILL.md');
+      if (!fs.existsSync(skillFile)) continue;
+      const text = fs.readFileSync(skillFile, 'utf8');
+      const fm = parseFrontmatter(text);
+      skills[name] = {
+        sha256: sha256(skillFile),
+        ...(fm.version ? { version: fm.version } : {}),
+        ...(fm.deprecated ? { deprecated: true } : {}),
+      };
+    }
+  }
+  return {
+    version: 2,
+    generated_at: new Date().toISOString(),
+    skills,
+  };
+}
+
+const next = buildLock();
+
+if (checkOnly) {
+  if (!fs.existsSync(LOCK)) {
+    console.error('✗ skills-lock.json missing');
+    process.exit(1);
+  }
+  const prev = JSON.parse(fs.readFileSync(LOCK, 'utf8'));
+  const drift = [];
+  for (const [name, entry] of Object.entries(next.skills)) {
+    const before = prev.skills?.[name];
+    if (!before) drift.push(`+ ${name} (new)`);
+    else if (before.sha256 !== entry.sha256) drift.push(`Δ ${name} (hash drift)`);
+  }
+  for (const name of Object.keys(prev.skills ?? {})) {
+    if (!next.skills[name]) drift.push(`- ${name} (removed)`);
+  }
+  if (drift.length) {
+    console.error('✗ skills-lock drift:');
+    for (const line of drift) console.error('  ' + line);
+    console.error('Run `node scripts/build-skills-lock.mjs` to refresh.');
+    process.exit(1);
+  }
+  console.log(`✓ skills-lock OK (${Object.keys(next.skills).length} skills)`);
+  process.exit(0);
+}
+
+fs.writeFileSync(LOCK, JSON.stringify(next, null, 2) + '\n', 'utf8');
+console.log(`✓ wrote skills-lock.json (${Object.keys(next.skills).length} skills)`);

package/scripts/build-skills.mjs

@@ -1,46 +1,157 @@
 #!/usr/bin/env node
 /**
- * Generate SKILL.md from SKILL.md.tmpl + meta.json when present.
- * Usage: node scripts/build-skills.mjs [--check]
+ * Build / sync skills.
+ *
+ * Modes:
+ *   1. Template render — reads skills/<name>/SKILL.md.tmpl + meta.json,
+ *      writes SKILL.md. Always runs.
+ *   2. Multi-platform sync — when --platforms is passed (or --all-platforms),
+ *      mirrors ALL cm-* skill folders + _shared/ into per-platform install dirs.
+ *
+ * Usage:
+ *   node scripts/build-skills.mjs                                 # template only
+ *   node scripts/build-skills.mjs --check                         # template + (when --platforms) drift check
+ *   node scripts/build-skills.mjs --platforms cursor,codex,opencode
+ *   node scripts/build-skills.mjs --all-platforms
  */
 import fs from 'fs';
 import path from 'path';
+import crypto from 'crypto';
 import { fileURLToPath } from 'url';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const skillsRoot = path.join(__dirname, '..', 'skills');
-const check = process.argv.includes('--check');
+const repoRoot = path.join(__dirname, '..');
+const skillsRoot = path.join(repoRoot, 'skills');
+const args = process.argv.slice(2);
+const check = args.includes('--check');
+
+function getFlag(name) {
+  const i = args.indexOf(`--${name}`);
+  if (i === -1) return null;
+  return args[i + 1] ?? '';
+}
+
+const platformsArg = getFlag('platforms');
+const allPlatforms = args.includes('--all-platforms');
+
+// All 14 supported platforms
+const PLATFORM_DIRS = {
+  'claude-code': path.join(repoRoot, '.claude', 'skills'),
+  'claude-desktop': path.join(repoRoot, '.claude-desktop', 'skills'),
+  cursor: path.join(repoRoot, '.cursor-plugin', 'skills'),
+  windsurf: path.join(repoRoot, '.windsurf', 'skills'),
+  antigravity: path.join(repoRoot, '.gemini', 'skills'),
+  codex: path.join(repoRoot, '.codex', 'skills'),
+  opencode: path.join(repoRoot, '.opencode', 'skills'),
+  cline: path.join(repoRoot, '.cline', 'skills'),
+  kiro: path.join(repoRoot, '.kiro', 'skills'),
+  copilot: path.join(repoRoot, '.copilot', 'skills'),
+  aider: path.join(repoRoot, '.aider', 'skills'),
+  continue: path.join(repoRoot, '.continue', 'skills'),
+  'amazon-q': path.join(repoRoot, '.amazonq', 'skills'),
+  amp: path.join(repoRoot, '.amp', 'skills'),
+};
 
 function render(tmpl, vars) {
   return tmpl.replace(/\{\{(\w+)\}\}/g, (_, k) => (vars[k] != null ? String(vars[k]) : `{{${k}}}`));
 }
 
-let tmplCount = 0;
-if (!fs.existsSync(skillsRoot)) process.exit(0);
-
-for (const dir of fs.readdirSync(skillsRoot, { withFileTypes: true })) {
-  if (!dir.isDirectory()) continue;
-  const folder = path.join(skillsRoot, dir.name);
-  const tmplPath = path.join(folder, 'SKILL.md.tmpl');
-  const metaPath = path.join(folder, 'meta.json');
-  const outPath = path.join(folder, 'SKILL.md');
-  if (!fs.existsSync(tmplPath)) continue;
-
-  tmplCount++;
-  const tmpl = fs.readFileSync(tmplPath, 'utf8');
-  let meta = {};
-  if (fs.existsSync(metaPath)) {
-    meta = JSON.parse(fs.readFileSync(metaPath, 'utf8'));
+function sha256(buf) {
+  return crypto.createHash('sha256').update(buf).digest('hex');
+}
+
+function ensureDir(p) {
+  fs.mkdirSync(p, { recursive: true });
+}
+
+function copyFileIdempotent(src, dst) {
+  const srcBuf = fs.readFileSync(src);
+  if (fs.existsSync(dst)) {
+    const dstBuf = fs.readFileSync(dst);
+    if (sha256(srcBuf) === sha256(dstBuf)) return 'skipped';
   }
-  const out = render(tmpl, meta);
-  if (check) {
-    const cur = fs.existsSync(outPath) ? fs.readFileSync(outPath, 'utf8') : '';
-    if (cur !== out) {
-      console.error(`check failed: ${outPath} out of date (run npm run build:skills)`);
-      process.exit(2);
+  if (check) return 'drift';
+  ensureDir(path.dirname(dst));
+  fs.writeFileSync(dst, srcBuf);
+  return 'synced';
+}
+
+function copyDirShallow(srcDir, dstDir) {
+  const result = { synced: 0, skipped: 0, drift: 0 };
+  if (!fs.existsSync(srcDir)) return result;
+  ensureDir(dstDir);
+
+  const skillFile = path.join(srcDir, 'SKILL.md');
+  if (fs.existsSync(skillFile)) {
+    result[copyFileIdempotent(skillFile, path.join(dstDir, 'SKILL.md'))]++;
+  }
+
+  const refDir = path.join(srcDir, 'references');
+  if (fs.existsSync(refDir) && fs.statSync(refDir).isDirectory()) {
+    for (const entry of fs.readdirSync(refDir)) {
+      const s = path.join(refDir, entry);
+      if (fs.statSync(s).isFile()) {
+        result[copyFileIdempotent(s, path.join(dstDir, 'references', entry))]++;
+      }
+    }
+  }
+  return result;
+}
+
+// Copy _shared/ directory recursively
+function copySharedHelpers(srcRoot, dstRoot) {
+  const sharedSrc = path.join(srcRoot, '_shared');
+  const sharedDst = path.join(dstRoot, '_shared');
+  if (!fs.existsSync(sharedSrc)) return { synced: 0, skipped: 0, drift: 0 };
+  
+  const result = { synced: 0, skipped: 0, drift: 0 };
+  ensureDir(sharedDst);
+  
+  for (const entry of fs.readdirSync(sharedSrc)) {
+    const srcFile = path.join(sharedSrc, entry);
+    const dstFile = path.join(sharedDst, entry);
+    if (fs.statSync(srcFile).isFile()) {
+      result[copyFileIdempotent(srcFile, dstFile)]++;
+    }
+  }
+  return result;
+}
+
+// Get ALL cm-* skills from skills/ directory
+function getAllCmSkills() {
+  if (!fs.existsSync(skillsRoot)) return [];
+  return fs.readdirSync(skillsRoot, { withFileTypes: true })
+    .filter(d => d.isDirectory() && d.name.startsWith('cm-'))
+    .map(d => d.name);
+}
+
+// --- Mode 1: template render ---
+let tmplCount = 0;
+if (fs.existsSync(skillsRoot)) {
+  for (const dir of fs.readdirSync(skillsRoot, { withFileTypes: true })) {
+    if (!dir.isDirectory()) continue;
+    const folder = path.join(skillsRoot, dir.name);
+    const tmplPath = path.join(folder, 'SKILL.md.tmpl');
+    const metaPath = path.join(folder, 'meta.json');
+    const outPath = path.join(folder, 'SKILL.md');
+    if (!fs.existsSync(tmplPath)) continue;
+
+    tmplCount++;
+    const tmpl = fs.readFileSync(tmplPath, 'utf8');
+    let meta = {};
+    if (fs.existsSync(metaPath)) {
+      meta = JSON.parse(fs.readFileSync(metaPath, 'utf8'));
+    }
+    const out = render(tmpl, meta);
+    if (check) {
+      const cur = fs.existsSync(outPath) ? fs.readFileSync(outPath, 'utf8') : '';
+      if (cur !== out) {
+        console.error(`check failed: ${outPath} out of date (run npm run build:skills)`);
+        process.exit(2);
+      }
+    } else {
+      fs.writeFileSync(outPath, out, 'utf8');
     }
-  } else {
-    fs.writeFileSync(outPath, out, 'utf8');
   }
 }
 
@@ -49,3 +160,51 @@ if (tmplCount === 0) {
 } else {
   console.log(check ? `build-skills: --check OK (${tmplCount})` : `build-skills: wrote ${tmplCount} skill(s)`);
 }
+
+// --- Mode 2: multi-platform sync ---
+let platforms = [];
+if (allPlatforms) platforms = Object.keys(PLATFORM_DIRS);
+else if (platformsArg) {
+  platforms = platformsArg.split(',').map(s => s.trim()).filter(Boolean);
+}
+
+if (platforms.length > 0) {
+  // Get ALL cm-* skills (not just top 35)
+  const list = getAllCmSkills();
+  console.log(`build-skills: found ${list.length} cm-* skills to sync`);
+
+  for (const platform of platforms) {
+    const dst = PLATFORM_DIRS[platform];
+    if (!dst) {
+      console.error(`build-skills: unknown platform '${platform}' (valid: ${Object.keys(PLATFORM_DIRS).join(',')})`);
+      process.exit(2);
+    }
+    
+    let synced = 0, skipped = 0, drift = 0, missing = 0;
+    
+    // Sync _shared/ helpers
+    const sharedResult = copySharedHelpers(skillsRoot, dst);
+    synced += sharedResult.synced;
+    skipped += sharedResult.skipped;
+    drift += sharedResult.drift;
+    
+    // Sync ALL cm-* skills
+    for (const name of list) {
+      const srcDir = path.join(skillsRoot, name);
+      if (!fs.existsSync(srcDir)) {
+        missing++;
+        console.warn(`  ! ${platform}: skill '${name}' not found in skills/`);
+        continue;
+      }
+      const r = copyDirShallow(srcDir, path.join(dst, name));
+      synced += r.synced; skipped += r.skipped; drift += r.drift;
+    }
+    
+    if (check && drift > 0) {
+      console.error(`build-skills: --check FAILED for ${platform} (drift=${drift})`);
+      process.exit(2);
+    }
+    const tag = check ? 'check' : 'sync';
+    console.log(`build-skills[${platform}] ${tag}: synced=${synced} skipped=${skipped} drift=${drift} missing=${missing} total=${list.length + 1}`);
+  }
+}

package/scripts/compress-skill.mjs

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+/**
+ * Migrate a skill to v2 compressed format.
+ *
+ *   - Adds frontmatter: `token_budget: <N>`, `compressed: true`, `deprecated: false`
+ *   - Inserts `## TL;DR` block after the H1 if not present
+ *   - Preserves the rest of the body verbatim
+ *
+ * Usage:
+ *   node scripts/compress-skill.mjs <skill-name> <token_budget> "<tldr-line-1>" "<tldr-line-2>" ...
+ *
+ * Idempotent: skips skills already marked `compressed: true`.
+ */
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+const [, , name, budgetArg, ...tldrLines] = process.argv;
+if (!name || !budgetArg || tldrLines.length === 0) {
+  console.error('Usage: compress-skill.mjs <skill-name> <token_budget> "<tldr-1>" ["<tldr-2>" ...]');
+  process.exit(1);
+}
+const budget = parseInt(budgetArg, 10);
+if (Number.isNaN(budget) || budget < 100 || budget > 6000) {
+  console.error(`token_budget must be int 100..6000, got: ${budgetArg}`);
+  process.exit(1);
+}
+
+const file = path.join(__dirname, '..', 'skills', name, 'SKILL.md');
+if (!fs.existsSync(file)) {
+  console.error(`✗ ${name}: SKILL.md not found`);
+  process.exit(1);
+}
+
+const original = fs.readFileSync(file, 'utf8');
+if (/^compressed:\s*true/m.test(original)) {
+  console.log(`• ${name}: already compressed, skipping`);
+  process.exit(0);
+}
+
+const fmMatch = original.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+if (!fmMatch) {
+  console.error(`✗ ${name}: missing YAML frontmatter`);
+  process.exit(1);
+}
+let fmText = fmMatch[1];
+const body = fmMatch[2];
+
+// Append fields if missing.
+if (!/^token_budget:/m.test(fmText)) fmText += `\ntoken_budget: ${budget}`;
+if (!/^compressed:/m.test(fmText)) fmText += `\ncompressed: true`;
+if (!/^deprecated:/m.test(fmText)) fmText += `\ndeprecated: false`;
+
+// Insert ## TL;DR after the H1 if absent.
+let newBody = body;
+if (!/^##\s+TL;DR\b/m.test(body)) {
+  const h1 = body.match(/^(#\s+[^\n]+\n)/m);
+  if (!h1) {
+    console.error(`✗ ${name}: missing H1`);
+    process.exit(1);
+  }
+  const tldrBlock =
+    `\n## TL;DR\n` +
+    tldrLines.map((l) => `- ${l}`).join('\n') +
+    `\n`;
+  newBody = body.replace(h1[0], h1[0] + tldrBlock);
+}
+
+const out = `---\n${fmText}\n---\n${newBody}`;
+fs.writeFileSync(file, out, 'utf8');
+console.log(`✓ ${name}: compressed (budget=${budget})`);

package/scripts/deprecate-skill.mjs

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+/**
+ * Deprecate a skill: archives original SKILL.md to SKILL.archive.md
+ * and replaces SKILL.md with a small redirect stub.
+ *
+ * Usage:
+ *   node scripts/deprecate-skill.mjs <skill-name> <merged-into> [reason]
+ *
+ * Idempotent: skips if SKILL.md already has `deprecated: true`.
+ */
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+const [, , name, mergedInto, ...reasonParts] = process.argv;
+if (!name || !mergedInto) {
+  console.error('Usage: deprecate-skill.mjs <skill-name> <merged-into> [reason]');
+  process.exit(1);
+}
+const reason = reasonParts.join(' ') || `consolidated into ${mergedInto}`;
+
+const dir = path.join(__dirname, '..', 'skills', name);
+const file = path.join(dir, 'SKILL.md');
+const archive = path.join(dir, 'SKILL.archive.md');
+
+if (!fs.existsSync(file)) {
+  console.error(`✗ ${name}: SKILL.md not found`);
+  process.exit(1);
+}
+
+const original = fs.readFileSync(file, 'utf8');
+if (/^deprecated:\s*true/m.test(original)) {
+  console.log(`• ${name}: already deprecated, skipping`);
+  process.exit(0);
+}
+
+if (!fs.existsSync(archive)) {
+  fs.writeFileSync(archive, original, 'utf8');
+}
+
+const stub = `---
+name: ${name}
+description: "[Deprecated] ${reason}. Use \`${mergedInto}\` instead."
+deprecated: true
+merged_into: ${mergedInto}
+---
+
+# ${name} — Deprecated
+
+> ⚠️ This skill is deprecated as of CodyMaster v6.0.0 and will be removed in v6.1.0.
+>
+> **Use \`${mergedInto}\` instead.** ${reason}.
+>
+> See [docs/migration-v2.md](../../docs/migration-v2.md) for the full mapping.
+
+The original content is preserved at [SKILL.archive.md](SKILL.archive.md) for reference.
+
+## Migration
+
+\`\`\`bash
+# Old:           cm <use this skill>
+# New (v6.0+):   cm ${mergedInto.replace(/^cm-/, '')} <equivalent action>
+\`\`\`
+
+If you depend on a capability that didn't carry over, please file an issue:
+https://github.com/tody-agent/codymaster/issues
+`;
+
+fs.writeFileSync(file, stub, 'utf8');
+console.log(`✓ ${name} → deprecated, redirects to ${mergedInto}`);