@rune-kit/rune 2.6.0 → 2.8.0

package/compiler/__tests__/status.test.js

@@ -0,0 +1,336 @@
+import assert from 'node:assert';
+import path from 'node:path';
+import { describe, test } from 'node:test';
+import { fileURLToPath } from 'node:url';
+import { collectStats, renderStatus, renderStatusJson } from '../status.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');
+
+// ─── collectStats ───
+
+describe('collectStats', () => {
+  test('collects core skill count', async () => {
+    const stats = await collectStats(RUNE_ROOT);
+    assert.ok(stats.skillCount >= 60, `Expected >= 60 skills, got ${stats.skillCount}`);
+  });
+
+  test('counts skills by layer', async () => {
+    const stats = await collectStats(RUNE_ROOT);
+    assert.strictEqual(stats.layers.L0, 1);
+    assert.ok(stats.layers.L1 >= 4);
+    assert.ok(stats.layers.L2 >= 25);
+    assert.ok(stats.layers.L3 >= 20);
+  });
+
+  test('counts signals', async () => {
+    const stats = await collectStats(RUNE_ROOT);
+    assert.ok(stats.signalCount >= 10, `Expected >= 10 signals, got ${stats.signalCount}`);
+  });
+
+  test('builds signal map with emitters and listeners', async () => {
+    const stats = await collectStats(RUNE_ROOT);
+    assert.ok(Object.keys(stats.signalMap.emitters).length > 0);
+    assert.ok(Object.keys(stats.signalMap.listeners).length > 0);
+  });
+
+  test('counts connections', async () => {
+    const stats = await collectStats(RUNE_ROOT);
+    assert.ok(stats.totalConnections > 100);
+    assert.ok(parseFloat(stats.avgConnections) > 1);
+  });
+
+  test('discovers free packs', async () => {
+    const stats = await collectStats(RUNE_ROOT);
+    assert.ok(stats.freePacks.length >= 14);
+  });
+
+  test('detects free tier when no tier sources', async () => {
+    const stats = await collectStats(RUNE_ROOT);
+    assert.strictEqual(stats.tier, 'free');
+  });
+
+  test('detects pro tier when pro sources exist', async () => {
+    const stats = await collectStats(RUNE_ROOT, { pro: PRO_DIR });
+    if (stats.proPacks.length > 0) {
+      assert.strictEqual(stats.tier, 'pro');
+    }
+  });
+
+  test('detects business tier when business sources exist', async () => {
+    const stats = await collectStats(RUNE_ROOT, { pro: PRO_DIR, business: BIZ_DIR });
+    if (stats.bizPacks.length > 0) {
+      assert.strictEqual(stats.tier, 'business');
+    }
+  });
+
+  test('counts pro pack lines', async () => {
+    const stats = await collectStats(RUNE_ROOT, { pro: PRO_DIR });
+    for (const pack of stats.proPacks) {
+      assert.ok(pack.name, 'Pack should have a name');
+      assert.ok(pack.lines > 0, `Pack ${pack.name} should have lines`);
+    }
+  });
+
+  test('counts business pack lines', async () => {
+    const stats = await collectStats(RUNE_ROOT, { business: BIZ_DIR });
+    for (const pack of stats.bizPacks) {
+      assert.ok(pack.name);
+      assert.ok(pack.lines > 0);
+    }
+  });
+
+  test('handles non-existent tier paths gracefully', async () => {
+    const stats = await collectStats(RUNE_ROOT, {
+      pro: '/nonexistent/path',
+      business: '/nonexistent/path',
+    });
+    assert.deepStrictEqual(stats.proPacks, []);
+    assert.deepStrictEqual(stats.bizPacks, []);
+    assert.strictEqual(stats.tier, 'free');
+  });
+
+  test('returns parsedSkills array', async () => {
+    const stats = await collectStats(RUNE_ROOT);
+    assert.strictEqual(stats.parsedSkills.length, stats.skillCount);
+    for (const skill of stats.parsedSkills) {
+      assert.ok(skill.name);
+    }
+  });
+});
+
+// ─── renderStatus ───
+
+describe('renderStatus', () => {
+  test('renders box with Unicode borders', async () => {
+    const stats = await collectStats(RUNE_ROOT);
+    const output = renderStatus(stats);
+    assert.ok(output.includes('╭'));
+    assert.ok(output.includes('╰'));
+    assert.ok(output.includes('│'));
+  });
+
+  test('shows tier icon — free', async () => {
+    const stats = await collectStats(RUNE_ROOT);
+    const output = renderStatus(stats);
+    assert.ok(output.includes('🔮 Rune'));
+  });
+
+  test('shows tier icon — pro', async () => {
+    const stats = await collectStats(RUNE_ROOT, { pro: PRO_DIR });
+    if (stats.tier === 'pro') {
+      const output = renderStatus(stats);
+      assert.ok(output.includes('⚡ Rune Pro'));
+    }
+  });
+
+  test('shows tier icon — business', async () => {
+    const stats = await collectStats(RUNE_ROOT, { pro: PRO_DIR, business: BIZ_DIR });
+    if (stats.tier === 'business') {
+      const output = renderStatus(stats);
+      assert.ok(output.includes('🏢 Rune Business'));
+    }
+  });
+
+  test('shows skill count with layer breakdown', async () => {
+    const stats = await collectStats(RUNE_ROOT);
+    const output = renderStatus(stats);
+    assert.match(output, /Skills\s+\d+ core/);
+    assert.ok(output.includes('L0:'));
+    assert.ok(output.includes('L1:'));
+    assert.ok(output.includes('L2:'));
+    assert.ok(output.includes('L3:'));
+  });
+
+  test('shows pack counts', async () => {
+    const stats = await collectStats(RUNE_ROOT);
+    const output = renderStatus(stats);
+    assert.match(output, /Packs\s+\d+ free/);
+  });
+
+  test('shows signal count', async () => {
+    const stats = await collectStats(RUNE_ROOT);
+    const output = renderStatus(stats);
+    assert.match(output, /Signals\s+\d+ defined/);
+  });
+
+  test('shows mesh connections', async () => {
+    const stats = await collectStats(RUNE_ROOT);
+    const output = renderStatus(stats);
+    assert.match(output, /Mesh\s+\d+\+ connections/);
+  });
+
+  test('shows health progress bar', async () => {
+    const stats = await collectStats(RUNE_ROOT);
+    const output = renderStatus(stats);
+    assert.ok(output.includes('▓'));
+    assert.ok(output.includes('mesh health'));
+  });
+
+  test('shows active signals section', async () => {
+    const stats = await collectStats(RUNE_ROOT);
+    const output = renderStatus(stats);
+    assert.ok(output.includes('Active Signals'));
+    assert.ok(output.includes('→'));
+  });
+
+  test('shows project info when provided', async () => {
+    const stats = await collectStats(RUNE_ROOT);
+    const output = renderStatus(stats, {
+      version: '2.6.0',
+      platform: 'cursor',
+      projectName: 'my-app',
+    });
+    assert.ok(output.includes('my-app'));
+    assert.ok(output.includes('cursor'));
+    assert.ok(output.includes('2.6.0'));
+  });
+
+  test('shows Pro pack section for pro tier', async () => {
+    const stats = await collectStats(RUNE_ROOT, { pro: PRO_DIR });
+    if (stats.proPacks.length > 0) {
+      const output = renderStatus(stats);
+      assert.ok(output.includes('Pro Packs'));
+      assert.ok(output.includes('@rune-pro/'));
+      assert.ok(output.includes('lines'));
+    }
+  });
+
+  test('shows Business pack section for business tier', async () => {
+    const stats = await collectStats(RUNE_ROOT, { pro: PRO_DIR, business: BIZ_DIR });
+    if (stats.bizPacks.length > 0) {
+      const output = renderStatus(stats);
+      assert.ok(output.includes('Business Packs'));
+      assert.ok(output.includes('@rune-biz/'));
+    }
+  });
+
+  test('omits Pro/Biz sections for free tier', async () => {
+    const stats = await collectStats(RUNE_ROOT);
+    const output = renderStatus(stats);
+    assert.ok(!output.includes('Pro Packs'));
+    assert.ok(!output.includes('Business Packs'));
+  });
+});
+
+// ─── renderStatusJson ───
+
+describe('renderStatusJson', () => {
+  test('returns valid JSON', async () => {
+    const stats = await collectStats(RUNE_ROOT);
+    const parsed = JSON.parse(renderStatusJson(stats));
+    assert.ok(parsed);
+  });
+
+  test('includes tier field', async () => {
+    const stats = await collectStats(RUNE_ROOT);
+    const parsed = JSON.parse(renderStatusJson(stats));
+    assert.ok(['free', 'pro', 'business'].includes(parsed.tier));
+  });
+
+  test('includes skills with layers', async () => {
+    const stats = await collectStats(RUNE_ROOT);
+    const parsed = JSON.parse(renderStatusJson(stats));
+    assert.ok(parsed.skills.total >= 60);
+    assert.strictEqual(parsed.skills.layers.L0, 1);
+  });
+
+  test('includes packs breakdown', async () => {
+    const stats = await collectStats(RUNE_ROOT);
+    const parsed = JSON.parse(renderStatusJson(stats));
+    assert.ok(parsed.packs.free >= 14);
+    assert.ok(Array.isArray(parsed.packs.pro));
+    assert.ok(Array.isArray(parsed.packs.business));
+  });
+
+  test('includes signal data with top signals', async () => {
+    const stats = await collectStats(RUNE_ROOT);
+    const parsed = JSON.parse(renderStatusJson(stats));
+    assert.ok(parsed.signals.count >= 10);
+    assert.ok(parsed.signals.top.length > 0);
+    for (const sig of parsed.signals.top) {
+      assert.ok(sig.name);
+      assert.ok(Array.isArray(sig.emitters));
+      assert.ok(Array.isArray(sig.listeners));
+    }
+  });
+
+  test('includes mesh stats', async () => {
+    const stats = await collectStats(RUNE_ROOT);
+    const parsed = JSON.parse(renderStatusJson(stats));
+    assert.ok(parsed.mesh.connections > 100);
+    assert.ok(parsed.mesh.avgPerSkill > 1);
+  });
+
+  test('includes health score 0-100', async () => {
+    const stats = await collectStats(RUNE_ROOT);
+    const parsed = JSON.parse(renderStatusJson(stats));
+    assert.ok(parsed.health >= 0);
+    assert.ok(parsed.health <= 100);
+  });
+
+  test('includes project info when provided', async () => {
+    const stats = await collectStats(RUNE_ROOT);
+    const parsed = JSON.parse(renderStatusJson(stats, { version: '2.6.0', platform: 'cursor', projectName: 'test' }));
+    assert.strictEqual(parsed.project, 'test');
+    assert.strictEqual(parsed.platform, 'cursor');
+    assert.strictEqual(parsed.version, '2.6.0');
+  });
+
+  test('pro packs include name and lines', async () => {
+    const stats = await collectStats(RUNE_ROOT, { pro: PRO_DIR });
+    const parsed = JSON.parse(renderStatusJson(stats));
+    for (const pack of parsed.packs.pro) {
+      assert.ok(pack.name);
+      assert.ok(pack.lines > 0);
+    }
+  });
+});
+
+// ─── Health Score ───
+
+describe('health score', () => {
+  test('free tier has reasonable health', async () => {
+    const stats = await collectStats(RUNE_ROOT);
+    const parsed = JSON.parse(renderStatusJson(stats));
+    assert.ok(parsed.health >= 70, `Health ${parsed.health} should be >= 70`);
+  });
+
+  test('business tier health >= free tier health', async () => {
+    const freeStats = await collectStats(RUNE_ROOT);
+    const bizStats = await collectStats(RUNE_ROOT, { pro: PRO_DIR, business: BIZ_DIR });
+
+    const freeHealth = JSON.parse(renderStatusJson(freeStats)).health;
+    const bizHealth = JSON.parse(renderStatusJson(bizStats)).health;
+    assert.ok(bizHealth >= freeHealth, `Biz ${bizHealth} should be >= Free ${freeHealth}`);
+  });
+});
+
+// ─── Box Rendering ───
+
+describe('box rendering', () => {
+  test('all box lines end with correct border char', async () => {
+    const stats = await collectStats(RUNE_ROOT);
+    const output = renderStatus(stats);
+    const lines = output.split('\n');
+    const boxLines = lines.filter((l) => l.startsWith('│') || l.startsWith('╭') || l.startsWith('╰'));
+
+    for (const line of boxLines) {
+      const lastChar = line.trimEnd().slice(-1);
+      assert.ok(
+        ['│', '╮', '╯'].includes(lastChar),
+        `Line should end with border char, got: "${lastChar}" in "${line}"`,
+      );
+    }
+  });
+
+  test('box has exactly one top and one bottom border', async () => {
+    const stats = await collectStats(RUNE_ROOT);
+    const output = renderStatus(stats);
+    const lines = output.split('\n');
+    assert.strictEqual(lines.filter((l) => l.startsWith('╭')).length, 1);
+    assert.strictEqual(lines.filter((l) => l.startsWith('╰')).length, 1);
+  });
+});

package/compiler/__tests__/templates.test.js

@@ -0,0 +1,245 @@
+import assert from 'node:assert';
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import { describe, test } from 'node:test';
+import { fileURLToPath } from 'node:url';
+import { parseSkill, parseTemplate } from '../parser.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const PRO_DIR = path.resolve(__dirname, '../../../Pro/extensions');
+
+// Signal naming: lowercase, dot-separated (same as validate-signals.js)
+const SIGNAL_NAME_PATTERN = /^[a-z][a-z0-9]*(\.[a-z][a-z0-9]*)+$/;
+
+describe('parseTemplate', () => {
+  test('parses template frontmatter correctly', () => {
+    const content = [
+      '---',
+      'name: test-workflow',
+      'pack: "@rune-pro/product"',
+      'version: "1.0.0"',
+      'description: A test workflow template',
+      'domain: product',
+      'chain: full',
+      'signals:',
+      '  emit: product.test.complete',
+      '  listen: codebase.scanned',
+      'connections:',
+      '  - ba',
+      '  - plan',
+      '  - brainstorm',
+      '---',
+      '',
+      '# Template: Test Workflow',
+      '',
+      '## Phases',
+      '',
+      '### Phase 1: Setup',
+      '**Skills**: `rune:ba`',
+    ].join('\n');
+
+    const parsed = parseTemplate(content);
+
+    assert.strictEqual(parsed.name, 'test-workflow');
+    assert.strictEqual(parsed.pack, '@rune-pro/product');
+    assert.strictEqual(parsed.version, '1.0.0');
+    assert.strictEqual(parsed.domain, 'product');
+    assert.strictEqual(parsed.chain, 'full');
+    assert.deepStrictEqual(parsed.signals.emit, ['product.test.complete']);
+    assert.deepStrictEqual(parsed.signals.listen, ['codebase.scanned']);
+    assert.deepStrictEqual(parsed.connections, ['ba', 'plan', 'brainstorm']);
+    assert.ok(parsed.sections.has('Phases'));
+  });
+
+  test('handles multiple emit signals', () => {
+    const content = [
+      '---',
+      'name: multi-emit',
+      'signals:',
+      '  emit: signal.one, signal.two, signal.three',
+      '  listen: signal.input',
+      '---',
+      '',
+      '# Multi-emit template',
+    ].join('\n');
+
+    const parsed = parseTemplate(content);
+    assert.deepStrictEqual(parsed.signals.emit, ['signal.one', 'signal.two', 'signal.three']);
+    assert.deepStrictEqual(parsed.signals.listen, ['signal.input']);
+  });
+
+  test('handles no signals gracefully', () => {
+    const content = ['---', 'name: no-signals', 'domain: test', '---', '', '# Template without signals'].join('\n');
+
+    const parsed = parseTemplate(content);
+    assert.deepStrictEqual(parsed.signals.emit, []);
+    assert.deepStrictEqual(parsed.signals.listen, []);
+  });
+
+  test('handles no connections gracefully', () => {
+    const content = ['---', 'name: no-connections', '---', '', '# Template without connections'].join('\n');
+
+    const parsed = parseTemplate(content);
+    assert.deepStrictEqual(parsed.connections, []);
+  });
+
+  test('defaults chain to standard', () => {
+    const content = ['---', 'name: default-chain', '---', '', '# Template'].join('\n');
+
+    const parsed = parseTemplate(content);
+    assert.strictEqual(parsed.chain, 'standard');
+  });
+
+  test('extracts cross-references from body', () => {
+    const content = [
+      '---',
+      'name: with-refs',
+      '---',
+      '',
+      '# Template',
+      '',
+      'Uses `rune:ba` and `rune:plan` for setup.',
+    ].join('\n');
+
+    const parsed = parseTemplate(content);
+    assert.strictEqual(parsed.crossRefs.length, 2);
+    assert.strictEqual(parsed.crossRefs[0].skillName, 'ba');
+    assert.strictEqual(parsed.crossRefs[1].skillName, 'plan');
+  });
+});
+
+describe('YAML list parsing in frontmatter', () => {
+  // This tests the parser's ability to handle YAML list items (- item)
+  // which was added for template connections support
+  test('parses YAML list items under nested key', () => {
+    const content = [
+      '---',
+      'name: yaml-list-test',
+      'connections:',
+      '  - alpha',
+      '  - beta',
+      '  - gamma-delta',
+      '---',
+      '',
+      '# Test',
+    ].join('\n');
+
+    const parsed = parseTemplate(content);
+    assert.deepStrictEqual(parsed.connections, ['alpha', 'beta', 'gamma-delta']);
+  });
+
+  test('YAML list does not break existing key-value nested blocks', () => {
+    // Ensure the parser still handles metadata: { key: value } correctly
+    const content = [
+      '---',
+      'name: skill-test',
+      'description: Test',
+      'metadata:',
+      '  layer: L2',
+      '  model: sonnet',
+      '  emit: code.changed',
+      '---',
+      '',
+      '# skill-test',
+    ].join('\n');
+
+    const parsed = parseSkill(content);
+    assert.strictEqual(parsed.name, 'skill-test');
+    assert.strictEqual(parsed.layer, 'L2');
+    assert.strictEqual(parsed.model, 'sonnet');
+    assert.deepStrictEqual(parsed.signals.emit, ['code.changed']);
+  });
+});
+
+// Skip Pro tier tests when Pro repo is not available (CI)
+const HAS_PRO = existsSync(PRO_DIR);
+
+(HAS_PRO ? describe : describe.skip)('Pro template files', () => {
+  const packs = ['pro-product', 'pro-data-science', 'pro-sales', 'pro-support'];
+
+  for (const pack of packs) {
+    const templatesDir = path.join(PRO_DIR, pack, 'templates');
+
+    test(`${pack} has templates directory`, () => {
+      assert.ok(existsSync(templatesDir), `${templatesDir} should exist`);
+    });
+
+    // Skip if Pro dir doesn't exist (CI without Pro repo)
+    if (!existsSync(templatesDir)) continue;
+
+    const files = readdirSync(templatesDir).filter((f) => f.endsWith('.md'));
+
+    for (const file of files) {
+      const templatePath = path.join(templatesDir, file);
+
+      test(`${pack}/${file}: parses without error`, () => {
+        const content = readFileSync(templatePath, 'utf-8');
+        const parsed = parseTemplate(content, templatePath);
+        assert.ok(parsed.name, `template ${file} must have a name`);
+      });
+
+      test(`${pack}/${file}: has required frontmatter fields`, () => {
+        const content = readFileSync(templatePath, 'utf-8');
+        const parsed = parseTemplate(content, templatePath);
+
+        assert.ok(parsed.name, 'name is required');
+        assert.ok(parsed.pack, 'pack is required');
+        assert.ok(parsed.version, 'version is required');
+        assert.ok(parsed.description, 'description is required');
+        assert.ok(parsed.domain, 'domain is required');
+        assert.ok(parsed.chain, 'chain is required');
+      });
+
+      test(`${pack}/${file}: has valid signal names`, () => {
+        const content = readFileSync(templatePath, 'utf-8');
+        const parsed = parseTemplate(content, templatePath);
+
+        for (const signal of parsed.signals.emit) {
+          assert.ok(SIGNAL_NAME_PATTERN.test(signal), `emit signal "${signal}" must match lowercase.dot.notation`);
+        }
+        for (const signal of parsed.signals.listen) {
+          assert.ok(SIGNAL_NAME_PATTERN.test(signal), `listen signal "${signal}" must match lowercase.dot.notation`);
+        }
+      });
+
+      test(`${pack}/${file}: has at least one connection`, () => {
+        const content = readFileSync(templatePath, 'utf-8');
+        const parsed = parseTemplate(content, templatePath);
+        assert.ok(parsed.connections.length > 0, 'template must declare skill connections');
+      });
+
+      test(`${pack}/${file}: body has Phases section`, () => {
+        const content = readFileSync(templatePath, 'utf-8');
+        const parsed = parseTemplate(content, templatePath);
+        assert.ok(parsed.sections.has('Phases'), 'template must have a ## Phases section');
+      });
+
+      test(`${pack}/${file}: body has Acceptance Criteria section`, () => {
+        const content = readFileSync(templatePath, 'utf-8');
+        const parsed = parseTemplate(content, templatePath);
+        assert.ok(parsed.sections.has('Acceptance Criteria'), 'template must have ## Acceptance Criteria');
+      });
+    }
+  }
+});
+
+(HAS_PRO ? describe : describe.skip)('template count per pack', () => {
+  const expectedCounts = {
+    'pro-product': 3,
+    'pro-data-science': 2,
+    'pro-sales': 2,
+    'pro-support': 2,
+  };
+
+  for (const [pack, expected] of Object.entries(expectedCounts)) {
+    test(`${pack} has ${expected} templates`, () => {
+      const templatesDir = path.join(PRO_DIR, pack, 'templates');
+      if (!existsSync(templatesDir)) {
+        assert.fail(`${templatesDir} does not exist`);
+        return;
+      }
+      const files = readdirSync(templatesDir).filter((f) => f.endsWith('.md'));
+      assert.strictEqual(files.length, expected, `${pack} should have ${expected} templates, got ${files.length}`);
+    });
+  }
+});