@rune-kit/rune 2.1.1

package/compiler/__tests__/openclaw-adapter.test.js

@@ -0,0 +1,140 @@
+import openclaw from '../adapters/openclaw.js';
+import { test } from 'node:test';
+import assert from 'node:assert';
+
+// --- Adapter shape ---
+
+test('openclaw adapter has all required properties', () => {
+  const required = [
+    'name', 'outputDir', 'fileExtension', 'skillPrefix', 'skillSuffix',
+    'transformReference', 'transformToolName', 'generateHeader', 'generateFooter',
+    'transformSubagentInstruction', 'postProcess',
+    'generateManifest', 'generateEntryPoint',
+  ];
+  for (const prop of required) {
+    assert.ok(prop in openclaw, `missing property: ${prop}`);
+  }
+});
+
+test('openclaw adapter has correct name and outputDir', () => {
+  assert.strictEqual(openclaw.name, 'openclaw');
+  assert.strictEqual(openclaw.outputDir, '.openclaw/rune/skills');
+  assert.strictEqual(openclaw.fileExtension, '.md');
+  assert.strictEqual(openclaw.skillPrefix, 'rune-');
+  assert.strictEqual(openclaw.skillSuffix, '');
+});
+
+// --- transformReference ---
+
+test('transformReference returns correct skill file reference', () => {
+  const result = openclaw.transformReference('cook', 'cook');
+  assert.strictEqual(result, 'rune-cook.md');
+});
+
+test('transformReference preserves backticks', () => {
+  const result = openclaw.transformReference('plan', '`plan`');
+  assert.strictEqual(result, '`rune-plan.md`');
+});
+
+// --- transformToolName ---
+
+test('transformToolName maps Claude Code tools to OpenClaw equivalents', () => {
+  assert.strictEqual(openclaw.transformToolName('Read'), 'read_file');
+  assert.strictEqual(openclaw.transformToolName('Write'), 'write_file');
+  assert.strictEqual(openclaw.transformToolName('Edit'), 'edit_file');
+  assert.strictEqual(openclaw.transformToolName('Bash'), 'run_command');
+  assert.strictEqual(openclaw.transformToolName('Glob'), 'glob');
+  assert.strictEqual(openclaw.transformToolName('Grep'), 'grep');
+});
+
+test('transformToolName passes through unknown tools', () => {
+  assert.strictEqual(openclaw.transformToolName('CustomTool'), 'CustomTool');
+});
+
+// --- generateHeader / generateFooter ---
+
+test('generateHeader produces valid markdown', () => {
+  const skill = { name: 'cook', layer: 'L1', group: 'orchestrator' };
+  const header = openclaw.generateHeader(skill);
+  assert.ok(header.startsWith('# rune-cook'));
+  assert.ok(header.includes('L1'));
+  assert.ok(header.includes('orchestrator'));
+});
+
+test('generateFooter includes Rune branding', () => {
+  const footer = openclaw.generateFooter();
+  assert.ok(footer.includes('Rune Skill Mesh'));
+  assert.ok(footer.includes('github.com/rune-kit/rune'));
+});
+
+// --- postProcess ---
+
+test('postProcess strips Claude-specific directives', () => {
+  const input = 'context: fork\nsome content\nagent: general-purpose\nmore content';
+  const result = openclaw.postProcess(input);
+  assert.ok(!result.includes('context: fork'));
+  assert.ok(!result.includes('agent: general-purpose'));
+  assert.ok(result.includes('some content'));
+  assert.ok(result.includes('more content'));
+});
+
+// --- generateManifest ---
+
+test('generateManifest returns valid openclaw.plugin.json structure', () => {
+  const skills = [
+    { name: 'cook', layer: 'L1', group: 'orchestrator' },
+    { name: 'plan', layer: 'L2', group: 'workflow' },
+  ];
+  const pluginJson = { version: '2.1.1', name: 'rune' };
+
+  const manifest = openclaw.generateManifest(skills, pluginJson);
+
+  assert.strictEqual(manifest.id, 'rune');
+  assert.strictEqual(manifest.name, 'Rune');
+  assert.strictEqual(manifest.kind, 'skills');
+  assert.strictEqual(manifest.version, '2.1.1');
+  assert.ok(Array.isArray(manifest.skills));
+  assert.deepStrictEqual(manifest.skills, ['./skills']);
+  assert.ok(manifest.configSchema);
+  assert.ok(manifest.configSchema.jsonSchema);
+  assert.strictEqual(manifest.configSchema.jsonSchema.type, 'object');
+});
+
+test('generateManifest defaults version when missing', () => {
+  const manifest = openclaw.generateManifest([], {});
+  assert.strictEqual(manifest.version, '0.0.0');
+});
+
+// --- generateEntryPoint ---
+
+test('generateEntryPoint returns valid TypeScript with register(api)', () => {
+  const skills = [
+    { name: 'cook', layer: 'L1', group: 'orchestrator', description: 'Feature orchestrator' },
+    { name: 'fix', layer: 'L2', group: 'workflow', description: 'Apply fixes' },
+  ];
+  const routerContent = '# skill-router\n\nRoute all tasks.';
+
+  const ts = openclaw.generateEntryPoint(skills, routerContent);
+
+  assert.ok(ts.includes('register(api'));
+  assert.ok(ts.includes("before_agent_start"));
+  assert.ok(ts.includes('prependSystemContext'));
+  assert.ok(ts.includes('export default plugin'));
+  assert.ok(ts.includes('cook'));
+  assert.ok(ts.includes('fix'));
+  assert.ok(ts.includes('skill-router'));
+});
+
+test('generateEntryPoint handles empty router content', () => {
+  const ts = openclaw.generateEntryPoint([], '');
+  assert.ok(ts.includes('register(api'));
+  assert.ok(ts.includes('export default plugin'));
+});
+
+test('generateEntryPoint escapes backticks in router content', () => {
+  const routerContent = 'Use `cook` skill for code tasks';
+  const ts = openclaw.generateEntryPoint([], routerContent);
+  // Should not have unescaped backticks inside template literal
+  assert.ok(!ts.includes('Use `cook`'));
+  assert.ok(ts.includes('\\`cook\\`'));
+});

package/compiler/__tests__/parser.test.js

@@ -0,0 +1,55 @@
+import { parseSkill } from '../parser.js';
+import { readFileSync } from 'node:fs';
+import { test } from 'node:test';
+import assert from 'node:assert';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const SKILLS_DIR = path.resolve(__dirname, '../../skills');
+
+test('parse cook SKILL.md', () => {
+  const content = readFileSync(path.join(SKILLS_DIR, 'cook/SKILL.md'), 'utf-8');
+  const parsed = parseSkill(content, 'cook/SKILL.md');
+
+  console.log('name:', JSON.stringify(parsed.name));
+  console.log('description:', JSON.stringify(parsed.description?.substring(0, 50)));
+  console.log('layer:', parsed.layer);
+  console.log('model:', parsed.model);
+  console.log('group:', parsed.group);
+  console.log('contextFork:', parsed.contextFork);
+  console.log('agentType:', parsed.agentType);
+  console.log('crossRefs:', parsed.crossRefs.length);
+  console.log('toolRefs:', parsed.toolRefs.length);
+  console.log('hardGates:', parsed.hardGates.length);
+  console.log('sections:', [...parsed.sections.keys()]);
+  console.log('frontmatter keys:', Object.keys(parsed.frontmatter));
+
+  assert.strictEqual(parsed.name, 'cook');
+  assert.strictEqual(parsed.layer, 'L1');
+  assert.ok(parsed.crossRefs.length > 0);
+  assert.ok(parsed.hardGates.length > 0);
+});
+
+test('parse fix SKILL.md', () => {
+  const content = readFileSync(path.join(SKILLS_DIR, 'fix/SKILL.md'), 'utf-8');
+  const parsed = parseSkill(content, 'fix/SKILL.md');
+
+  console.log('fix name:', JSON.stringify(parsed.name));
+  console.log('fix layer:', parsed.layer);
+
+  assert.strictEqual(parsed.name, 'fix');
+  assert.strictEqual(parsed.layer, 'L2');
+});
+
+test('parse verification SKILL.md', () => {
+  const content = readFileSync(path.join(SKILLS_DIR, 'verification/SKILL.md'), 'utf-8');
+  const parsed = parseSkill(content, 'verification/SKILL.md');
+
+  console.log('verification name:', JSON.stringify(parsed.name));
+  console.log('verification layer:', parsed.layer);
+  console.log('verification toolRefs:', parsed.toolRefs.length);
+
+  assert.strictEqual(parsed.name, 'verification');
+  assert.strictEqual(parsed.layer, 'L3');
+});

package/compiler/adapters/antigravity.js

@@ -0,0 +1,59 @@
+/**
+ * Google Antigravity (Jules) Adapter
+ *
+ * Emits .md rule files for .agent/rules/ directory.
+ */
+
+const TOOL_MAP = {
+  Read: 'read the file',
+  Write: 'write/create the file',
+  Edit: 'edit the file',
+  Glob: 'find files by pattern',
+  Grep: 'search file contents',
+  Bash: 'run a shell command',
+  TodoWrite: 'track task progress',
+  Skill: 'follow the referenced skill',
+  Agent: 'execute the workflow',
+};
+
+export default {
+  name: 'antigravity',
+  outputDir: '.agent/rules',
+  fileExtension: '.md',
+  skillPrefix: 'rune-',
+  skillSuffix: '',
+
+  transformReference(skillName, raw) {
+    const isBackticked = raw.startsWith('`') && raw.endsWith('`');
+    const ref = `the rune-${skillName} rule`;
+    return isBackticked ? `\`${ref}\`` : ref;
+  },
+
+  transformToolName(toolName) {
+    return TOOL_MAP[toolName] || toolName;
+  },
+
+  generateHeader(skill) {
+    return `# rune-${skill.name}\n\n> Rune ${skill.layer} Skill | ${skill.group}\n\n`;
+  },
+
+  generateFooter() {
+    return [
+      '',
+      '---',
+      '> **Rune Skill Mesh** — 49 skills, 170+ connections',
+      '> Source: https://github.com/rune-kit/rune',
+      '> Full experience with subagents, hooks, adaptive routing → use Rune on Claude Code.',
+    ].join('\n');
+  },
+
+  transformSubagentInstruction(text) {
+    return text;
+  },
+
+  postProcess(content) {
+    return content
+      .replace(/^context: fork\n/gm, '')
+      .replace(/^agent: general-purpose\n/gm, '');
+  },
+};

package/compiler/adapters/claude.js

@@ -0,0 +1,37 @@
+/**
+ * Claude Code Adapter (Passthrough)
+ *
+ * No transformation needed — source IS the output.
+ */
+
+export default {
+  name: 'claude',
+  outputDir: null,
+  fileExtension: '.md',
+  skillPrefix: '',
+  skillSuffix: '',
+
+  transformReference(skillName, raw) {
+    return raw;
+  },
+
+  transformToolName(toolName) {
+    return toolName;
+  },
+
+  generateHeader(_skill) {
+    return '';
+  },
+
+  generateFooter() {
+    return '';
+  },
+
+  transformSubagentInstruction(text) {
+    return text;
+  },
+
+  postProcess(content) {
+    return content;
+  },
+};

package/compiler/adapters/cursor.js

@@ -0,0 +1,67 @@
+/**
+ * Cursor Adapter
+ *
+ * Emits .mdc rule files for .cursor/rules/ directory.
+ * Uses @file references for cross-skill mesh.
+ */
+
+const TOOL_MAP = {
+  Read: 'read the file',
+  Write: 'write/create the file',
+  Edit: 'edit the file',
+  Glob: 'search for files by pattern',
+  Grep: 'search file contents',
+  Bash: 'run a terminal command',
+  TodoWrite: 'track progress',
+  Skill: 'follow the referenced skill rules',
+  Agent: 'execute the workflow',
+};
+
+export default {
+  name: 'cursor',
+  outputDir: '.cursor/rules',
+  fileExtension: '.mdc',
+  skillPrefix: 'rune-',
+  skillSuffix: '',
+
+  transformReference(skillName, raw) {
+    const isBackticked = raw.startsWith('`') && raw.endsWith('`');
+    const ref = `@rune-${skillName}.mdc`;
+    return isBackticked ? `\`${ref}\`` : ref;
+  },
+
+  transformToolName(toolName) {
+    return TOOL_MAP[toolName] || toolName;
+  },
+
+  generateHeader(skill) {
+    return [
+      '---',
+      `description: "${skill.description}"`,
+      'globs: []',
+      `alwaysApply: ${skill.layer === 'L0'}`,
+      '---',
+      '',
+    ].join('\n');
+  },
+
+  generateFooter() {
+    return [
+      '',
+      '---',
+      '> **Rune Skill Mesh** — 49 skills, 170+ connections',
+      '> Source: https://github.com/rune-kit/rune',
+      '> Full experience with subagents, hooks, adaptive routing → use Rune on Claude Code.',
+    ].join('\n');
+  },
+
+  transformSubagentInstruction(text) {
+    return text;
+  },
+
+  postProcess(content) {
+    return content
+      .replace(/^context: fork\n/gm, '')
+      .replace(/^agent: general-purpose\n/gm, '');
+  },
+};

package/compiler/adapters/generic.js

@@ -0,0 +1,60 @@
+/**
+ * Generic Adapter (Fallback)
+ *
+ * For unknown or future platforms. Emits to .ai/rules/ directory.
+ * Uses the most portable format possible.
+ */
+
+const TOOL_MAP = {
+  Read: 'read the file',
+  Write: 'write/create the file',
+  Edit: 'edit the file',
+  Glob: 'find files by pattern',
+  Grep: 'search file contents',
+  Bash: 'run a shell command',
+  TodoWrite: 'track task progress',
+  Skill: 'follow the referenced skill',
+  Agent: 'execute the workflow',
+};
+
+export default {
+  name: 'generic',
+  outputDir: '.ai/rules',
+  fileExtension: '.md',
+  skillPrefix: 'rune-',
+  skillSuffix: '',
+
+  transformReference(skillName, raw) {
+    const isBackticked = raw.startsWith('`') && raw.endsWith('`');
+    const ref = `the rune-${skillName} rule file`;
+    return isBackticked ? `\`${ref}\`` : ref;
+  },
+
+  transformToolName(toolName) {
+    return TOOL_MAP[toolName] || toolName;
+  },
+
+  generateHeader(skill) {
+    return `# rune-${skill.name}\n\n> Rune ${skill.layer} Skill | ${skill.group}\n\n`;
+  },
+
+  generateFooter() {
+    return [
+      '',
+      '---',
+      '> **Rune Skill Mesh** — 49 skills, 170+ connections',
+      '> Source: https://github.com/rune-kit/rune',
+      '> Full experience with subagents, hooks, adaptive routing → use Rune on Claude Code.',
+    ].join('\n');
+  },
+
+  transformSubagentInstruction(text) {
+    return text;
+  },
+
+  postProcess(content) {
+    return content
+      .replace(/^context: fork\n/gm, '')
+      .replace(/^agent: general-purpose\n/gm, '');
+  },
+};

package/compiler/adapters/index.js

@@ -0,0 +1,45 @@
+/**
+ * Adapter Registry
+ *
+ * Central registry for all platform adapters.
+ */
+
+import claude from './claude.js';
+import cursor from './cursor.js';
+import windsurf from './windsurf.js';
+import antigravity from './antigravity.js';
+import generic from './generic.js';
+import openclaw from './openclaw.js';
+
+const adapters = {
+  claude,
+  cursor,
+  windsurf,
+  antigravity,
+  generic,
+  openclaw,
+};
+
+/**
+ * Get adapter by platform name
+ * @param {string} platform
+ * @returns {object} adapter
+ */
+export function getAdapter(platform) {
+  const adapter = adapters[platform];
+  if (!adapter) {
+    const available = Object.keys(adapters).join(', ');
+    throw new Error(`Unknown platform "${platform}". Available: ${available}`);
+  }
+  return adapter;
+}
+
+/**
+ * List all available platform names
+ * @returns {string[]}
+ */
+export function listPlatforms() {
+  return Object.keys(adapters);
+}
+
+export { adapters };

package/compiler/adapters/openclaw.js

@@ -0,0 +1,150 @@
+/**
+ * OpenClaw Adapter
+ *
+ * Emits an OpenClaw plugin structure:
+ *   .openclaw/rune/openclaw.plugin.json  (manifest)
+ *   .openclaw/rune/src/index.ts          (register entrypoint)
+ *   .openclaw/rune/skills/*.md           (transformed skill files)
+ *
+ * Follows the NeuralMemory OpenClaw plugin pattern.
+ */
+
+const TOOL_MAP = {
+  Read: 'read_file',
+  Write: 'write_file',
+  Edit: 'edit_file',
+  Glob: 'glob',
+  Grep: 'grep',
+  Bash: 'run_command',
+  TodoWrite: 'todo_write',
+  Skill: 'follow the referenced skill',
+  Agent: 'execute the workflow',
+};
+
+export default {
+  name: 'openclaw',
+  outputDir: '.openclaw/rune/skills',
+  fileExtension: '.md',
+  skillPrefix: 'rune-',
+  skillSuffix: '',
+
+  transformReference(skillName, raw) {
+    const isBackticked = raw.startsWith('`') && raw.endsWith('`');
+    const ref = `rune-${skillName}.md`;
+    return isBackticked ? `\`${ref}\`` : ref;
+  },
+
+  transformToolName(toolName) {
+    return TOOL_MAP[toolName] || toolName;
+  },
+
+  generateHeader(skill) {
+    return `# rune-${skill.name}\n\n> Rune ${skill.layer} Skill | ${skill.group}\n\n`;
+  },
+
+  generateFooter() {
+    return [
+      '',
+      '---',
+      '> **Rune Skill Mesh** — 55 skills, 200+ connections',
+      '> Source: https://github.com/rune-kit/rune',
+    ].join('\n');
+  },
+
+  transformSubagentInstruction(text) {
+    return text;
+  },
+
+  postProcess(content) {
+    return content
+      .replace(/^context: fork\n/gm, '')
+      .replace(/^agent: general-purpose\n/gm, '');
+  },
+
+  /**
+   * Generate openclaw.plugin.json manifest
+   *
+   * @param {object[]} skills - parsed skill objects
+   * @param {object} pluginJson - Rune's .claude-plugin/plugin.json
+   * @returns {object} manifest object
+   */
+  generateManifest(skills, pluginJson) {
+    return {
+      id: 'rune',
+      name: 'Rune',
+      kind: 'skills',
+      description: '55-skill mesh for AI coding assistants. Routes all code tasks through specialized skills.',
+      version: pluginJson.version || '0.0.0',
+      skills: ['./skills'],
+      configSchema: {
+        jsonSchema: {
+          type: 'object',
+          properties: {
+            disabledSkills: {
+              type: 'array',
+              items: { type: 'string' },
+              description: 'Skills to disable (by name)',
+              default: [],
+            },
+          },
+          additionalProperties: false,
+        },
+        uiHints: {
+          disabledSkills: {
+            label: 'Disabled Skills',
+            help: 'Comma-separated list of skill names to exclude from routing',
+          },
+        },
+      },
+    };
+  },
+
+  /**
+   * Generate src/index.ts entry point with register(api) pattern
+   *
+   * @param {object[]} skills - parsed skill objects
+   * @param {string} routerContent - skill-router SKILL.md content for injection
+   * @returns {string} TypeScript source
+   */
+  generateEntryPoint(skills, routerContent) {
+    const skillNames = skills.map(s => s.name);
+    const routingTable = skills
+      .map(s => `//   ${s.name} (${s.layer}) — ${s.description || s.group}`)
+      .join('\n');
+
+    // Escape backticks and backslashes in router content for template literal
+    const escapedRouter = (routerContent || '')
+      .replace(/\\/g, '\\\\')
+      .replace(/`/g, '\\`')
+      .replace(/\$/g, '\\$');
+
+    return `/**
+ * Rune — OpenClaw Plugin Entry Point
+ *
+ * Auto-generated by Rune compiler.
+ * Do not edit manually — regenerate with: rune build --platform openclaw
+ *
+ * Skills (${skillNames.length}):
+${routingTable}
+ */
+
+const SKILL_ROUTER_INSTRUCTIONS = \`${escapedRouter}\`;
+
+const plugin = {
+  id: 'rune',
+  name: 'Rune',
+
+  register(api: any): void {
+    // Inject skill-router instructions so the agent routes through Rune skills
+    api.on('before_agent_start', async () => {
+      return {
+        prependSystemContext: SKILL_ROUTER_INSTRUCTIONS,
+      };
+    }, { priority: 5 });
+  },
+};
+
+export default plugin;
+`;
+  },
+};

package/compiler/adapters/windsurf.js

@@ -0,0 +1,60 @@
+/**
+ * Windsurf Adapter
+ *
+ * Emits .md rule files for .windsurf/rules/ directory.
+ * Uses prose references for cross-skill mesh (no @file support).
+ */
+
+const TOOL_MAP = {
+  Read: 'read the file',
+  Write: 'write/create the file',
+  Edit: 'edit the file',
+  Glob: 'find files matching a pattern',
+  Grep: 'search for text in files',
+  Bash: 'run a shell command',
+  TodoWrite: 'track task progress',
+  Skill: 'follow the referenced skill workflow',
+  Agent: 'execute the workflow',
+};
+
+export default {
+  name: 'windsurf',
+  outputDir: '.windsurf/rules',
+  fileExtension: '.md',
+  skillPrefix: 'rune-',
+  skillSuffix: '',
+
+  transformReference(skillName, raw) {
+    const isBackticked = raw.startsWith('`') && raw.endsWith('`');
+    const ref = `the rune-${skillName} rule file`;
+    return isBackticked ? `\`${ref}\`` : ref;
+  },
+
+  transformToolName(toolName) {
+    return TOOL_MAP[toolName] || toolName;
+  },
+
+  generateHeader(skill) {
+    return `# rune-${skill.name}\n\n> Layer: ${skill.layer} | Group: ${skill.group}\n\n`;
+  },
+
+  generateFooter() {
+    return [
+      '',
+      '---',
+      '> **Rune Skill Mesh** — 49 skills, 170+ connections',
+      '> Source: https://github.com/rune-kit/rune',
+      '> Full experience with subagents, hooks, adaptive routing → use Rune on Claude Code.',
+    ].join('\n');
+  },
+
+  transformSubagentInstruction(text) {
+    return text;
+  },
+
+  postProcess(content) {
+    return content
+      .replace(/^context: fork\n/gm, '')
+      .replace(/^agent: general-purpose\n/gm, '');
+  },
+};