@rune-kit/rune 2.16.1 → 2.18.0

package/compiler/__tests__/setup.test.js

@@ -0,0 +1,152 @@
+import assert from 'node:assert';
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, test } from 'node:test';
+import { detectTiers, formatSetupResult, runSetup } from '../commands/setup.js';
+
+let tmpRoot;
+
+async function seedClaude(root) {
+  await mkdir(path.join(root, '.claude'), { recursive: true });
+}
+
+async function seedTier(root, tier) {
+  const dir = path.join(root, '..', tier === 'pro' ? 'Pro' : 'Business', 'hooks');
+  await mkdir(dir, { recursive: true });
+  await writeFile(
+    path.join(dir, 'manifest.json'),
+    JSON.stringify({
+      tier,
+      version: '1.0.0',
+      minFreeVersion: '2.0.0',
+      requires: [tier === 'pro' ? 'RUNE_PRO_ROOT' : 'RUNE_BUSINESS_ROOT'],
+      entries: [],
+    }),
+  );
+}
+
+beforeEach(async () => {
+  tmpRoot = await mkdtemp(path.join(tmpdir(), 'rune-setup-'));
+  await mkdir(path.join(tmpRoot, 'project'), { recursive: true });
+});
+
+afterEach(async () => {
+  if (tmpRoot) await rm(tmpRoot, { recursive: true, force: true });
+  delete process.env.RUNE_PRO_ROOT;
+  delete process.env.RUNE_BUSINESS_ROOT;
+});
+
+describe('detectTiers', () => {
+  test('returns null for both when no tier present', () => {
+    const projectRoot = path.join(tmpRoot, 'project');
+    const result = detectTiers(projectRoot, { wellKnownPaths: { pro: [], business: [] } });
+    assert.strictEqual(result.pro, null);
+    assert.strictEqual(result.business, null);
+  });
+
+  test('detects Pro via sibling path', async () => {
+    const projectRoot = path.join(tmpRoot, 'project');
+    await seedTier(projectRoot, 'pro');
+    const result = detectTiers(projectRoot, { wellKnownPaths: { pro: [], business: [] } });
+    assert.ok(result.pro);
+    assert.match(result.pro.source, /sibling/);
+    assert.strictEqual(result.pro.version, '1.0.0');
+    assert.strictEqual(result.business, null);
+  });
+
+  test('detects Business via sibling path', async () => {
+    const projectRoot = path.join(tmpRoot, 'project');
+    await seedTier(projectRoot, 'business');
+    const result = detectTiers(projectRoot, { wellKnownPaths: { pro: [], business: [] } });
+    assert.ok(result.business);
+    assert.match(result.business.source, /sibling/);
+    assert.strictEqual(result.pro, null);
+  });
+
+  test('env var takes precedence over sibling', async () => {
+    const projectRoot = path.join(tmpRoot, 'project');
+    await seedTier(projectRoot, 'pro');
+    // Env var pointing at a different location
+    const envRoot = path.join(tmpRoot, 'env-pro');
+    await mkdir(path.join(envRoot, 'hooks'), { recursive: true });
+    await writeFile(
+      path.join(envRoot, 'hooks', 'manifest.json'),
+      JSON.stringify({ tier: 'pro', version: '2.0.0', minFreeVersion: '2.0.0', requires: [], entries: [] }),
+    );
+    process.env.RUNE_PRO_ROOT = envRoot;
+    const result = detectTiers(projectRoot, { wellKnownPaths: { pro: [], business: [] } });
+    assert.match(result.pro.source, /\$RUNE_PRO_ROOT/);
+    assert.strictEqual(result.pro.version, '2.0.0');
+  });
+});
+
+describe('runSetup (non-interactive)', () => {
+  test('--here installs to current project, no tiers when none detected', async () => {
+    const projectRoot = path.join(tmpRoot, 'project');
+    await seedClaude(projectRoot);
+    const result = await runSetup({
+      projectRoot,
+      runeRoot: path.resolve(path.dirname(new URL(import.meta.url).pathname), '..', '..'),
+      args: { here: true, preset: 'gentle', 'no-tier': true },
+    });
+    assert.strictEqual(result.scope, 'current');
+    assert.strictEqual(result.preset, 'gentle');
+    assert.deepStrictEqual(result.tiers, []);
+    assert.strictEqual(result.targetRoot, projectRoot);
+  });
+
+  test('--tier flag bypasses prompt', async () => {
+    const projectRoot = path.join(tmpRoot, 'project');
+    await seedClaude(projectRoot);
+    await seedTier(projectRoot, 'pro');
+    const result = await runSetup({
+      projectRoot,
+      runeRoot: path.resolve(path.dirname(new URL(import.meta.url).pathname), '..', '..'),
+      args: { here: true, preset: 'gentle', tier: 'pro' },
+    });
+    assert.deepStrictEqual(result.tiers, ['pro']);
+  });
+
+  test('--dry does not write files', async () => {
+    const projectRoot = path.join(tmpRoot, 'project');
+    await seedClaude(projectRoot);
+    const result = await runSetup({
+      projectRoot,
+      runeRoot: path.resolve(path.dirname(new URL(import.meta.url).pathname), '..', '..'),
+      args: { here: true, preset: 'gentle', 'no-tier': true, dry: true },
+    });
+    assert.strictEqual(result.written, false);
+  });
+});
+
+describe('formatSetupResult', () => {
+  test('renders summary with scope and tiers', () => {
+    const out = formatSetupResult({
+      scope: 'current',
+      targetRoot: '/path/to/project',
+      tiers: ['pro'],
+      preset: 'gentle',
+      platforms: ['claude'],
+      written: true,
+      notes: [],
+    });
+    assert.match(out, /Setup Complete/);
+    assert.match(out, /Tiers:.*Free.*pro/);
+    assert.match(out, /current project/);
+    assert.match(out, /rune doctor --hooks/);
+  });
+
+  test('renders global scope label when scope=global', () => {
+    const out = formatSetupResult({
+      scope: 'global',
+      targetRoot: '/home/user',
+      tiers: [],
+      preset: 'gentle',
+      platforms: ['claude'],
+      written: true,
+      notes: [],
+    });
+    assert.match(out, /GLOBAL/);
+  });
+});

package/compiler/adapters/aider.js

@@ -0,0 +1,120 @@
+/**
+ * Aider Adapter
+ *
+ * Emits per-skill convention files into aider/rules/ and a `.aider.conf.yml`
+ * at the project root with a `read:` array pointing to every rule file. Aider
+ * loads everything in `read:` automatically on each session.
+ *
+ * Aider rules dir: aider/rules/
+ * Aider rule file: aider/rules/rune-{name}.md
+ * Aider config: .aider.conf.yml (auto-discovered: home dir → repo root → cwd)
+ *
+ * @see https://aider.chat/docs/usage/conventions.html
+ * @see https://aider.chat/docs/config/aider_conf.html
+ *
+ * MODEL TIER MAPPING (v2.18+):
+ * Aider supports any provider via env vars / CLI flags. Tier hint is emitted
+ * as a comment — aider does not parse model directives from rule files.
+ */
+
+import { BRANDING_FOOTER } from '../transforms/branding.js';
+
+const MODEL_MAP = {
+  opus: 'tier:heavy',
+  sonnet: 'tier:mid',
+  haiku: 'tier:light',
+};
+
+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 rune-{name} convention',
+  Agent: 'execute the workflow',
+};
+
+export default {
+  name: 'aider',
+  outputDir: 'aider/rules',
+  fileExtension: '.md',
+  skillPrefix: 'rune-',
+  skillSuffix: '',
+
+  // Aider conventions are flat per-skill markdown files.
+  useSkillDirectories: false,
+
+  transformReference(skillName, raw) {
+    const isBackticked = raw.startsWith('`') && raw.endsWith('`');
+    const ref = `the rune-${skillName} convention`;
+    return isBackticked ? `\`${ref}\`` : ref;
+  },
+
+  transformToolName(toolName) {
+    return TOOL_MAP[toolName] || toolName;
+  },
+
+  generateHeader(skill) {
+    const tierHint = skill.model ? MODEL_MAP[skill.model] || skill.model : null;
+    const tierLine = tierHint ? ` | ${tierHint}` : '';
+    return `# rune-${skill.name}\n\n> Rune ${skill.layer} ${skill.group}${tierLine}\n> ${(skill.description || '').replace(/\n/g, ' ')}\n\n`;
+  },
+
+  generateFooter() {
+    return BRANDING_FOOTER;
+  },
+
+  transformSubagentInstruction(text) {
+    return text;
+  },
+
+  scriptsDir(skillName) {
+    return `rune-${skillName}-scripts`;
+  },
+
+  postProcess(content) {
+    return content.replace(/^context: fork\n/gm, '').replace(/^agent: general-purpose\n/gm, '');
+  },
+
+  // Emit `.aider.conf.yml` with `read:` array referencing every rule file +
+  // a CONVENTIONS.md as the high-level entry point.
+  generateExtraFiles({ stats }) {
+    // stats.files holds entries like 'rune-cook.md' (per-skill) and 'index.md' (autogen).
+    // Filter to per-skill rule files; aider loads everything in read[] on every session.
+    const ruleFiles = stats.files
+      .filter((f) => f.startsWith('rune-') && f.endsWith('.md') && !f.includes('/') && !f.includes('\\'))
+      .sort();
+
+    const conf = [
+      '# Auto-generated by Rune — do not edit manually.',
+      '# Aider auto-loads every file listed under `read:` on each session.',
+      'read:',
+      ...ruleFiles.map((f) => `  - aider/rules/${f}`),
+      '',
+    ].join('\n');
+
+    const conventions = [
+      '# Rune Conventions for Aider',
+      '',
+      `Rune compiles ${stats.skillCount} skills + ${stats.packCount} packs into per-skill convention files under \`aider/rules/\`. Aider auto-loads them via \`.aider.conf.yml\`.`,
+      '',
+      'When a request matches a skill (e.g. "implement", "refactor", "review"), follow the matching rune-<name> convention.',
+      '',
+      '## Loaded Conventions',
+      '',
+      ...ruleFiles.map((f) => `- \`aider/rules/${f}\``),
+      '',
+      '---',
+      '> Rune Skill Mesh — https://github.com/rune-kit/rune',
+      '',
+    ].join('\n');
+
+    return [
+      { path: '.aider.conf.yml', content: conf },
+      { path: 'CONVENTIONS.md', content: conventions },
+    ];
+  },
+};

package/compiler/adapters/codex.js

@@ -80,4 +80,37 @@ export default {
   postProcess(content) {
     return content.replace(/^context: fork\n/gm, '').replace(/^agent: general-purpose\n/gm, '');
   },
+
+  // Codex (and OpenAI's AGENTS.md convention generally) reads AGENTS.md at the
+  // project root for high-level context. Migrated from emitter.js v2.18.
+  generateExtraFiles({ stats }) {
+    const agentsMd = [
+      '# Rune — Project Configuration',
+      '',
+      '## Overview',
+      '',
+      'Rune is an interconnected skill ecosystem for AI coding assistants.',
+      `${stats.skillCount} core skills | 5-layer mesh architecture | ${stats.crossRefsResolved} connections | Multi-platform.`,
+      'Philosophy: "Less skills. Deeper connections."',
+      '',
+      'Platform: codex',
+      '',
+      '## Skills',
+      '',
+      `**${stats.skillCount} core skills** + **${stats.packCount} extension packs**`,
+      '',
+      '## Usage',
+      '',
+      'Reference skills using the `Skill` tool or delegate to subagents using the `Agent` tool.',
+      '',
+      '## Skills Directory',
+      '',
+      'Skills are located in: .codex/skills/',
+      '',
+      '---',
+      '> Rune Skill Mesh — https://github.com/rune-kit/rune',
+      '',
+    ].join('\n');
+    return [{ path: 'AGENTS.md', content: agentsMd }];
+  },
 };

package/compiler/adapters/copilot.js

@@ -0,0 +1,126 @@
+/**
+ * GitHub Copilot CLI Adapter
+ *
+ * Emits per-skill instruction files into .github/instructions/ — the documented
+ * convention for GitHub Copilot custom instructions (read by both the CLI and
+ * the GitHub Copilot IDE plugin family).
+ *
+ * Copilot instructions dir: .github/instructions/
+ * Copilot instruction file: .github/instructions/rune-{name}.instructions.md
+ * Copilot project context: AGENTS.md (Copilot Spaces / Coding Agent convention)
+ *
+ * Each .instructions.md uses YAML frontmatter with `applyTo` for path scoping.
+ * Default applyTo: "**" means "apply to all files."
+ *
+ * @see https://docs.github.com/en/copilot/how-tos/copilot-cli/customize-copilot/add-custom-instructions
+ * @see https://docs.github.com/en/copilot/concepts/response-customization
+ *
+ * MODEL TIER MAPPING (v2.18+):
+ * Copilot multi-model support exposes Anthropic/OpenAI/Google providers. Tier
+ * names are emitted as a hint comment in the body — Copilot does not parse a
+ * model field, so we don't fight the platform.
+ */
+
+import { BRANDING_FOOTER } from '../transforms/branding.js';
+
+const MODEL_MAP = {
+  opus: 'tier:heavy',
+  sonnet: 'tier:mid',
+  haiku: 'tier:light',
+};
+
+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 instructions',
+  Agent: 'execute the workflow',
+};
+
+export default {
+  name: 'copilot',
+  outputDir: '.github/instructions',
+  fileExtension: '.instructions.md',
+  skillPrefix: 'rune-',
+  skillSuffix: '',
+
+  // Copilot instructions are flat per-skill files, not directories.
+  useSkillDirectories: false,
+
+  transformReference(skillName, raw) {
+    const isBackticked = raw.startsWith('`') && raw.endsWith('`');
+    const ref = `the rune-${skillName} instructions`;
+    return isBackticked ? `\`${ref}\`` : ref;
+  },
+
+  transformToolName(toolName) {
+    return TOOL_MAP[toolName] || toolName;
+  },
+
+  generateHeader(skill) {
+    // Per docs.github.com Copilot CLI custom-instructions spec, the only
+    // documented frontmatter key for `.instructions.md` is `applyTo`. Other
+    // metadata (description, tier hint) belongs in the markdown body so it
+    // survives parsing across CLI/IDE/extensions consistently.
+    const desc = (skill.description || '').replace(/\n/g, ' ');
+    const tierHint = skill.model ? MODEL_MAP[skill.model] || skill.model : null;
+    const lines = ['---', 'applyTo: "**"', '---', '', `# rune-${skill.name}`, '', `> ${desc}`];
+    if (tierHint) lines.push('', `<!-- tier-hint: ${tierHint} -->`);
+    lines.push('', '');
+    return lines.join('\n');
+  },
+
+  generateFooter() {
+    return BRANDING_FOOTER;
+  },
+
+  transformSubagentInstruction(text) {
+    return text;
+  },
+
+  scriptsDir(skillName) {
+    return `rune-${skillName}-scripts`;
+  },
+
+  postProcess(content) {
+    return content.replace(/^context: fork\n/gm, '').replace(/^agent: general-purpose\n/gm, '');
+  },
+
+  // Emit a top-level .github/copilot-instructions.md as the entry point + an
+  // AGENTS.md so Copilot Spaces / Coding Agent can find the project context.
+  generateExtraFiles({ stats }) {
+    const copilotIndex = [
+      '# Rune — Copilot Custom Instructions',
+      '',
+      `Per-skill instructions live under \`.github/instructions/rune-<name>.instructions.md\` (${stats.skillCount} skills + ${stats.packCount} packs). Copilot loads them based on each file's \`applyTo\` glob.`,
+      '',
+      'When a user request matches a skill\'s domain (e.g. "fix the failing test", "review this PR"), prefer following the corresponding rune-<name>.instructions.md over freestyling.',
+      '',
+      '---',
+      '> Rune Skill Mesh — https://github.com/rune-kit/rune',
+      '',
+    ].join('\n');
+
+    const agentsMd = [
+      '# Rune — Project Configuration',
+      '',
+      'Rune is an interconnected skill ecosystem for AI coding assistants.',
+      `${stats.skillCount} core skills + ${stats.packCount} extension packs.`,
+      '',
+      'Per-skill custom instructions: `.github/instructions/rune-<name>.instructions.md`',
+      '',
+      '---',
+      '> Rune Skill Mesh — https://github.com/rune-kit/rune',
+      '',
+    ].join('\n');
+
+    return [
+      { path: '.github/copilot-instructions.md', content: copilotIndex },
+      { path: 'AGENTS.md', content: agentsMd },
+    ];
+  },
+};

package/compiler/adapters/gemini.js

@@ -0,0 +1,131 @@
+/**
+ * Gemini CLI Adapter
+ *
+ * Gemini CLI loads a single GEMINI.md at project root for context. It does NOT
+ * support per-skill imports as of writing — so the canonical output is a
+ * bundled GEMINI.md with every skill concatenated under `## rune-<name>` H2
+ * sections. Per-skill files are still emitted under gemini/skills/ for human
+ * inspection and forward-compatibility if Gemini adds @import support later.
+ *
+ * Gemini context file: GEMINI.md (project root)
+ * Gemini per-skill files: gemini/skills/rune-{name}.md (forward-compat staging)
+ *
+ * @see https://github.com/google-gemini/gemini-cli
+ * @see https://geminicli.com/docs/reference/configuration/
+ *
+ * MODEL TIER MAPPING (v2.18+):
+ * Gemini CLI exposes 1.5 Pro / 1.5 Flash / 2.0 Flash etc. Anthropic tier names
+ * translate to Gemini families: opus→1.5-pro, sonnet→1.5-flash, haiku→
+ * 2.0-flash-lite. Hint only — Gemini CLI reads model from --model flag /
+ * config, not from rule body.
+ */
+
+import { readFile } from 'node:fs/promises';
+import nodePath from 'node:path';
+import { BRANDING_FOOTER } from '../transforms/branding.js';
+
+const MODEL_MAP = {
+  opus: 'gemini-2.5-pro',
+  sonnet: 'gemini-2.5-flash',
+  haiku: 'gemini-2.0-flash-lite',
+};
+
+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 rune-{name} section in GEMINI.md',
+  Agent: 'execute the workflow',
+};
+
+export default {
+  name: 'gemini',
+  outputDir: 'gemini/skills',
+  fileExtension: '.md',
+  skillPrefix: 'rune-',
+  skillSuffix: '',
+
+  // Per-skill files staged for forward compat; canonical entry is bundled GEMINI.md.
+  useSkillDirectories: false,
+
+  transformReference(skillName, raw) {
+    const isBackticked = raw.startsWith('`') && raw.endsWith('`');
+    const ref = `the rune-${skillName} section in GEMINI.md`;
+    return isBackticked ? `\`${ref}\`` : ref;
+  },
+
+  transformToolName(toolName) {
+    return TOOL_MAP[toolName] || toolName;
+  },
+
+  generateHeader(skill) {
+    const desc = (skill.description || '').replace(/"/g, '\\"');
+    const lines = ['---', `name: rune-${skill.name}`, `description: "${desc}"`];
+    const translatedModel = skill.model ? MODEL_MAP[skill.model] || skill.model : null;
+    if (translatedModel) lines.push(`# model-hint: ${translatedModel}`);
+    lines.push('---', '', '');
+    return lines.join('\n');
+  },
+
+  generateFooter() {
+    return BRANDING_FOOTER;
+  },
+
+  transformSubagentInstruction(text) {
+    return text;
+  },
+
+  scriptsDir(skillName) {
+    return `rune-${skillName}-scripts`;
+  },
+
+  postProcess(content) {
+    return content.replace(/^context: fork\n/gm, '').replace(/^agent: general-purpose\n/gm, '');
+  },
+
+  // Bundle every per-skill file into a single GEMINI.md with H2 section per skill.
+  // Gemini CLI loads GEMINI.md from project root as its context file. Hook contract
+  // requires relative paths (resolved against outputRoot by the emitter).
+  async generateExtraFiles({ stats, outputDir }) {
+    const skillFiles = [...stats.files]
+      .filter((f) => f.startsWith('rune-') && f.endsWith('.md') && !f.includes('/') && !f.includes('\\'))
+      .sort();
+
+    const sections = [];
+    for (const fname of skillFiles) {
+      const sourcePath = nodePath.join(outputDir, fname);
+      try {
+        const raw = await readFile(sourcePath, 'utf-8');
+        // Strip frontmatter — Gemini reads plain markdown.
+        const stripped = raw.replace(/^---\n[\s\S]*?\n---\n?/, '').trim();
+        const skillName = fname.replace(/^rune-/, '').replace(/\.md$/, '');
+        sections.push(`\n\n## rune-${skillName}\n\n${stripped}`);
+      } catch {
+        // Skip unreadable per-skill file — sections array still produces valid bundle.
+      }
+    }
+
+    const geminiMd = [
+      '# Rune — Project Configuration',
+      '',
+      'Rune is an interconnected skill ecosystem for AI coding assistants.',
+      `${stats.skillCount} core skills + ${stats.packCount} extension packs, bundled below.`,
+      '',
+      'When a user request matches a skill\'s domain (e.g. "implement", "review", "debug"), follow the matching `## rune-<name>` section.',
+      '',
+      '> Per-skill files are staged in `gemini/skills/` for forward-compat if Gemini CLI adds @import support.',
+      '',
+      ...sections,
+      '',
+      '---',
+      '> Rune Skill Mesh — https://github.com/rune-kit/rune',
+      '',
+    ].join('\n');
+
+    return [{ path: 'GEMINI.md', content: geminiMd }];
+  },
+};

package/compiler/adapters/index.js

@@ -4,13 +4,18 @@
  * Central registry for all platform adapters.
  */
 
+import aider from './aider.js';
 import antigravity from './antigravity.js';
 import claude from './claude.js';
 import codex from './codex.js';
+import copilot from './copilot.js';
 import cursor from './cursor.js';
+import gemini from './gemini.js';
 import generic from './generic.js';
 import openclaw from './openclaw.js';
 import opencode from './opencode.js';
+import qoder from './qoder.js';
+import qwen from './qwen.js';
 import windsurf from './windsurf.js';
 
 const adapters = {
@@ -22,6 +27,11 @@ const adapters = {
   openclaw,
   codex,
   opencode,
+  aider,
+  copilot,
+  gemini,
+  qoder,
+  qwen,
 };
 
 /**

package/compiler/adapters/openclaw.js

@@ -105,7 +105,7 @@ export default {
       id: 'rune',
       name: 'Rune',
       kind: 'skills',
-      description: `${skills.length}-skill mesh for AI coding assistants. Routes all code tasks through specialized skills. 215+ connections, 14 extension packs.`,
+      description: `${skills.length}-skill mesh for AI coding assistants. Routes all code tasks through specialized skills. 203 sync connections + 40 async signals, 14 extension packs.`,
       version: pluginJson.version || '0.0.0',
       skills: ['./skills'],
       artifactConvention: {