@rune-kit/rune 2.4.0 → 2.7.0

package/compiler/__tests__/visualizer.test.js

@@ -0,0 +1,325 @@
+import assert from 'node:assert';
+import path from 'node:path';
+import { describe, test } from 'node:test';
+import { fileURLToPath } from 'node:url';
+import { collectGraphData, generateMeshHTML } from '../visualizer.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const RUNE_ROOT = path.resolve(__dirname, '../..');
+const PRO_DIR = path.resolve(RUNE_ROOT, '../../Pro/extensions');
+const BIZ_DIR = path.resolve(RUNE_ROOT, '../../Business/extensions');
+
+// ─── collectGraphData ───
+
+describe('collectGraphData', () => {
+  test('collects nodes for all core skills', async () => {
+    const data = await collectGraphData(RUNE_ROOT);
+    const coreNodes = data.nodes.filter((n) => n.layer !== 'L4');
+    assert.ok(coreNodes.length >= 60, `Expected >= 60 core nodes, got ${coreNodes.length}`);
+  });
+
+  test('collects L4 pack nodes', async () => {
+    const data = await collectGraphData(RUNE_ROOT);
+    const packNodes = data.nodes.filter((n) => n.layer === 'L4');
+    assert.ok(packNodes.length >= 14, `Expected >= 14 pack nodes, got ${packNodes.length}`);
+  });
+
+  test('nodes have required fields', async () => {
+    const data = await collectGraphData(RUNE_ROOT);
+    for (const n of data.nodes) {
+      assert.ok(n.id, 'Node must have id');
+      assert.ok(n.layer, 'Node must have layer');
+      assert.ok(n.tier, 'Node must have tier');
+    }
+  });
+
+  test('nodes have correct layer values', async () => {
+    const data = await collectGraphData(RUNE_ROOT);
+    const validLayers = new Set(['L0', 'L1', 'L2', 'L3', 'L4']);
+    for (const n of data.nodes) {
+      assert.ok(validLayers.has(n.layer), `Invalid layer ${n.layer} for ${n.id}`);
+    }
+  });
+
+  test('collects cross-ref edges', async () => {
+    const data = await collectGraphData(RUNE_ROOT);
+    assert.ok(data.edges.length > 100, `Expected > 100 edges, got ${data.edges.length}`);
+  });
+
+  test('edges reference valid nodes', async () => {
+    const data = await collectGraphData(RUNE_ROOT);
+    const nodeIds = new Set(data.nodes.map((n) => n.id));
+    for (const e of data.edges) {
+      assert.ok(nodeIds.has(e.source), `Edge source ${e.source} not in nodes`);
+    }
+  });
+
+  test('edges have type field', async () => {
+    const data = await collectGraphData(RUNE_ROOT);
+    for (const e of data.edges) {
+      assert.strictEqual(e.type, 'crossref');
+    }
+  });
+
+  test('collects signal edges', async () => {
+    const data = await collectGraphData(RUNE_ROOT);
+    assert.ok(data.signalEdges.length > 0, 'Should have signal edges');
+  });
+
+  test('signal edges have signal name', async () => {
+    const data = await collectGraphData(RUNE_ROOT);
+    for (const e of data.signalEdges) {
+      assert.ok(e.signal, 'Signal edge must have signal name');
+      assert.ok(e.source, 'Signal edge must have source');
+      assert.ok(e.target, 'Signal edge must have target');
+    }
+  });
+
+  test('counts unique signals', async () => {
+    const data = await collectGraphData(RUNE_ROOT);
+    assert.ok(data.signals.length >= 10, `Expected >= 10 signals, got ${data.signals.length}`);
+  });
+
+  test('stats are accurate', async () => {
+    const data = await collectGraphData(RUNE_ROOT);
+    assert.strictEqual(data.stats.nodeCount, data.nodes.length);
+    assert.strictEqual(data.stats.edgeCount, data.edges.length);
+    assert.strictEqual(data.stats.signalEdgeCount, data.signalEdges.length);
+    assert.strictEqual(data.stats.signalCount, data.signals.length);
+  });
+
+  test('includes Pro pack nodes when tier provided', async () => {
+    const data = await collectGraphData(RUNE_ROOT, { pro: PRO_DIR });
+    const proNodes = data.nodes.filter((n) => n.tier === 'pro');
+    if (proNodes.length > 0) {
+      assert.ok(proNodes.length >= 4, `Expected >= 4 pro nodes`);
+      for (const n of proNodes) {
+        assert.strictEqual(n.layer, 'L4');
+        assert.ok(n.id.startsWith('pack:'));
+      }
+    }
+  });
+
+  test('includes Business pack nodes when tier provided', async () => {
+    const data = await collectGraphData(RUNE_ROOT, { business: BIZ_DIR });
+    const bizNodes = data.nodes.filter((n) => n.tier === 'business');
+    if (bizNodes.length > 0) {
+      assert.ok(bizNodes.length >= 4);
+      for (const n of bizNodes) {
+        assert.strictEqual(n.layer, 'L4');
+      }
+    }
+  });
+
+  test('handles non-existent tier paths', async () => {
+    const data = await collectGraphData(RUNE_ROOT, {
+      pro: '/nonexistent',
+      business: '/nonexistent',
+    });
+    const proNodes = data.nodes.filter((n) => n.tier === 'pro');
+    assert.strictEqual(proNodes.length, 0);
+  });
+
+  test('no duplicate node IDs', async () => {
+    const data = await collectGraphData(RUNE_ROOT, { pro: PRO_DIR, business: BIZ_DIR });
+    const ids = data.nodes.map((n) => n.id);
+    const unique = new Set(ids);
+    assert.strictEqual(ids.length, unique.size, 'Duplicate node IDs found');
+  });
+
+  test('L0 has exactly 1 node (skill-router)', async () => {
+    const data = await collectGraphData(RUNE_ROOT);
+    const l0 = data.nodes.filter((n) => n.layer === 'L0');
+    assert.strictEqual(l0.length, 1);
+    assert.strictEqual(l0[0].id, 'skill-router');
+  });
+
+  test('L1 has orchestrator nodes', async () => {
+    const data = await collectGraphData(RUNE_ROOT);
+    const l1 = data.nodes.filter((n) => n.layer === 'L1');
+    assert.ok(l1.length >= 4);
+    const names = l1.map((n) => n.id);
+    assert.ok(names.includes('cook'));
+    assert.ok(names.includes('team'));
+  });
+});
+
+// ─── generateMeshHTML ───
+
+describe('generateMeshHTML', () => {
+  test('generates valid HTML document', async () => {
+    const data = await collectGraphData(RUNE_ROOT);
+    const html = generateMeshHTML(data);
+    assert.ok(html.startsWith('<!DOCTYPE html>'));
+    assert.ok(html.includes('<html'));
+    assert.ok(html.includes('</html>'));
+  });
+
+  test('is self-contained (no CDN links)', async () => {
+    const data = await collectGraphData(RUNE_ROOT);
+    const html = generateMeshHTML(data);
+    assert.ok(!html.includes('cdn.'), 'Should not reference CDN');
+    assert.ok(!html.includes('unpkg.com'), 'Should not reference unpkg');
+    assert.ok(!html.includes('cdnjs.'), 'Should not reference cdnjs');
+  });
+
+  test('embeds graph data as JSON', async () => {
+    const data = await collectGraphData(RUNE_ROOT);
+    const html = generateMeshHTML(data);
+    assert.ok(html.includes('const DATA ='));
+    assert.ok(html.includes('"nodeCount"'));
+  });
+
+  test('includes inline CSS', async () => {
+    const data = await collectGraphData(RUNE_ROOT);
+    const html = generateMeshHTML(data);
+    assert.ok(html.includes('<style>'));
+    assert.ok(html.includes('</style>'));
+  });
+
+  test('includes inline JavaScript', async () => {
+    const data = await collectGraphData(RUNE_ROOT);
+    const html = generateMeshHTML(data);
+    assert.ok(html.includes('<script>'));
+    assert.ok(html.includes('</script>'));
+  });
+
+  test('includes search input', async () => {
+    const data = await collectGraphData(RUNE_ROOT);
+    const html = generateMeshHTML(data);
+    assert.ok(html.includes('id="search"'));
+    assert.ok(html.includes('Search skills'));
+  });
+
+  test('includes layer filter buttons', async () => {
+    const data = await collectGraphData(RUNE_ROOT);
+    const html = generateMeshHTML(data);
+    assert.ok(html.includes('id="filters"'));
+    assert.ok(html.includes('filter-btn'));
+  });
+
+  test('includes detail panel', async () => {
+    const data = await collectGraphData(RUNE_ROOT);
+    const html = generateMeshHTML(data);
+    assert.ok(html.includes('detail-panel'));
+    assert.ok(html.includes('detail-content'));
+  });
+
+  test('includes legend', async () => {
+    const data = await collectGraphData(RUNE_ROOT);
+    const html = generateMeshHTML(data);
+    assert.ok(html.includes('L0 Router'));
+    assert.ok(html.includes('L1 Orchestrator'));
+    assert.ok(html.includes('L2 Workflow'));
+    assert.ok(html.includes('L3 Utility'));
+    assert.ok(html.includes('L4 Extension'));
+    assert.ok(html.includes('Cross-ref'));
+    assert.ok(html.includes('Signal'));
+  });
+
+  test('includes canvas element', async () => {
+    const data = await collectGraphData(RUNE_ROOT);
+    const html = generateMeshHTML(data);
+    assert.ok(html.includes('<canvas id="canvas"'));
+  });
+
+  test('includes layer colors config', async () => {
+    const data = await collectGraphData(RUNE_ROOT);
+    const html = generateMeshHTML(data);
+    assert.ok(html.includes('#f59e0b')); // L0
+    assert.ok(html.includes('#ef4444')); // L1
+    assert.ok(html.includes('#6366f1')); // L2
+    assert.ok(html.includes('#10b981')); // L3
+    assert.ok(html.includes('#8b5cf6')); // L4
+  });
+
+  test('includes tier border colors for paid packs', async () => {
+    const data = await collectGraphData(RUNE_ROOT);
+    const html = generateMeshHTML(data);
+    assert.ok(html.includes('TIER_BORDER'));
+    assert.ok(html.includes('pro'));
+    assert.ok(html.includes('business'));
+  });
+
+  test('handles interaction code', async () => {
+    const data = await collectGraphData(RUNE_ROOT);
+    const html = generateMeshHTML(data);
+    assert.ok(html.includes('mousemove'));
+    assert.ok(html.includes('mousedown'));
+    assert.ok(html.includes('wheel'));
+    assert.ok(html.includes('hitTest'));
+  });
+
+  test('has zoom/pan support', async () => {
+    const data = await collectGraphData(RUNE_ROOT);
+    const html = generateMeshHTML(data);
+    assert.ok(html.includes('cam.zoom'));
+    assert.ok(html.includes('cam.x'));
+  });
+
+  test('HTML escapes data to prevent XSS', async () => {
+    const data = await collectGraphData(RUNE_ROOT);
+    const html = generateMeshHTML(data);
+    assert.ok(html.includes('function esc('));
+    assert.ok(html.includes('&amp;'));
+    assert.ok(html.includes('&lt;'));
+  });
+});
+
+// ─── Graph Properties ───
+
+describe('graph properties', () => {
+  test('graph is connected (most nodes reachable from cook)', async () => {
+    const data = await collectGraphData(RUNE_ROOT);
+    const adj = {};
+    for (const n of data.nodes) adj[n.id] = [];
+    for (const e of data.edges) {
+      if (adj[e.source]) adj[e.source].push(e.target);
+      if (adj[e.target]) adj[e.target].push(e.source);
+    }
+
+    // BFS from cook
+    const visited = new Set();
+    const queue = ['cook'];
+    visited.add('cook');
+    while (queue.length > 0) {
+      const current = queue.shift();
+      for (const neighbor of adj[current] || []) {
+        if (!visited.has(neighbor)) {
+          visited.add(neighbor);
+          queue.push(neighbor);
+        }
+      }
+    }
+
+    // Most core skills should be reachable
+    const coreNodes = data.nodes.filter((n) => n.layer !== 'L4');
+    const reachable = coreNodes.filter((n) => visited.has(n.id));
+    const ratio = reachable.length / coreNodes.length;
+    assert.ok(ratio > 0.5, `Only ${(ratio * 100).toFixed(0)}% of core skills reachable from cook`);
+  });
+
+  test('no self-referencing edges', async () => {
+    const data = await collectGraphData(RUNE_ROOT);
+    for (const e of data.edges) {
+      assert.notStrictEqual(e.source, e.target, `Self-edge found: ${e.source}`);
+    }
+  });
+
+  test('signal edges connect different nodes', async () => {
+    const data = await collectGraphData(RUNE_ROOT);
+    for (const e of data.signalEdges) {
+      assert.notStrictEqual(e.source, e.target, `Signal self-edge: ${e.source} via ${e.signal}`);
+    }
+  });
+
+  test('all layers represented', async () => {
+    const data = await collectGraphData(RUNE_ROOT);
+    const layers = new Set(data.nodes.map((n) => n.layer));
+    assert.ok(layers.has('L0'));
+    assert.ok(layers.has('L1'));
+    assert.ok(layers.has('L2'));
+    assert.ok(layers.has('L3'));
+    assert.ok(layers.has('L4'));
+  });
+});

package/compiler/adapters/antigravity.js

@@ -1,7 +1,13 @@
 /**
  * Google Antigravity (Jules) Adapter
  *
- * Emits .md rule files for .agent/rules/ directory.
+ * Emits SKILL.md files into .agents/skills/{name}/ directories.
+ * Uses the same SKILL.md frontmatter format (name, description)
+ * with markdown body — identical to Codex pattern.
+ *
+ * Antigravity project context: AGENTS.md (+ CLAUDE.md fallback)
+ * Antigravity skills dir: .agents/skills/
+ * Antigravity skill format: .agents/skills/{name}/SKILL.md
  */
 
 import { BRANDING_FOOTER } from '../transforms/branding.js';
@@ -20,14 +26,17 @@ const TOOL_MAP = {
 
 export default {
   name: 'antigravity',
-  outputDir: '.agent/rules',
+  outputDir: '.agents/skills',
   fileExtension: '.md',
   skillPrefix: 'rune-',
   skillSuffix: '',
 
+  useSkillDirectories: true,
+  skillFileName: 'SKILL.md',
+
   transformReference(skillName, raw) {
     const isBackticked = raw.startsWith('`') && raw.endsWith('`');
-    const ref = `the rune-${skillName} rule`;
+    const ref = `the rune-${skillName} skill`;
     return isBackticked ? `\`${ref}\`` : ref;
   },
 
@@ -36,7 +45,8 @@ export default {
   },
 
   generateHeader(skill) {
-    return `# rune-${skill.name}\n\n> Rune ${skill.layer} Skill | ${skill.group}\n\n`;
+    const desc = (skill.description || '').replace(/"/g, '\\"');
+    return ['---', `name: rune-${skill.name}`, `description: "${desc}"`, '---', '', ''].join('\n');
   },
 
   generateFooter() {
@@ -51,6 +61,10 @@ export default {
     return `rune-${skillName}-scripts`;
   },
 
+  referencesDir(skillName) {
+    return `rune-${skillName}-references`;
+  },
+
   postProcess(content) {
     return content.replace(/^context: fork\n/gm, '').replace(/^agent: general-purpose\n/gm, '');
   },

package/compiler/bin/rune.js

@@ -7,6 +7,8 @@
  *   rune init    — Interactive setup for a new project
  *   rune build   — Compile skills for the configured platform
  *   rune doctor  — Validate compiled output
+ *   rune status  — Project dashboard (neofetch-style)
+ *   rune visualize — Interactive mesh graph
  */
 
 import { existsSync } from 'node:fs';
@@ -17,6 +19,8 @@ import { fileURLToPath } from 'node:url';
 import { getAdapter, listPlatforms } from '../adapters/index.js';
 import { formatDoctorResults, runDoctor } from '../doctor.js';
 import { buildAll } from '../emitter.js';
+import { collectStats, renderStatus, renderStatusJson } from '../status.js';
+import { collectGraphData, generateMeshHTML } from '../visualizer.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -48,7 +52,7 @@ function detectPlatform(projectRoot) {
   if (existsSync(path.join(projectRoot, '.claude-plugin'))) return 'claude';
   if (existsSync(path.join(projectRoot, '.cursor'))) return 'cursor';
   if (existsSync(path.join(projectRoot, '.windsurf'))) return 'windsurf';
-  if (existsSync(path.join(projectRoot, '.agent'))) return 'antigravity';
+  if (existsSync(path.join(projectRoot, '.agents'))) return 'antigravity';
   if (existsSync(path.join(projectRoot, '.openclaw'))) return 'openclaw';
   if (existsSync(path.join(projectRoot, '.codex'))) return 'codex';
   if (existsSync(path.join(projectRoot, '.opencode'))) return 'opencode';
@@ -262,6 +266,82 @@ async function cmdDoctor(projectRoot, args) {
   if (!results.healthy) process.exit(1);
 }
 
+async function cmdStatus(projectRoot, args) {
+  const config = await readConfig(projectRoot);
+  const tierSources = resolveTierSources(config?.tiers, projectRoot);
+  const runeRoot =
+    config?.source === '@rune-kit/rune'
+      ? RUNE_ROOT
+      : config?.source
+        ? path.resolve(projectRoot, config.source)
+        : RUNE_ROOT;
+  const platform = config?.platform || detectPlatform(projectRoot) || '';
+
+  const pkg = JSON.parse(await readFile(path.join(RUNE_ROOT, 'package.json'), 'utf-8'));
+  const projectName = path.basename(projectRoot);
+
+  const stats = await collectStats(runeRoot, tierSources);
+
+  if (args.json) {
+    log(renderStatusJson(stats, { version: pkg.version, platform, projectName }));
+  } else {
+    log('');
+    log(renderStatus(stats, { version: pkg.version, platform, projectName }));
+    log('');
+  }
+}
+
+async function cmdVisualize(projectRoot, args) {
+  const config = await readConfig(projectRoot);
+  const tierSources = resolveTierSources(config?.tiers, projectRoot);
+  const runeRoot =
+    config?.source === '@rune-kit/rune'
+      ? RUNE_ROOT
+      : config?.source
+        ? path.resolve(projectRoot, config.source)
+        : RUNE_ROOT;
+
+  logStep('◎', 'Collecting mesh data...');
+  const graphData = await collectGraphData(runeRoot, tierSources);
+
+  logStep(
+    '◎',
+    `Found ${graphData.stats.nodeCount} nodes, ${graphData.stats.edgeCount} edges, ${graphData.stats.signalCount} signals`,
+  );
+
+  const html = generateMeshHTML(graphData);
+
+  const runeDir = path.join(projectRoot, '.rune');
+  if (!existsSync(runeDir)) {
+    const { mkdir: mkdirFs } = await import('node:fs/promises');
+    await mkdirFs(runeDir, { recursive: true });
+  }
+
+  const outputPath = args.output ? path.resolve(projectRoot, args.output) : path.join(runeDir, 'mesh.html');
+
+  const { writeFile: writeFileFs } = await import('node:fs/promises');
+  await writeFileFs(outputPath, html, 'utf-8');
+  logStep('✓', `Mesh visualization written to ${path.relative(projectRoot, outputPath)}`);
+
+  if (args.json) {
+    log(JSON.stringify(graphData, null, 2));
+  } else {
+    // Try to open in browser
+    try {
+      const { exec } = await import('node:child_process');
+      const cmd =
+        process.platform === 'win32'
+          ? `start "" "${outputPath}"`
+          : process.platform === 'darwin'
+            ? `open "${outputPath}"`
+            : `xdg-open "${outputPath}"`;
+      exec(cmd);
+    } catch {
+      /* ignore if browser open fails */
+    }
+  }
+}
+
 // ─── Arg Parsing ───
 
 // Flags that require a string value (not boolean)
@@ -316,6 +396,13 @@ async function main() {
     case 'doctor':
       await cmdDoctor(projectRoot, args);
       break;
+    case 'status':
+      await cmdStatus(projectRoot, args);
+      break;
+    case 'visualize':
+    case 'viz':
+      await cmdVisualize(projectRoot, args);
+      break;
     case 'version':
     case '--version':
     case '-v': {
@@ -333,6 +420,8 @@ async function main() {
       log('    init     Interactive setup (auto-detects platform)');
       log('    build    Compile skills for configured platform');
       log('    doctor   Validate compiled output');
+      log('    status   Project dashboard (skills, signals, packs, health)');
+      log('    visualize  Interactive mesh graph (opens in browser)');
       log('');
       log('  Options:');
       log(