@rune-kit/rune 2.2.2 → 2.2.4

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

@@ -1,145 +1,145 @@
-import { parsePack, parseSkill } from '../parser.js';
-import { test } from 'node:test';
-import assert from 'node:assert';
-import { readFileSync, existsSync } from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const EXTENSIONS_DIR = path.resolve(__dirname, '../../extensions');
-
-// --- Monolith format (regression) ---
-
-test('parsePack: monolith format has isSplit=false', () => {
-  const content = `---
-name: "@rune/trading"
-description: "Trading patterns"
-metadata:
-  version: "0.2.0"
-  layer: L4
-  price: free
-  target: Traders
----
-
-# @rune/trading
-
-## Purpose
-Trading pack.
-
-## Skills Included
-
-### risk-management
-Risk management workflow.
-`;
-
-  const parsed = parsePack(content, 'extensions/trading/PACK.md');
-
-  assert.strictEqual(parsed.isSplit, false);
-  assert.deepStrictEqual(parsed.skillManifest, []);
-  assert.strictEqual(parsed.name, '@rune/trading');
-  assert.strictEqual(parsed.version, '0.2.0');
-  assert.strictEqual(parsed.layer, 'L4');
-  assert.ok(parsed.body.includes('risk-management'));
-});
-
-test('parsePack: monolith without metadata block defaults correctly', () => {
-  const content = `---
-name: "@rune/test"
-description: "Test pack"
----
-
-# @rune/test
-Body here.
-`;
-
-  const parsed = parsePack(content, 'test/PACK.md');
-
-  assert.strictEqual(parsed.isSplit, false);
-  assert.strictEqual(parsed.version, '1.0.0');
-});
-
-// --- Split format detection ---
-
-test('parsePack: split format detected via metadata.format', () => {
-  const content = `---
-name: "@rune/backend"
-description: "Backend patterns"
-metadata:
-  version: "0.3.0"
-  layer: L4
-  price: free
-  target: Backend developers
-  format: split
----
-
-# @rune/backend
-
-## Purpose
-Backend pack index.
-
-## Skills Included
-| Skill | Model | Description |
-|-------|-------|-------------|
-| api-design | sonnet | API patterns |
-| auth | sonnet | Auth patterns |
-`;
-
-  const parsed = parsePack(content, 'extensions/backend/PACK.md');
-
-  assert.strictEqual(parsed.isSplit, true);
-  assert.strictEqual(parsed.version, '0.3.0');
-  assert.strictEqual(parsed.name, '@rune/backend');
-});
-
-test('parsePack: skill manifest parsed from string array', () => {
-  // Note: our YAML parser is simple — it handles nested objects but not arrays.
-  // This test validates the parseSkillManifest function directly with object skills.
-  const content = `---
-name: "@rune/test"
-description: "Test"
-metadata:
-  format: split
----
-
-Body.
-`;
-
-  const parsed = parsePack(content, 'test/PACK.md');
-  assert.strictEqual(parsed.isSplit, true);
-  // With simple YAML parser, skills array won't parse — manifest will be empty
-  // Real usage will use the skills/ directory detection as fallback
-  assert.ok(Array.isArray(parsed.skillManifest));
-});
-
-// --- Real pack regression: existing monolith packs parse correctly ---
-
-test('parsePack: real trading PACK.md parses as split', () => {
-  const tradingPath = path.join(EXTENSIONS_DIR, 'trading', 'PACK.md');
-  if (!existsSync(tradingPath)) {
-    console.log('  skip: trading PACK.md not found');
-    return;
-  }
-
-  const content = readFileSync(tradingPath, 'utf-8');
-  const parsed = parsePack(content, tradingPath);
-
-  assert.strictEqual(parsed.isSplit, true);
-  assert.strictEqual(parsed.layer, 'L4');
-  assert.strictEqual(parsed.group, 'extension');
-  assert.ok(parsed.body.length > 50);
-});
-
-test('parsePack: real backend PACK.md parses as split (post-split)', () => {
-  const backendPath = path.join(EXTENSIONS_DIR, 'backend', 'PACK.md');
-  if (!existsSync(backendPath)) {
-    console.log('  skip: backend PACK.md not found');
-    return;
-  }
-
-  const content = readFileSync(backendPath, 'utf-8');
-  const parsed = parsePack(content, backendPath);
-
-  assert.strictEqual(parsed.isSplit, true);
-  assert.strictEqual(parsed.layer, 'L4');
-  assert.ok(parsed.sections.size > 0);
-});
+import assert from 'node:assert';
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import { test } from 'node:test';
+import { fileURLToPath } from 'node:url';
+import { parsePack } from '../parser.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const EXTENSIONS_DIR = path.resolve(__dirname, '../../extensions');
+
+// --- Monolith format (regression) ---
+
+test('parsePack: monolith format has isSplit=false', () => {
+  const content = `---
+name: "@rune/trading"
+description: "Trading patterns"
+metadata:
+  version: "0.2.0"
+  layer: L4
+  price: free
+  target: Traders
+---
+
+# @rune/trading
+
+## Purpose
+Trading pack.
+
+## Skills Included
+
+### risk-management
+Risk management workflow.
+`;
+
+  const parsed = parsePack(content, 'extensions/trading/PACK.md');
+
+  assert.strictEqual(parsed.isSplit, false);
+  assert.deepStrictEqual(parsed.skillManifest, []);
+  assert.strictEqual(parsed.name, '@rune/trading');
+  assert.strictEqual(parsed.version, '0.2.0');
+  assert.strictEqual(parsed.layer, 'L4');
+  assert.ok(parsed.body.includes('risk-management'));
+});
+
+test('parsePack: monolith without metadata block defaults correctly', () => {
+  const content = `---
+name: "@rune/test"
+description: "Test pack"
+---
+
+# @rune/test
+Body here.
+`;
+
+  const parsed = parsePack(content, 'test/PACK.md');
+
+  assert.strictEqual(parsed.isSplit, false);
+  assert.strictEqual(parsed.version, '1.0.0');
+});
+
+// --- Split format detection ---
+
+test('parsePack: split format detected via metadata.format', () => {
+  const content = `---
+name: "@rune/backend"
+description: "Backend patterns"
+metadata:
+  version: "0.3.0"
+  layer: L4
+  price: free
+  target: Backend developers
+  format: split
+---
+
+# @rune/backend
+
+## Purpose
+Backend pack index.
+
+## Skills Included
+| Skill | Model | Description |
+|-------|-------|-------------|
+| api-design | sonnet | API patterns |
+| auth | sonnet | Auth patterns |
+`;
+
+  const parsed = parsePack(content, 'extensions/backend/PACK.md');
+
+  assert.strictEqual(parsed.isSplit, true);
+  assert.strictEqual(parsed.version, '0.3.0');
+  assert.strictEqual(parsed.name, '@rune/backend');
+});
+
+test('parsePack: skill manifest parsed from string array', () => {
+  // Note: our YAML parser is simple — it handles nested objects but not arrays.
+  // This test validates the parseSkillManifest function directly with object skills.
+  const content = `---
+name: "@rune/test"
+description: "Test"
+metadata:
+  format: split
+---
+
+Body.
+`;
+
+  const parsed = parsePack(content, 'test/PACK.md');
+  assert.strictEqual(parsed.isSplit, true);
+  // With simple YAML parser, skills array won't parse — manifest will be empty
+  // Real usage will use the skills/ directory detection as fallback
+  assert.ok(Array.isArray(parsed.skillManifest));
+});
+
+// --- Real pack regression: existing monolith packs parse correctly ---
+
+test('parsePack: real trading PACK.md parses as split', () => {
+  const tradingPath = path.join(EXTENSIONS_DIR, 'trading', 'PACK.md');
+  if (!existsSync(tradingPath)) {
+    console.log('  skip: trading PACK.md not found');
+    return;
+  }
+
+  const content = readFileSync(tradingPath, 'utf-8');
+  const parsed = parsePack(content, tradingPath);
+
+  assert.strictEqual(parsed.isSplit, true);
+  assert.strictEqual(parsed.layer, 'L4');
+  assert.strictEqual(parsed.group, 'extension');
+  assert.ok(parsed.body.length > 50);
+});
+
+test('parsePack: real backend PACK.md parses as split (post-split)', () => {
+  const backendPath = path.join(EXTENSIONS_DIR, 'backend', 'PACK.md');
+  if (!existsSync(backendPath)) {
+    console.log('  skip: backend PACK.md not found');
+    return;
+  }
+
+  const content = readFileSync(backendPath, 'utf-8');
+  const parsed = parsePack(content, backendPath);
+
+  assert.strictEqual(parsed.isSplit, true);
+  assert.strictEqual(parsed.layer, 'L4');
+  assert.ok(parsed.sections.size > 0);
+});

package/compiler/__tests__/parser.test.js

@@ -1,9 +1,9 @@
-import { parseSkill } from '../parser.js';
-import { readFileSync } from 'node:fs';
-import { test } from 'node:test';
 import assert from 'node:assert';
+import { readFileSync } from 'node:fs';
 import path from 'node:path';
+import { test } from 'node:test';
 import { fileURLToPath } from 'node:url';
+import { parseSkill } from '../parser.js';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const SKILLS_DIR = path.resolve(__dirname, '../../skills');

package/compiler/__tests__/pipeline.test.js

@@ -0,0 +1,110 @@
+/**
+ * E2E Pipeline Tests
+ *
+ * Tests the full compile pipeline: parse → transform → assemble output.
+ * Verifies that real skills produce valid output for each platform adapter.
+ */
+
+import assert from 'node:assert';
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { describe, test } from 'node:test';
+import { fileURLToPath } from 'node:url';
+import { getAdapter, listPlatforms } from '../adapters/index.js';
+import { parseSkill } from '../parser.js';
+import { transformSkill } from '../transformer.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const SKILLS_DIR = path.resolve(__dirname, '../../skills');
+
+// Use a real skill (cook) for e2e tests
+const cookContent = readFileSync(path.join(SKILLS_DIR, 'cook/SKILL.md'), 'utf-8');
+const cookParsed = parseSkill(cookContent, 'cook/SKILL.md');
+
+const fixContent = readFileSync(path.join(SKILLS_DIR, 'fix/SKILL.md'), 'utf-8');
+const fixParsed = parseSkill(fixContent, 'fix/SKILL.md');
+
+// --- Full pipeline per platform ---
+
+describe('full pipeline: cook skill', () => {
+  for (const platform of listPlatforms()) {
+    test(`${platform}: parse → transform → output`, () => {
+      const adapter = getAdapter(platform);
+      const result = transformSkill(cookParsed, adapter);
+
+      // Result structure
+      assert.ok(typeof result.header === 'string', `${platform}: header not string`);
+      assert.ok(typeof result.body === 'string', `${platform}: body not string`);
+      assert.ok(typeof result.footer === 'string', `${platform}: footer not string`);
+
+      // Body should contain meaningful content
+      assert.ok(result.body.length > 500, `${platform}: body too short (${result.body.length})`);
+
+      if (platform === 'claude') {
+        // Claude: passthrough, no header/footer
+        assert.strictEqual(result.header, '');
+        assert.strictEqual(result.footer, '');
+        // Should still have original cross-refs
+        assert.ok(result.body.includes('rune:'), `claude: should preserve rune: cross-refs`);
+      } else {
+        // Non-Claude: should have transformed cross-refs
+        assert.ok(!result.body.includes('`rune:cook`'), `${platform}: should not have backticked rune:cook cross-ref`);
+
+        // Should have footer with branding
+        assert.ok(result.footer.includes('Rune'), `${platform}: footer missing branding`);
+      }
+    });
+  }
+});
+
+describe('full pipeline: fix skill', () => {
+  test('cursor: cross-refs transformed to .mdc', () => {
+    const adapter = getAdapter('cursor');
+    const result = transformSkill(fixParsed, adapter);
+
+    // Fix references cook, debug, test, etc. — at least some should be transformed
+    assert.ok(result.body.includes('.mdc'), 'cursor output should contain .mdc references');
+  });
+
+  test('generic: cross-refs transformed to descriptive text', () => {
+    const adapter = getAdapter('generic');
+    const result = transformSkill(fixParsed, adapter);
+    assert.ok(result.body.includes('rule file'), 'generic output should contain "rule file" references');
+  });
+
+  test('openclaw: cross-refs transformed to .md file refs', () => {
+    const adapter = getAdapter('openclaw');
+    const result = transformSkill(fixParsed, adapter);
+    assert.ok(result.body.includes('.md'), 'openclaw output should contain .md references');
+  });
+});
+
+// --- Output assembly (header + body + footer) ---
+
+describe('output assembly', () => {
+  test('cursor output assembles into valid .mdc file', () => {
+    const adapter = getAdapter('cursor');
+    const result = transformSkill(cookParsed, adapter);
+    const assembled = result.header + result.body + result.footer;
+
+    // Should start with YAML frontmatter
+    assert.ok(assembled.startsWith('---\n'), 'cursor .mdc should start with YAML frontmatter');
+    assert.ok(assembled.includes('description:'), 'cursor .mdc should have description');
+    assert.ok(assembled.includes('alwaysApply:'), 'cursor .mdc should have alwaysApply');
+  });
+
+  test('codex output has YAML frontmatter with name', () => {
+    const adapter = getAdapter('codex');
+    const result = transformSkill(cookParsed, adapter);
+    const assembled = result.header + result.body + result.footer;
+
+    assert.ok(assembled.includes('name: rune-cook'), 'codex should have name: rune-cook');
+  });
+
+  test('generic output has markdown heading', () => {
+    const adapter = getAdapter('generic');
+    const result = transformSkill(cookParsed, adapter);
+
+    assert.ok(result.header.includes('# rune-cook'), 'generic header should have # rune-cook');
+  });
+});

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

@@ -0,0 +1,148 @@
+/**
+ * Skill Validation Tests
+ *
+ * Verifies ALL 58 SKILL.md files parse correctly and meet structural requirements.
+ * This is the "mesh integrity" test — if any skill breaks parsing, mesh connections fail.
+ */
+
+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 } from '../parser.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const SKILLS_DIR = path.resolve(__dirname, '../../skills');
+
+// Discover all skill directories
+const skillDirs = readdirSync(SKILLS_DIR, { withFileTypes: true })
+  .filter((d) => d.isDirectory())
+  .map((d) => d.name)
+  .sort();
+
+const VALID_LAYERS = ['L0', 'L1', 'L2', 'L3'];
+const VALID_MODELS = ['haiku', 'sonnet', 'opus'];
+
+// --- Discovery ---
+
+test(`discovers all 58 core skills`, () => {
+  assert.ok(skillDirs.length >= 58, `expected >=58 skills, found ${skillDirs.length}`);
+});
+
+// --- Per-skill validation ---
+
+describe('skill parsing', () => {
+  for (const skillName of skillDirs) {
+    const skillFile = path.join(SKILLS_DIR, skillName, 'SKILL.md');
+
+    test(`${skillName}/SKILL.md exists`, () => {
+      assert.ok(existsSync(skillFile), `missing SKILL.md for ${skillName}`);
+    });
+
+    test(`${skillName} parses without errors`, () => {
+      const content = readFileSync(skillFile, 'utf-8');
+      const parsed = parseSkill(content, `${skillName}/SKILL.md`);
+
+      // Must have a name
+      assert.ok(parsed.name, `${skillName}: missing name`);
+      assert.strictEqual(parsed.name, skillName, `${skillName}: parsed name mismatch`);
+    });
+
+    test(`${skillName} has valid layer`, () => {
+      const content = readFileSync(skillFile, 'utf-8');
+      const parsed = parseSkill(content, `${skillName}/SKILL.md`);
+      assert.ok(VALID_LAYERS.includes(parsed.layer), `${skillName}: invalid layer "${parsed.layer}"`);
+    });
+
+    test(`${skillName} has valid model`, () => {
+      const content = readFileSync(skillFile, 'utf-8');
+      const parsed = parseSkill(content, `${skillName}/SKILL.md`);
+      if (parsed.model) {
+        assert.ok(VALID_MODELS.includes(parsed.model), `${skillName}: invalid model "${parsed.model}"`);
+      }
+    });
+
+    test(`${skillName} has description`, () => {
+      const content = readFileSync(skillFile, 'utf-8');
+      const parsed = parseSkill(content, `${skillName}/SKILL.md`);
+      assert.ok(parsed.description && parsed.description.length > 10, `${skillName}: missing or too short description`);
+    });
+
+    test(`${skillName} has non-empty body`, () => {
+      const content = readFileSync(skillFile, 'utf-8');
+      const parsed = parseSkill(content, `${skillName}/SKILL.md`);
+      assert.ok(
+        parsed.body && parsed.body.length > 100,
+        `${skillName}: body too short (${parsed.body?.length || 0} chars)`,
+      );
+    });
+  }
+});
+
+// --- Mesh integrity ---
+
+describe('mesh integrity', () => {
+  const allParsed = skillDirs.map((name) => {
+    const content = readFileSync(path.join(SKILLS_DIR, name, 'SKILL.md'), 'utf-8');
+    return parseSkill(content, `${name}/SKILL.md`);
+  });
+  const allNames = new Set(allParsed.map((s) => s.name));
+
+  test('all string cross-references point to existing skills', () => {
+    const broken = [];
+    for (const skill of allParsed) {
+      for (const ref of skill.crossRefs) {
+        // Skip non-string refs (parser quirk for some metadata formats)
+        if (typeof ref !== 'string') continue;
+        if (!allNames.has(ref)) {
+          broken.push(`${skill.name} → ${ref}`);
+        }
+      }
+    }
+    assert.strictEqual(broken.length, 0, `broken cross-refs:\n  ${broken.join('\n  ')}`);
+  });
+
+  test('L0 layer has exactly 1 skill (skill-router)', () => {
+    const l0 = allParsed.filter((s) => s.layer === 'L0');
+    assert.strictEqual(l0.length, 1);
+    assert.strictEqual(l0[0].name, 'skill-router');
+  });
+
+  test('L1 orchestrators exist', () => {
+    const l1 = allParsed.filter((s) => s.layer === 'L1');
+    const l1Names = l1.map((s) => s.name);
+    for (const expected of ['cook', 'team', 'launch', 'rescue', 'scaffold']) {
+      assert.ok(l1Names.includes(expected), `missing L1 orchestrator: ${expected}`);
+    }
+  });
+
+  test('mesh has 200+ total cross-references', () => {
+    const totalRefs = allParsed.reduce((sum, s) => sum + s.crossRefs.length, 0);
+    assert.ok(totalRefs >= 200, `expected >=200 cross-refs, found ${totalRefs}`);
+  });
+
+  test('no true orphan skills (every skill is referenced by at least one other)', () => {
+    // Collect all names referenced via crossRefs OR mentioned in body text as rune:name
+    const referenced = new Set();
+    const refPattern = /rune:([a-z][\w-]*)/g;
+    for (const skill of allParsed) {
+      // From parsed crossRefs
+      for (const ref of skill.crossRefs) {
+        if (typeof ref === 'string') referenced.add(ref);
+      }
+      // From body text mentions
+      let match;
+      while ((match = refPattern.exec(skill.body)) !== null) {
+        referenced.add(match[1]);
+      }
+    }
+    // Skills that are dispatched dynamically by skill-router (not via explicit rune:X refs)
+    const dynamicDispatch = new Set(['constraint-check', 'context-engine', 'sast', 'scope-guard', 'worktree']);
+    // A skill is orphan only if it's never referenced and not dynamically dispatched
+    const orphans = allParsed.filter(
+      (s) => !referenced.has(s.name) && !dynamicDispatch.has(s.name) && s.layer !== 'L0',
+    );
+    assert.strictEqual(orphans.length, 0, `orphan skills (never referenced): ${orphans.map((s) => s.name).join(', ')}`);
+  });
+});

package/compiler/__tests__/transformer.test.js

@@ -0,0 +1,70 @@
+import assert from 'node:assert';
+import { describe, test } from 'node:test';
+import { getAdapter } from '../adapters/index.js';
+import { transformSkill } from '../transformer.js';
+
+// --- Transformer pipeline ---
+
+describe('transformSkill', () => {
+  const mockSkill = {
+    name: 'fix',
+    layer: 'L2',
+    group: 'workflow',
+    description: 'Apply code fixes',
+    body: '# fix\n\nUse `rune:cook` for orchestration.\n\nUse `Read` to check files.\n\n## Steps\n\n1. Analyze\n2. Fix\n3. Verify',
+    crossRefs: ['cook'],
+    toolRefs: ['Read'],
+    hardGates: [],
+    frontmatter: { layer: 'L2', model: 'sonnet' },
+    sections: new Map(),
+  };
+
+  test('Claude adapter returns body unchanged', () => {
+    const claude = getAdapter('claude');
+    const result = transformSkill(mockSkill, claude);
+    assert.strictEqual(result.body, mockSkill.body);
+    assert.strictEqual(result.header, '');
+    assert.strictEqual(result.footer, '');
+  });
+
+  test('Cursor adapter transforms cross-refs to .mdc format', () => {
+    const cursor = getAdapter('cursor');
+    const result = transformSkill(mockSkill, cursor);
+    assert.ok(result.body.includes('@rune-cook.mdc'));
+    assert.ok(!result.body.includes('rune:cook'));
+  });
+
+  test('result has header, body, and footer', () => {
+    const cursor = getAdapter('cursor');
+    const result = transformSkill(mockSkill, cursor);
+    assert.ok(typeof result.header === 'string');
+    assert.ok(typeof result.body === 'string');
+    assert.ok(typeof result.footer === 'string');
+    assert.ok(result.header.length > 0, 'header should not be empty for non-Claude');
+    assert.ok(result.footer.length > 0, 'footer should not be empty for non-Claude');
+  });
+
+  test('Cursor header contains frontmatter with description', () => {
+    const cursor = getAdapter('cursor');
+    const result = transformSkill(mockSkill, cursor);
+    assert.ok(result.header.includes('description:'));
+    assert.ok(result.header.includes('alwaysApply:'));
+  });
+
+  test('Generic adapter transforms refs to descriptive text', () => {
+    const generic = getAdapter('generic');
+    const result = transformSkill(mockSkill, generic);
+    assert.ok(result.body.includes('rune-cook rule file'));
+  });
+
+  test('postProcess strips context: fork and agent: general-purpose', () => {
+    const skillWithDirectives = {
+      ...mockSkill,
+      body: 'context: fork\nagent: general-purpose\n# fix\n\nContent here.',
+    };
+    const cursor = getAdapter('cursor');
+    const result = transformSkill(skillWithDirectives, cursor);
+    assert.ok(!result.body.includes('context: fork'));
+    assert.ok(!result.body.includes('agent: general-purpose'));
+  });
+});