@rune-kit/rune 2.4.0 → 2.7.0

package/compiler/__tests__/pack-split.test.js

@@ -1,8 +1,12 @@
 import assert from 'node:assert';
 import { existsSync, readFileSync } from 'node:fs';
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
 import path from 'node:path';
-import { test } from 'node:test';
+import { describe, test } from 'node:test';
 import { fileURLToPath } from 'node:url';
+import { getAdapter } from '../adapters/index.js';
+import { buildAll } from '../emitter.js';
 import { parsePack } from '../parser.js';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -143,3 +147,139 @@ test('parsePack: real backend PACK.md parses as split (post-split)', () => {
   assert.strictEqual(parsed.layer, 'L4');
   assert.ok(parsed.sections.size > 0);
 });
+
+// --- Integration: buildAll auto-discovers split pack skill files ---
+
+describe('buildAll split pack auto-discovery', () => {
+  async function createTempWithSplitPack() {
+    const tmp = path.join(tmpdir(), `rune-split-test-${Date.now()}`);
+    const skillsDir = path.join(tmp, 'skills', 'test-skill');
+    const extDir = path.join(tmp, 'extensions', 'test-pack');
+    const extSkillsDir = path.join(extDir, 'skills');
+
+    await mkdir(skillsDir, { recursive: true });
+    await mkdir(extSkillsDir, { recursive: true });
+
+    // Minimal core skill (required for build)
+    await writeFile(
+      path.join(skillsDir, 'SKILL.md'),
+      [
+        '---',
+        'name: test-skill',
+        'description: "A test skill"',
+        'layer: L3',
+        'group: utility',
+        'connections: []',
+        'tags: [test]',
+        '---',
+        '',
+        '# test-skill',
+        '',
+        'Hello.',
+      ].join('\n'),
+      'utf-8',
+    );
+
+    // Split pack WITHOUT skills: array in frontmatter
+    await writeFile(
+      path.join(extDir, 'PACK.md'),
+      [
+        '---',
+        'name: "@rune/test-pack"',
+        'description: "Test pack"',
+        'metadata:',
+        '  version: "0.1.0"',
+        '  format: split',
+        '---',
+        '',
+        '# @rune/test-pack',
+        '',
+        'Pack index body.',
+      ].join('\n'),
+      'utf-8',
+    );
+
+    // Two skill files in skills/ subdir
+    await writeFile(
+      path.join(extSkillsDir, 'alpha.md'),
+      [
+        '---',
+        'name: "alpha"',
+        'description: "Alpha skill"',
+        'model: sonnet',
+        '---',
+        '',
+        '# alpha',
+        '',
+        'Alpha body content here.',
+      ].join('\n'),
+      'utf-8',
+    );
+    await writeFile(
+      path.join(extSkillsDir, 'beta.md'),
+      [
+        '---',
+        'name: "beta"',
+        'description: "Beta skill"',
+        'model: sonnet',
+        '---',
+        '',
+        '# beta',
+        '',
+        'Beta body content here.',
+      ].join('\n'),
+      'utf-8',
+    );
+
+    return tmp;
+  }
+
+  test('auto-discovers skill files from skills/ subdir when manifest is empty', async () => {
+    const tmp = await createTempWithSplitPack();
+    try {
+      const outputRoot = path.join(tmp, 'out');
+      const adapter = getAdapter('cursor');
+      const stats = await buildAll({ runeRoot: tmp, outputRoot, adapter });
+
+      assert.strictEqual(stats.packCount, 1, 'should build 1 pack');
+
+      // Read the compiled pack output
+      const packOutput = await readFile(path.join(outputRoot, adapter.outputDir, 'rune-ext-test-pack.mdc'), 'utf-8');
+
+      // Should contain the pack index body
+      assert.ok(packOutput.includes('Pack index body'), 'missing pack index body');
+
+      // Should contain BOTH auto-discovered skill bodies
+      assert.ok(packOutput.includes('Alpha body content here'), 'missing alpha skill body');
+      assert.ok(packOutput.includes('Beta body content here'), 'missing beta skill body');
+    } finally {
+      await rm(tmp, { recursive: true, force: true });
+    }
+  });
+
+  test('real ai-ml pack includes skill content after build', async () => {
+    const aimlPath = path.join(EXTENSIONS_DIR, 'ai-ml', 'PACK.md');
+    if (!existsSync(aimlPath)) {
+      console.log('  skip: ai-ml PACK.md not found');
+      return;
+    }
+
+    const tmp = path.join(tmpdir(), `rune-aiml-test-${Date.now()}`);
+    const runeRoot = path.resolve(__dirname, '../..');
+    const adapter = getAdapter('cursor');
+    await buildAll({ runeRoot, outputRoot: tmp, adapter });
+
+    try {
+      const packOutput = await readFile(path.join(tmp, adapter.outputDir, 'rune-ext-ai-ml.mdc'), 'utf-8');
+
+      // Should be significantly longer than just the index body (~99 lines without skills)
+      const lineCount = packOutput.split('\n').length;
+      assert.ok(lineCount > 200, `ai-ml pack output too short (${lineCount} lines) — skills likely not included`);
+
+      // Should contain content from individual skill files
+      assert.ok(packOutput.includes('ai-agents') || packOutput.includes('AI agent'), 'missing ai-agents skill content');
+    } finally {
+      await rm(tmp, { recursive: true, force: true });
+    }
+  });
+});

package/compiler/__tests__/parser.test.js

@@ -1,7 +1,7 @@
 import assert from 'node:assert';
 import { readFileSync } from 'node:fs';
 import path from 'node:path';
-import { test } from 'node:test';
+import { describe, test } from 'node:test';
 import { fileURLToPath } from 'node:url';
 import { parseSkill } from '../parser.js';
 
@@ -53,3 +53,149 @@ test('parse verification SKILL.md', () => {
   assert.strictEqual(parsed.name, 'verification');
   assert.strictEqual(parsed.layer, 'L3');
 });
+
+describe('signals parsing', () => {
+  test('parses emit and listen from metadata', () => {
+    const content = [
+      '---',
+      'name: alpha',
+      'description: "Test skill"',
+      'metadata:',
+      '  layer: L2',
+      '  emit: code.changed, tests.passed',
+      '  listen: plan.ready',
+      '---',
+      '',
+      '# alpha',
+    ].join('\n');
+
+    const parsed = parseSkill(content);
+    assert.ok(parsed.signals, 'signals should not be null');
+    assert.deepStrictEqual(parsed.signals.emit, ['code.changed', 'tests.passed']);
+    assert.deepStrictEqual(parsed.signals.listen, ['plan.ready']);
+  });
+
+  test('emit only — no listen', () => {
+    const content = [
+      '---',
+      'name: beta',
+      'description: "Emitter only"',
+      'metadata:',
+      '  layer: L3',
+      '  emit: deploy.complete',
+      '---',
+      '',
+      '# beta',
+    ].join('\n');
+
+    const parsed = parseSkill(content);
+    assert.ok(parsed.signals);
+    assert.deepStrictEqual(parsed.signals.emit, ['deploy.complete']);
+    assert.deepStrictEqual(parsed.signals.listen, []);
+  });
+
+  test('listen only — no emit', () => {
+    const content = [
+      '---',
+      'name: gamma',
+      'description: "Listener only"',
+      'metadata:',
+      '  layer: L3',
+      '  listen: code.changed',
+      '---',
+      '',
+      '# gamma',
+    ].join('\n');
+
+    const parsed = parseSkill(content);
+    assert.ok(parsed.signals);
+    assert.deepStrictEqual(parsed.signals.emit, []);
+    assert.deepStrictEqual(parsed.signals.listen, ['code.changed']);
+  });
+
+  test('no signals — returns null', () => {
+    const content = [
+      '---',
+      'name: delta',
+      'description: "No signals"',
+      'metadata:',
+      '  layer: L3',
+      '---',
+      '',
+      '# delta',
+    ].join('\n');
+
+    const parsed = parseSkill(content);
+    assert.strictEqual(parsed.signals, null);
+  });
+
+  test('real cook skill has signals', () => {
+    const content = readFileSync(path.join(SKILLS_DIR, 'cook/SKILL.md'), 'utf-8');
+    const parsed = parseSkill(content, 'cook/SKILL.md');
+    assert.ok(parsed.signals, 'cook should have signals');
+    assert.ok(parsed.signals.emit.includes('phase.complete'));
+  });
+
+  test('real test skill has emit and listen', () => {
+    const content = readFileSync(path.join(SKILLS_DIR, 'test/SKILL.md'), 'utf-8');
+    const parsed = parseSkill(content, 'test/SKILL.md');
+    assert.ok(parsed.signals, 'test should have signals');
+    assert.ok(parsed.signals.emit.includes('tests.passed'));
+    assert.ok(parsed.signals.emit.includes('tests.failed'));
+    assert.ok(parsed.signals.listen.includes('code.changed'));
+  });
+
+  test('top-level emit/listen (Pro/Business pack format)', () => {
+    const content = [
+      '---',
+      'name: "feature-spec"',
+      'pack: "@rune-pro/product"',
+      'version: "1.2.0"',
+      'model: opus',
+      'tools: [Read, Write]',
+      'emit: product.spec.drafted',
+      'listen: sales.account.researched, product.research.complete',
+      '---',
+      '',
+      '# feature-spec',
+    ].join('\n');
+
+    const parsed = parseSkill(content);
+    assert.ok(parsed.signals, 'top-level signals should be parsed');
+    assert.deepStrictEqual(parsed.signals.emit, ['product.spec.drafted']);
+    assert.deepStrictEqual(parsed.signals.listen, ['sales.account.researched', 'product.research.complete']);
+  });
+
+  test('top-level emit only (no listen)', () => {
+    const content = [
+      '---',
+      'name: "account-research"',
+      'emit: sales.account.researched',
+      '---',
+      '',
+      '# account-research',
+    ].join('\n');
+
+    const parsed = parseSkill(content);
+    assert.ok(parsed.signals);
+    assert.deepStrictEqual(parsed.signals.emit, ['sales.account.researched']);
+    assert.deepStrictEqual(parsed.signals.listen, []);
+  });
+
+  test('metadata emit takes precedence over top-level', () => {
+    const content = [
+      '---',
+      'name: "hybrid"',
+      'emit: top.level.signal',
+      'metadata:',
+      '  emit: nested.signal',
+      '---',
+      '',
+      '# hybrid',
+    ].join('\n');
+
+    const parsed = parseSkill(content);
+    assert.ok(parsed.signals);
+    assert.deepStrictEqual(parsed.signals.emit, ['nested.signal']);
+  });
+});

package/compiler/__tests__/scripts-bundling.test.js

@@ -138,11 +138,7 @@ describe('buildAll with scripts', () => {
 
     // Minimal .claude-plugin for openclaw
     await mkdir(path.join(tmp, '.claude-plugin'), { recursive: true });
-    await writeFile(
-      path.join(tmp, '.claude-plugin', 'plugin.json'),
-      JSON.stringify({ version: '0.0.1' }),
-      'utf-8',
-    );
+    await writeFile(path.join(tmp, '.claude-plugin', 'plugin.json'), JSON.stringify({ version: '0.0.1' }), 'utf-8');
 
     return tmp;
   }
@@ -168,7 +164,10 @@ describe('buildAll with scripts', () => {
       assert.ok(mdc.includes('.cursor/rules/rune-test-slide-scripts/build-deck.js'), 'resolved path missing');
 
       // Plain skill: no scripts dir created
-      assert.ok(!existsSync(path.join(outputRoot, adapter.outputDir, 'rune-test-plain-scripts')), 'plain skill should not have scripts dir');
+      assert.ok(
+        !existsSync(path.join(outputRoot, adapter.outputDir, 'rune-test-plain-scripts')),
+        'plain skill should not have scripts dir',
+      );
     } finally {
       await rm(tmp, { recursive: true, force: true });
     }
@@ -189,10 +188,7 @@ describe('buildAll with scripts', () => {
       assert.ok(existsSync(path.join(scriptsOut, 'helper.py')), 'helper.py missing');
 
       // Placeholder resolved
-      const md = await readFile(
-        path.join(outputRoot, adapter.outputDir, 'rune-test-slide', 'SKILL.md'),
-        'utf-8',
-      );
+      const md = await readFile(path.join(outputRoot, adapter.outputDir, 'rune-test-slide', 'SKILL.md'), 'utf-8');
       assert.ok(!md.includes('{scripts_dir}'), 'placeholder should be resolved');
       assert.ok(md.includes('.codex/skills/rune-test-slide/scripts/build-deck.js'), 'resolved path missing');
     } finally {
@@ -254,7 +250,10 @@ describe('buildAll with scripts', () => {
       await buildAll({ runeRoot: tmp, outputRoot, adapter });
 
       const original = await readFile(path.join(tmp, 'skills', 'test-slide', 'scripts', 'build-deck.js'), 'utf-8');
-      const copied = await readFile(path.join(outputRoot, adapter.outputDir, 'rune-test-slide-scripts', 'build-deck.js'), 'utf-8');
+      const copied = await readFile(
+        path.join(outputRoot, adapter.outputDir, 'rune-test-slide-scripts', 'build-deck.js'),
+        'utf-8',
+      );
       assert.strictEqual(copied, original, 'script content should be identical');
     } finally {
       await rm(tmp, { recursive: true, force: true });

package/compiler/__tests__/skill-index.test.js

@@ -0,0 +1,218 @@
+/**
+ * Skill Index Generation Tests
+ *
+ * Tests that buildAll generates a valid skill-index.json with:
+ * - Intent patterns mapped to skills
+ * - Mesh-aware chain prediction from connections
+ * - Complete skill graph
+ */
+
+import assert from 'node:assert';
+import { existsSync } from 'node:fs';
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { describe, test } from 'node:test';
+import { fileURLToPath } from 'node:url';
+import { getAdapter } from '../adapters/index.js';
+import { buildAll } from '../emitter.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const RUNE_ROOT = path.resolve(__dirname, '../..');
+
+describe('skill-index.json generation', () => {
+  test('buildAll emits skill-index.json with correct structure', async () => {
+    const tmp = path.join(tmpdir(), `rune-idx-test-${Date.now()}`);
+    try {
+      const adapter = getAdapter('cursor');
+      await buildAll({ runeRoot: RUNE_ROOT, outputRoot: tmp, adapter });
+
+      const indexPath = path.join(tmp, adapter.outputDir, 'skill-index.json');
+      assert.ok(existsSync(indexPath), 'skill-index.json not found in output');
+
+      const index = JSON.parse(await readFile(indexPath, 'utf-8'));
+
+      // Structure checks
+      assert.strictEqual(index.version, 2);
+      assert.ok(index.generated, 'missing generated timestamp');
+      assert.ok(index.skillCount >= 50, `too few skills: ${index.skillCount}`);
+      assert.ok(typeof index.skills === 'object', 'missing skills object');
+      assert.ok(typeof index.graph === 'object', 'missing graph object');
+      assert.ok(typeof index.signals === 'object', 'missing signals object');
+      assert.ok(typeof index.intents === 'object', 'missing intents object');
+    } finally {
+      await rm(tmp, { recursive: true, force: true });
+    }
+  });
+
+  test('skill-index contains intent patterns with chains', async () => {
+    const tmp = path.join(tmpdir(), `rune-idx-test-${Date.now()}`);
+    try {
+      const adapter = getAdapter('cursor');
+      await buildAll({ runeRoot: RUNE_ROOT, outputRoot: tmp, adapter });
+
+      const index = JSON.parse(await readFile(path.join(tmp, adapter.outputDir, 'skill-index.json'), 'utf-8'));
+
+      // cook intent should exist with keywords and chain
+      assert.ok(index.intents.cook, 'missing cook intent');
+      assert.ok(Array.isArray(index.intents.cook.keywords), 'cook keywords not array');
+      assert.ok(index.intents.cook.keywords.includes('implement'), 'cook missing "implement" keyword');
+      assert.ok(Array.isArray(index.intents.cook.chain), 'cook chain not array');
+      assert.strictEqual(index.intents.cook.chain[0], 'cook', 'cook chain should start with cook');
+      assert.ok(index.intents.cook.chain.length > 1, 'cook chain should have connected skills');
+
+      // debug intent
+      assert.ok(index.intents.debug, 'missing debug intent');
+      assert.ok(index.intents.debug.keywords.includes('bug'), 'debug missing "bug" keyword');
+
+      // sentinel intent
+      assert.ok(index.intents.sentinel, 'missing sentinel intent');
+      assert.ok(index.intents.sentinel.keywords.includes('security'), 'sentinel missing "security" keyword');
+    } finally {
+      await rm(tmp, { recursive: true, force: true });
+    }
+  });
+
+  test('skill-index graph has connections from cross-refs', async () => {
+    const tmp = path.join(tmpdir(), `rune-idx-test-${Date.now()}`);
+    try {
+      const adapter = getAdapter('cursor');
+      await buildAll({ runeRoot: RUNE_ROOT, outputRoot: tmp, adapter });
+
+      const index = JSON.parse(await readFile(path.join(tmp, adapter.outputDir, 'skill-index.json'), 'utf-8'));
+
+      // cook should have outbound connections
+      assert.ok(index.graph.cook, 'cook not in graph');
+      assert.ok(index.graph.cook.length > 3, `cook should have many connections, got ${index.graph.cook.length}`);
+
+      // Skills entry should have layer and description
+      assert.ok(index.skills.cook, 'cook not in skills');
+      assert.strictEqual(index.skills.cook.layer, 'L1');
+      assert.ok(index.skills.cook.description.length > 20, 'cook description too short');
+    } finally {
+      await rm(tmp, { recursive: true, force: true });
+    }
+  });
+
+  test('skill-index contains signal graph', async () => {
+    const tmp = path.join(tmpdir(), `rune-idx-test-${Date.now()}`);
+    try {
+      const adapter = getAdapter('cursor');
+      await buildAll({ runeRoot: RUNE_ROOT, outputRoot: tmp, adapter });
+
+      const index = JSON.parse(await readFile(path.join(tmp, adapter.outputDir, 'skill-index.json'), 'utf-8'));
+
+      // Signal graph should exist
+      assert.ok(typeof index.signals === 'object', 'missing signals object');
+      assert.ok(Object.keys(index.signals).length >= 10, `too few signals: ${Object.keys(index.signals).length}`);
+
+      // code.changed should be a well-connected signal
+      assert.ok(index.signals['code.changed'], 'missing code.changed signal');
+      assert.ok(index.signals['code.changed'].emitters.includes('fix'), 'fix should emit code.changed');
+      assert.ok(index.signals['code.changed'].listeners.length >= 3, 'code.changed should have 3+ listeners');
+
+      // Per-skill signals should be included
+      assert.ok(index.skills.test.signals, 'test skill should have signals');
+      assert.ok(index.skills.test.signals.emit.includes('tests.passed'), 'test should emit tests.passed');
+      assert.ok(index.skills.test.signals.listen.includes('code.changed'), 'test should listen to code.changed');
+
+      // Skills without signals should not have the field
+      const noSignalSkill = Object.values(index.skills).find((s) => !s.signals);
+      assert.ok(noSignalSkill, 'at least one skill should have no signals');
+    } finally {
+      await rm(tmp, { recursive: true, force: true });
+    }
+  });
+
+  test('skill-index signal graph with synthetic skills', async () => {
+    const tmp = path.join(tmpdir(), `rune-idx-sig-${Date.now()}`);
+    const skillsDir = path.join(tmp, 'skills');
+    await mkdir(path.join(skillsDir, 'emitter'), { recursive: true });
+    await mkdir(path.join(skillsDir, 'listener'), { recursive: true });
+    await mkdir(path.join(tmp, 'extensions'), { recursive: true });
+
+    await writeFile(
+      path.join(skillsDir, 'emitter', 'SKILL.md'),
+      [
+        '---',
+        'name: emitter',
+        'description: "Emits signals"',
+        'metadata:',
+        '  layer: L2',
+        '  emit: data.ready',
+        '---',
+        '',
+        '# emitter',
+      ].join('\n'),
+      'utf-8',
+    );
+
+    await writeFile(
+      path.join(skillsDir, 'listener', 'SKILL.md'),
+      [
+        '---',
+        'name: listener',
+        'description: "Listens to signals"',
+        'metadata:',
+        '  layer: L3',
+        '  listen: data.ready',
+        '---',
+        '',
+        '# listener',
+      ].join('\n'),
+      'utf-8',
+    );
+
+    try {
+      const adapter = getAdapter('generic');
+      await buildAll({ runeRoot: tmp, outputRoot: tmp, adapter });
+
+      const index = JSON.parse(await readFile(path.join(tmp, adapter.outputDir, 'skill-index.json'), 'utf-8'));
+
+      assert.ok(index.signals['data.ready'], 'data.ready signal should exist');
+      assert.deepStrictEqual(index.signals['data.ready'].emitters, ['emitter']);
+      assert.deepStrictEqual(index.signals['data.ready'].listeners, ['listener']);
+      assert.ok(index.skills.emitter.signals);
+      assert.deepStrictEqual(index.skills.emitter.signals.emit, ['data.ready']);
+    } finally {
+      await rm(tmp, { recursive: true, force: true });
+    }
+  });
+
+  test('skill-index works with minimal skill tree', async () => {
+    const tmp = path.join(tmpdir(), `rune-idx-min-${Date.now()}`);
+    const skillsDir = path.join(tmp, 'skills', 'alpha');
+    await mkdir(skillsDir, { recursive: true });
+    await mkdir(path.join(tmp, 'extensions'), { recursive: true });
+
+    await writeFile(
+      path.join(skillsDir, 'SKILL.md'),
+      [
+        '---',
+        'name: alpha',
+        'description: "Test skill"',
+        'metadata:',
+        '  layer: L3',
+        '  group: utility',
+        '---',
+        '',
+        '# alpha',
+        '',
+        'Body.',
+      ].join('\n'),
+      'utf-8',
+    );
+
+    try {
+      const adapter = getAdapter('generic');
+      await buildAll({ runeRoot: tmp, outputRoot: tmp, adapter });
+
+      const index = JSON.parse(await readFile(path.join(tmp, adapter.outputDir, 'skill-index.json'), 'utf-8'));
+      assert.strictEqual(index.skillCount, 1);
+      assert.ok(index.skills.alpha, 'alpha not in skills');
+      assert.deepStrictEqual(index.graph.alpha, [], 'alpha should have no connections');
+    } finally {
+      await rm(tmp, { recursive: true, force: true });
+    }
+  });
+});