@rune-kit/rune 2.3.3 → 2.6.0

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

@@ -0,0 +1,283 @@
+/**
+ * Scripts Bundling Tests
+ *
+ * Tests the scripts/ directory copy pipeline:
+ * - copyScriptsDir helper
+ * - scriptsDir adapter method
+ * - {scripts_dir} placeholder resolution
+ * - End-to-end buildAll with scripts
+ */
+
+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 { getAdapter } from '../adapters/index.js';
+import { buildAll } from '../emitter.js';
+import { resolveScriptsPath } from '../transforms/scripts-path.js';
+
+// --- resolveScriptsPath transform ---
+
+describe('resolveScriptsPath', () => {
+  test('replaces {scripts_dir} with resolved path', () => {
+    const body = 'Run: `node {scripts_dir}/build-deck.js`';
+    const result = resolveScriptsPath(body, '.cursor/rules/rune-slides-scripts');
+    assert.strictEqual(result, 'Run: `node .cursor/rules/rune-slides-scripts/build-deck.js`');
+  });
+
+  test('replaces multiple occurrences', () => {
+    const body = '{scripts_dir}/a.js and {scripts_dir}/b.js';
+    const result = resolveScriptsPath(body, 'scripts');
+    assert.strictEqual(result, 'scripts/a.js and scripts/b.js');
+  });
+
+  test('returns body unchanged when no placeholder', () => {
+    const body = 'No placeholders here';
+    const result = resolveScriptsPath(body, 'some/path');
+    assert.strictEqual(result, body);
+  });
+
+  test('returns body unchanged when scriptsPath is null', () => {
+    const body = 'Has {scripts_dir} but no path';
+    const result = resolveScriptsPath(body, null);
+    assert.strictEqual(result, body);
+  });
+
+  test('returns body unchanged when body is empty', () => {
+    assert.strictEqual(resolveScriptsPath('', 'path'), '');
+  });
+});
+
+// --- scriptsDir adapter method ---
+
+describe('adapter scriptsDir', () => {
+  test('flat-file adapters return sibling dir pattern', () => {
+    for (const name of ['cursor', 'windsurf', 'antigravity', 'generic', 'openclaw']) {
+      const adapter = getAdapter(name);
+      assert.ok(adapter.scriptsDir, `${name} should have scriptsDir`);
+      assert.strictEqual(adapter.scriptsDir('slides'), 'rune-slides-scripts', `${name} scriptsDir mismatch`);
+    }
+  });
+
+  test('directory-per-skill adapters return nested dir pattern', () => {
+    for (const name of ['codex', 'opencode']) {
+      const adapter = getAdapter(name);
+      assert.ok(adapter.scriptsDir, `${name} should have scriptsDir`);
+      assert.strictEqual(adapter.scriptsDir('slides'), 'rune-slides/scripts', `${name} scriptsDir mismatch`);
+    }
+  });
+
+  test('claude adapter has no scriptsDir (passthrough)', () => {
+    const adapter = getAdapter('claude');
+    assert.ok(!adapter.scriptsDir, 'claude should not have scriptsDir');
+  });
+});
+
+// --- Integration: buildAll with scripts ---
+
+describe('buildAll with scripts', () => {
+  async function createTempSkillTree() {
+    const tmp = path.join(tmpdir(), `rune-scripts-test-${Date.now()}`);
+    const skillsDir = path.join(tmp, 'skills');
+    const slideSkillDir = path.join(skillsDir, 'test-slide');
+    const scriptsDir = path.join(slideSkillDir, 'scripts');
+    const plainSkillDir = path.join(skillsDir, 'test-plain');
+
+    await mkdir(scriptsDir, { recursive: true });
+    await mkdir(plainSkillDir, { recursive: true });
+
+    // Skill with scripts/
+    await writeFile(
+      path.join(slideSkillDir, 'SKILL.md'),
+      [
+        '---',
+        'name: test-slide',
+        'description: "Test slide skill"',
+        'layer: L3',
+        'group: utility',
+        'connections: []',
+        'tags: [test]',
+        '---',
+        '',
+        '# test-slide',
+        '',
+        'Run: `node {scripts_dir}/build-deck.js --input slides.json`',
+        '',
+        'Also: `{scripts_dir}/helper.py`',
+      ].join('\n'),
+      'utf-8',
+    );
+
+    await writeFile(path.join(scriptsDir, 'build-deck.js'), '// build deck script\nconsole.log("hello");\n', 'utf-8');
+    await writeFile(path.join(scriptsDir, 'helper.py'), '# helper\nprint("hi")\n', 'utf-8');
+
+    // Skill without scripts/
+    await writeFile(
+      path.join(plainSkillDir, 'SKILL.md'),
+      [
+        '---',
+        'name: test-plain',
+        'description: "Test plain skill"',
+        'layer: L3',
+        'group: utility',
+        'connections: []',
+        'tags: [test]',
+        '---',
+        '',
+        '# test-plain',
+        '',
+        'No scripts here.',
+      ].join('\n'),
+      'utf-8',
+    );
+
+    // Minimal extensions dir (empty — no packs needed for test)
+    await mkdir(path.join(tmp, 'extensions'), { recursive: true });
+
+    // 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');
+
+    return tmp;
+  }
+
+  test('cursor: scripts copied to sibling dir, placeholder resolved', async () => {
+    const tmp = await createTempSkillTree();
+    try {
+      const outputRoot = path.join(tmp, 'out');
+      const adapter = getAdapter('cursor');
+      const stats = await buildAll({ runeRoot: tmp, outputRoot, adapter });
+
+      // Scripts copied
+      assert.ok(stats.scriptsCopied >= 2, `expected 2+ scripts copied, got ${stats.scriptsCopied}`);
+
+      // Scripts dir exists with files
+      const scriptsOut = path.join(outputRoot, adapter.outputDir, 'rune-test-slide-scripts');
+      assert.ok(existsSync(path.join(scriptsOut, 'build-deck.js')), 'build-deck.js missing in output');
+      assert.ok(existsSync(path.join(scriptsOut, 'helper.py')), 'helper.py missing in output');
+
+      // Placeholder resolved in .mdc output
+      const mdc = await readFile(path.join(outputRoot, adapter.outputDir, 'rune-test-slide.mdc'), 'utf-8');
+      assert.ok(!mdc.includes('{scripts_dir}'), 'placeholder should be resolved');
+      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',
+      );
+    } finally {
+      await rm(tmp, { recursive: true, force: true });
+    }
+  });
+
+  test('codex: scripts inside skill directory', async () => {
+    const tmp = await createTempSkillTree();
+    try {
+      const outputRoot = path.join(tmp, 'out');
+      const adapter = getAdapter('codex');
+      const stats = await buildAll({ runeRoot: tmp, outputRoot, adapter });
+
+      assert.ok(stats.scriptsCopied >= 2);
+
+      // Scripts inside skill dir: .codex/skills/rune-test-slide/scripts/
+      const scriptsOut = path.join(outputRoot, adapter.outputDir, 'rune-test-slide', 'scripts');
+      assert.ok(existsSync(path.join(scriptsOut, 'build-deck.js')), 'build-deck.js missing');
+      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');
+      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 {
+      await rm(tmp, { recursive: true, force: true });
+    }
+  });
+
+  test('skill without scripts: no error, no empty dirs', async () => {
+    const tmp = await createTempSkillTree();
+    try {
+      const outputRoot = path.join(tmp, 'out');
+      const adapter = getAdapter('windsurf');
+      const stats = await buildAll({ runeRoot: tmp, outputRoot, adapter });
+
+      // Should still build both skills
+      assert.strictEqual(stats.skillCount, 2);
+
+      // No scripts dir for plain skill
+      assert.ok(!existsSync(path.join(outputRoot, adapter.outputDir, 'rune-test-plain-scripts')));
+    } finally {
+      await rm(tmp, { recursive: true, force: true });
+    }
+  });
+
+  test('stats include scriptsCopied count', async () => {
+    const tmp = await createTempSkillTree();
+    try {
+      const outputRoot = path.join(tmp, 'out');
+      const adapter = getAdapter('generic');
+      const stats = await buildAll({ runeRoot: tmp, outputRoot, adapter });
+
+      assert.strictEqual(typeof stats.scriptsCopied, 'number');
+      assert.strictEqual(stats.scriptsCopied, 2);
+    } finally {
+      await rm(tmp, { recursive: true, force: true });
+    }
+  });
+
+  test('claude adapter: passthrough, no scripts processing', async () => {
+    const tmp = await createTempSkillTree();
+    try {
+      const outputRoot = path.join(tmp, 'out');
+      const adapter = getAdapter('claude');
+      const stats = await buildAll({ runeRoot: tmp, outputRoot, adapter });
+
+      // Claude is passthrough — no build
+      assert.strictEqual(stats.platform, 'claude');
+      assert.strictEqual(stats.skillCount, 0);
+    } finally {
+      await rm(tmp, { recursive: true, force: true });
+    }
+  });
+
+  test('scripts content copied as-is (byte-for-byte)', async () => {
+    const tmp = await createTempSkillTree();
+    try {
+      const outputRoot = path.join(tmp, 'out');
+      const adapter = getAdapter('cursor');
+      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',
+      );
+      assert.strictEqual(copied, original, 'script content should be identical');
+    } finally {
+      await rm(tmp, { recursive: true, force: true });
+    }
+  });
+
+  test('multiple adapters resolve different paths', async () => {
+    const tmp = await createTempSkillTree();
+    try {
+      // Cursor (flat)
+      const cursorOut = path.join(tmp, 'out-cursor');
+      const cursorAdapter = getAdapter('cursor');
+      await buildAll({ runeRoot: tmp, outputRoot: cursorOut, adapter: cursorAdapter });
+      const cursorMdc = await readFile(path.join(cursorOut, '.cursor/rules/rune-test-slide.mdc'), 'utf-8');
+      assert.ok(cursorMdc.includes('.cursor/rules/rune-test-slide-scripts/'), 'cursor path');
+
+      // Codex (directory)
+      const codexOut = path.join(tmp, 'out-codex');
+      const codexAdapter = getAdapter('codex');
+      await buildAll({ runeRoot: tmp, outputRoot: codexOut, adapter: codexAdapter });
+      const codexMd = await readFile(path.join(codexOut, '.codex/skills/rune-test-slide/SKILL.md'), 'utf-8');
+      assert.ok(codexMd.includes('.codex/skills/rune-test-slide/scripts/'), 'codex path');
+    } 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 });
+    }
+  });
+});

package/compiler/__tests__/tier-override.test.js

@@ -155,4 +155,45 @@ describe('discoverTieredPacks', () => {
       rmSync(root, { recursive: true, force: true });
     }
   });
+
+  test('pro override tracks free pack in overrides array', async () => {
+    const { freePacks, proPacks, root } = createTierFixture();
+    try {
+      const packs = await discoverTieredPacks(freePacks, { pro: proPacks });
+      const saasPack = packs.find((p) => p.dirName === 'pro-saas');
+      assert.ok(saasPack, 'pro-saas should exist');
+      assert.strictEqual(saasPack.overrides.length, 1);
+      assert.strictEqual(saasPack.overrides[0].tier, 'free');
+      assert.strictEqual(saasPack.overrides[0].dirName, 'saas');
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  test('business override tracks both pro and free in overrides array', async () => {
+    const { freePacks, proPacks, bizPacks, root } = createTierFixture();
+    try {
+      const packs = await discoverTieredPacks(freePacks, { pro: proPacks, business: bizPacks });
+      const saasPack = packs.find((p) => p.dirName === 'business-saas');
+      assert.ok(saasPack, 'business-saas should exist');
+      // Should have both free and pro overrides (free was overridden by pro, then pro by business)
+      assert.strictEqual(saasPack.overrides.length, 2);
+      const overrideTiers = saasPack.overrides.map((o) => o.tier).sort();
+      assert.deepStrictEqual(overrideTiers, ['free', 'pro']);
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  test('free-only packs have empty overrides array', async () => {
+    const { freePacks, proPacks, root } = createTierFixture();
+    try {
+      const packs = await discoverTieredPacks(freePacks, { pro: proPacks });
+      const tradingPack = packs.find((p) => p.dirName === 'trading');
+      assert.ok(tradingPack, 'trading should exist');
+      assert.deepStrictEqual(tradingPack.overrides, []);
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
 });

package/compiler/adapters/antigravity.js

@@ -1,53 +1,71 @@
-/**
- * Google Antigravity (Jules) Adapter
- *
- * Emits .md rule files for .agent/rules/ directory.
- */
-
-import { BRANDING_FOOTER } from '../transforms/branding.js';
-
-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 BRANDING_FOOTER;
-  },
-
-  transformSubagentInstruction(text) {
-    return text;
-  },
-
-  postProcess(content) {
-    return content.replace(/^context: fork\n/gm, '').replace(/^agent: general-purpose\n/gm, '');
-  },
-};
+/**
+ * Google Antigravity (Jules) Adapter
+ *
+ * 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';
+
+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: '.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} skill`;
+    return isBackticked ? `\`${ref}\`` : ref;
+  },
+
+  transformToolName(toolName) {
+    return TOOL_MAP[toolName] || toolName;
+  },
+
+  generateHeader(skill) {
+    const desc = (skill.description || '').replace(/"/g, '\\"');
+    return ['---', `name: rune-${skill.name}`, `description: "${desc}"`, '---', '', ''].join('\n');
+  },
+
+  generateFooter() {
+    return BRANDING_FOOTER;
+  },
+
+  transformSubagentInstruction(text) {
+    return text;
+  },
+
+  scriptsDir(skillName) {
+    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/adapters/codex.js

@@ -58,6 +58,10 @@ export default {
     return text;
   },
 
+  scriptsDir(skillName) {
+    return `rune-${skillName}/scripts`;
+  },
+
   postProcess(content) {
     return content.replace(/^context: fork\n/gm, '').replace(/^agent: general-purpose\n/gm, '');
   },