@rune-kit/rune 2.4.0 → 2.7.0

package/compiler/emitter.js

@@ -2,13 +2,13 @@
  * Emitter
  *
  * Writes transformed skill files to the platform's output directory.
- * Handles file naming, directory creation, and index generation.
+ * Handles file naming, directory creation, index generation, and AGENTS.md creation.
  */
 
 import { existsSync } from 'node:fs';
 import { cp, mkdir, readdir, readFile, writeFile } from 'node:fs/promises';
 import path from 'node:path';
-import { extractCrossRefs, extractToolRefs, parsePack, parseSkill } from './parser.js';
+import { extractCrossRefs, extractToolRefs, parseOrgConfig, parsePack, parseSkill, parseTemplate } from './parser.js';
 import { transformSkill } from './transformer.js';
 import { resolveScriptsPath } from './transforms/scripts-path.js';
 
@@ -60,6 +60,33 @@ async function discoverPacks(extensionsDir, enabledPacks = null) {
   return paths.sort();
 }
 
+/**
+ * Copy extra directories from skill source to output
+ * Copies directories except SKILL.md (already processed) and denylisted dirs
+ *
+ * @param {string} sourceSkillDir - e.g. skills/cook/
+ * @param {string} outputSkillDir - e.g. .codex/skills/rune-cook/
+ * @returns {Promise<string[]>} list of copied directory names
+ */
+const COPY_DENYLIST = new Set(['.git', 'node_modules', '__pycache__', '.DS_Store', '.venv', '.env']);
+
+async function copySkillExtraDirs(sourceSkillDir, outputSkillDir) {
+  if (!existsSync(sourceSkillDir)) return [];
+
+  const entries = await readdir(sourceSkillDir, { withFileTypes: true });
+  const dirs = entries.filter((e) => e.isDirectory() && !COPY_DENYLIST.has(e.name));
+
+  const copied = [];
+  for (const dir of dirs) {
+    const sourcePath = path.join(sourceSkillDir, dir.name);
+    const outputPath = path.join(outputSkillDir, dir.name);
+    await cp(sourcePath, outputPath, { recursive: true });
+    copied.push(dir.name);
+  }
+
+  return copied;
+}
+
 /**
  * Copy scripts directory from skill source to output.
  *
@@ -151,6 +178,217 @@ export async function discoverTieredPacks(freeExtDir, tierSources = {}, enabledP
   return [...packMap.values()].sort((a, b) => a.dirName.localeCompare(b.dirName));
 }
 
+/**
+ * Discover workflow templates in a pack's templates/ directory
+ *
+ * @param {string} packDir - path to the pack directory (e.g. extensions/pro-product/)
+ * @returns {Promise<Array<{name: string, file: string, parsed: object}>>} array of parsed templates
+ */
+async function discoverTemplates(packDir) {
+  const templatesDir = path.join(packDir, 'templates');
+  if (!existsSync(templatesDir)) return [];
+
+  const entries = await readdir(templatesDir, { withFileTypes: true });
+  const templates = [];
+
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith('.md')) continue;
+    const filePath = path.join(templatesDir, entry.name);
+    const content = await readFile(filePath, 'utf-8');
+    const parsed = parseTemplate(content, filePath);
+    templates.push({
+      name: parsed.name || entry.name.replace(/\.md$/, ''),
+      file: `templates/${entry.name}`,
+      parsed,
+    });
+  }
+
+  return templates.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+/**
+ * Load reference injection rules from all tier extension directories.
+ * Each pack can have an inject.json file defining which references to inject
+ * into Free core skills when that pack is installed.
+ *
+ * @param {string} freeExtDir - path to free extensions/ directory
+ * @param {Object<string, string>} tierSources - { pro: "/path", business: "/path" }
+ * @returns {Promise<Map<string, Array<{ref: string, context: string, packDir: string}>>>}
+ *   Map of skillName → array of injections
+ */
+async function loadInjectionRules(freeExtDir, tierSources) {
+  const injections = new Map(); // skillName → [{ref, context, packDir}]
+
+  const extDirs = [freeExtDir, tierSources.pro, tierSources.business].filter(Boolean);
+
+  for (const extDir of extDirs) {
+    if (!existsSync(extDir)) continue;
+    const entries = await readdir(extDir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const injectFile = path.join(extDir, entry.name, 'inject.json');
+      if (!existsSync(injectFile)) continue;
+
+      try {
+        const raw = await readFile(injectFile, 'utf-8');
+        const config = JSON.parse(raw);
+        const packDir = path.join(extDir, entry.name);
+
+        for (const rule of config.injections || []) {
+          if (!rule.skill || !rule.ref) continue;
+          if (!injections.has(rule.skill)) {
+            injections.set(rule.skill, []);
+          }
+          injections.get(rule.skill).push({
+            ref: rule.ref,
+            context: rule.context || '',
+            packDir,
+            pack: entry.name,
+          });
+        }
+      } catch {
+        // Invalid JSON — skip gracefully
+      }
+    }
+  }
+
+  return injections;
+}
+
+/**
+ * Apply reference injections to a skill's body.
+ * Reads the referenced files and appends them as context blocks.
+ *
+ * @param {string} body - original skill body
+ * @param {Array<{ref: string, context: string, packDir: string}>} rules - injection rules
+ * @returns {Promise<{body: string, count: number}>} injected body + count of injections applied
+ */
+async function applyInjections(body, rules) {
+  const blocks = [];
+
+  for (const rule of rules) {
+    const refPath = path.join(rule.packDir, rule.ref);
+    if (!existsSync(refPath)) continue;
+
+    try {
+      const content = await readFile(refPath, 'utf-8');
+      // Strip frontmatter if present
+      const cleaned = content
+        .replace(/\r\n/g, '\n')
+        .replace(/^---\n[\s\S]*?\n---\n?/, '')
+        .trim();
+      blocks.push(
+        `\n\n<!-- Pro Reference: ${rule.pack}/${rule.ref} -->\n` +
+          `<CONTEXT-INJECTION source="${rule.pack}" context="${rule.context}">\n` +
+          `${cleaned}\n` +
+          `</CONTEXT-INJECTION>`,
+      );
+    } catch {
+      // Unreadable reference — skip
+    }
+  }
+
+  return { body: body + blocks.join(''), count: blocks.length };
+}
+
+/**
+ * Load org config from .rune/org/org.md if it exists.
+ * Returns parsed org config or null if not present.
+ */
+async function loadOrgConfig(runeRoot, tierSources) {
+  // Org templates are a Business feature — only load if business tier is available
+  if (!tierSources || !tierSources.business) return null;
+
+  const orgPath = path.join(runeRoot, '.rune', 'org', 'org.md');
+  if (!existsSync(orgPath)) return null;
+
+  try {
+    const content = await readFile(orgPath, 'utf-8');
+    return parseOrgConfig(content, orgPath);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Generate <ORG-POLICY> block from org config for injection into sentinel/preflight.
+ */
+function buildOrgPolicyBlock(orgConfig, targetSkill) {
+  if (!orgConfig) return null;
+
+  const lines = [];
+  lines.push(`\n\n<!-- Business: Organization Policy (${orgConfig.name}) -->`);
+  lines.push(`<ORG-POLICY template="${orgConfig.name}" governance="${orgConfig.governanceLevel.level}">`);
+
+  if (targetSkill === 'sentinel') {
+    // Inject security + code review + deployment policies
+    const security = orgConfig.policies.security || [];
+    const codeReview = orgConfig.policies.code_review || [];
+    const deployment = orgConfig.policies.deployment || [];
+
+    if (security.length > 0) {
+      lines.push('\n### Security Policies');
+      for (const rule of security) {
+        lines.push(`- **${rule.key}**: ${rule.value}`);
+      }
+    }
+    if (codeReview.length > 0) {
+      lines.push('\n### Code Review Policies');
+      for (const rule of codeReview) {
+        lines.push(`- **${rule.key}**: ${rule.value}`);
+      }
+    }
+    if (deployment.length > 0) {
+      lines.push('\n### Deployment Policies');
+      for (const rule of deployment) {
+        lines.push(`- **${rule.key}**: ${rule.value}`);
+      }
+    }
+  } else if (targetSkill === 'preflight') {
+    // Inject code review + deployment + approval flows
+    const codeReview = orgConfig.policies.code_review || [];
+    const deployment = orgConfig.policies.deployment || [];
+
+    if (codeReview.length > 0) {
+      lines.push('\n### Code Review Requirements');
+      for (const rule of codeReview) {
+        lines.push(`- **${rule.key}**: ${rule.value}`);
+      }
+    }
+    if (deployment.length > 0) {
+      lines.push('\n### Deployment Requirements');
+      for (const rule of deployment) {
+        lines.push(`- **${rule.key}**: ${rule.value}`);
+      }
+    }
+
+    // Include approval flows
+    const flows = orgConfig.approvalFlows;
+    if (Object.keys(flows).length > 0) {
+      lines.push('\n### Approval Flows');
+      for (const [name, flow] of Object.entries(flows)) {
+        lines.push(`\n**${name}**:`);
+        lines.push('```');
+        lines.push(flow);
+        lines.push('```');
+      }
+    }
+  }
+
+  // Governance settings
+  const gov = orgConfig.governanceLevel;
+  if (gov.settings.length > 0) {
+    lines.push('\n### Governance Settings');
+    for (const setting of gov.settings) {
+      lines.push(`- ${setting}`);
+    }
+  }
+
+  lines.push('</ORG-POLICY>');
+  return lines.join('\n');
+}
+
 /**
  * Generate output filename for a skill
  */
@@ -215,13 +453,23 @@ export async function buildAll({
     crossRefsResolved: 0,
     toolRefsResolved: 0,
     scriptsCopied: 0,
+    templateCount: 0,
+    injectionsApplied: 0,
     files: [],
     skipped: [],
     errors: [],
     tierOverrides: [],
   };
 
-  // Build skills
+  // Load reference injection rules from Pro/Business packs
+  const injectionRules = hasTiers ? await loadInjectionRules(extensionsDir, tierSources) : new Map();
+
+  // Load org config from .rune/org/org.md (Business feature)
+  const orgConfig = await loadOrgConfig(runeRoot, tierSources);
+
+  // Build skills — collect parsed data for skill-index + openclaw reuse
+  const parsedSkills = [];
+
   for (const skillPath of skillPaths) {
     try {
       const content = await readFile(skillPath, 'utf-8');
@@ -252,15 +500,33 @@ export async function buildAll({
         });
       }
 
-      const output = [header, body, footer].filter(Boolean).join('\n');
+      // Apply reference injections from Pro/Business packs
+      let finalBody = body;
+      if (injectionRules.has(parsed.name)) {
+        const { body: injectedBody, count } = await applyInjections(body, injectionRules.get(parsed.name));
+        finalBody = injectedBody;
+        stats.injectionsApplied += count;
+      }
+
+      // Inject org policies into sentinel/preflight (Business feature)
+      if (orgConfig && (parsed.name === 'sentinel' || parsed.name === 'preflight')) {
+        const orgBlock = buildOrgPolicyBlock(orgConfig, parsed.name);
+        if (orgBlock) {
+          finalBody += orgBlock;
+          stats.orgPoliciesInjected = (stats.orgPoliciesInjected || 0) + 1;
+        }
+      }
+
+      const output = [header, finalBody, footer].filter(Boolean).join('\n');
 
       let outputPath;
       let displayName;
+      let skillDir = null;
 
       if (adapter.useSkillDirectories) {
         // Directory-per-skill: .codex/skills/rune-{name}/SKILL.md
         const dirName = `${adapter.skillPrefix}${parsed.name}`;
-        const skillDir = path.join(outputDir, dirName);
+        skillDir = path.join(outputDir, dirName);
         await mkdir(skillDir, { recursive: true });
         outputPath = path.join(skillDir, adapter.skillFileName || 'SKILL.md');
         displayName = `${dirName}/${adapter.skillFileName || 'SKILL.md'}`;
@@ -272,6 +538,11 @@ export async function buildAll({
 
       await writeFile(outputPath, output, 'utf-8');
 
+      // Copy extra directories (references/, etc.) from skill source
+      if (adapter.useSkillDirectories && skillDir) {
+        await copySkillExtraDirs(skillSourceDir, skillDir);
+      }
+
       // Copy scripts/ directory if present
       if (hasScripts) {
         const scriptsOutput = path.join(outputDir, adapter.scriptsDir(parsed.name));
@@ -279,6 +550,7 @@ export async function buildAll({
         stats.scriptsCopied += copied.length;
       }
 
+      parsedSkills.push(parsed);
       stats.skillCount++;
       stats.crossRefsResolved += parsed.crossRefs.length;
       stats.toolRefsResolved += parsed.toolRefs.length;
@@ -327,6 +599,17 @@ export async function buildAll({
         }
       }
 
+      // For split packs: auto-discover skill files from skills/ subdir when manifest is empty
+      if (parsed.isSplit && parsed.skillManifest.length === 0) {
+        const skillsSubdir = path.join(packDir, 'skills');
+        if (existsSync(skillsSubdir)) {
+          const skillFiles = (await readdir(skillsSubdir)).filter((f) => f.endsWith('.md')).sort();
+          for (const sf of skillFiles) {
+            parsed.skillManifest.push({ name: sf.replace(/\.md$/, ''), file: `skills/${sf}` });
+          }
+        }
+      }
+
       // For split packs, load individual skill files and concatenate into body
       if (parsed.isSplit && parsed.skillManifest.length > 0) {
         const skillBodies = [];
@@ -351,6 +634,31 @@ export async function buildAll({
         parsed.toolRefs = extractToolRefs(parsed.body);
       }
 
+      // Discover and append workflow templates (Pro/Business packs)
+      const templates = await discoverTemplates(packDir);
+      if (templates.length > 0) {
+        const templateSection = [
+          '',
+          '## Workflow Templates',
+          '',
+          'Pre-built multi-phase workflows for `cook --template <name>`:',
+          '',
+          ...templates.map(
+            (t) => `| \`${t.name}\` | ${t.parsed.description.slice(0, 100)} | chain: ${t.parsed.chain} |`,
+          ),
+          '',
+          ...templates.map((t) => {
+            const header = `### Template: ${t.name}`;
+            return `${header}\n\n${t.parsed.body}`;
+          }),
+        ];
+        parsed.body = `${parsed.body}\n\n${templateSection.join('\n')}`;
+        // Re-extract refs after template injection
+        parsed.crossRefs = extractCrossRefs(parsed.body);
+        parsed.toolRefs = extractToolRefs(parsed.body);
+        stats.templateCount = (stats.templateCount || 0) + templates.length;
+      }
+
       // Normalize pack name for headers (ext-trading instead of @rune/trading)
       parsed.name = `ext-${packName}`;
 
@@ -387,6 +695,18 @@ export async function buildAll({
   await writeFile(path.join(outputDir, indexFileName), indexContent, 'utf-8');
   stats.files.push(indexFileName);
 
+  // Generate skill-index.json — compiled intent mesh for auto-trigger hooks
+  const skillIndex = generateSkillIndex(parsedSkills);
+  await writeFile(path.join(outputDir, 'skill-index.json'), `${JSON.stringify(skillIndex, null, 2)}\n`, 'utf-8');
+  stats.files.push('skill-index.json');
+
+  // Generate AGENTS.md for Codex (OpenAI convention — not used by other platforms)
+  if (adapter.name === 'codex') {
+    const agentsMdContent = generateAgentsMd(stats, adapter);
+    await writeFile(path.join(outputRoot, 'AGENTS.md'), agentsMdContent, 'utf-8');
+    stats.files.push('AGENTS.md');
+  }
+
   // OpenClaw adapter: generate manifest + TypeScript entry point
   if (adapter.name === 'openclaw' && adapter.generateManifest && adapter.generateEntryPoint) {
     const pluginJsonPath = path.join(runeRoot, '.claude-plugin', 'plugin.json');
@@ -395,17 +715,6 @@ export async function buildAll({
       pluginJson = JSON.parse(await readFile(pluginJsonPath, 'utf-8'));
     }
 
-    // Collect parsed skills for manifest/entry generation
-    const parsedSkills = [];
-    for (const sp of skillPaths) {
-      try {
-        const c = await readFile(sp, 'utf-8');
-        parsedSkills.push(parseSkill(c, sp));
-      } catch {
-        /* skip on error */
-      }
-    }
-
     // Read skill-router content for system prompt injection
     const routerPath = path.join(runeRoot, 'skills', 'skill-router', 'SKILL.md');
     let routerContent = '';
@@ -447,7 +756,7 @@ function generateIndex(stats, adapter) {
   const lines = [
     '# Rune Skill Index',
     '',
-    `> Platform: ${adapter.name} | Skills: ${stats.skillCount} | Extensions: ${stats.packCount}`,
+    `> Platform: ${adapter.name} | Skills: ${stats.skillCount} | Extensions: ${stats.packCount}${stats.templateCount > 0 ? ` | Templates: ${stats.templateCount}` : ''}${stats.injectionsApplied > 0 ? ` | Injections: ${stats.injectionsApplied}` : ''}`,
     '',
     '## Core Skills',
     '',
@@ -464,3 +773,167 @@ function generateIndex(stats, adapter) {
 
   return lines.join('\n');
 }
+
+/**
+ * Generate AGENTS.md for Codex (OpenAI convention)
+ * Uses dynamic counts from build stats — no hardcoded skill lists
+ */
+function generateAgentsMd(stats, adapter) {
+  const lines = [
+    '# 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: ${adapter.name}`,
+    '',
+    '## 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: ${adapter.outputDir}/`,
+    '',
+    '---',
+    '> Rune Skill Mesh — https://github.com/rune-kit/rune',
+    '',
+  ];
+
+  return lines.join('\n');
+}
+
+/**
+ * Intent keyword patterns for each skill — extracted from description + Triggers section
+ * Maps common user intent words to the skill that handles them
+ */
+const INTENT_KEYWORDS = {
+  cook: ['implement', 'build', 'create', 'add', 'feature', 'fix', 'code', 'write', 'make', 'develop'],
+  team: ['parallel', 'split', 'multiple', 'large', 'many files', 'multi-module'],
+  launch: ['deploy', 'launch', 'release', 'ship', 'publish', 'production'],
+  rescue: ['legacy', 'refactor', 'modernize', 'rescue', 'clean up', 'old code', 'messy'],
+  scaffold: ['new project', 'bootstrap', 'scaffold', 'init', 'greenfield', 'starter'],
+  plan: ['plan', 'architect', 'design system', 'roadmap', 'strategy'],
+  brainstorm: ['brainstorm', 'explore', 'ideas', 'alternatives', 'approaches'],
+  debug: ['debug', 'error', 'bug', 'broken', 'trace', 'diagnose', 'crash', 'fail'],
+  fix: ['fix', 'patch', 'hotfix', 'resolve', 'repair'],
+  test: ['test', 'tdd', 'coverage', 'unit test', 'e2e', 'spec'],
+  review: ['review', 'code review', 'check quality', 'audit code'],
+  sentinel: ['security', 'vulnerability', 'owasp', 'secret', 'audit security'],
+  preflight: ['pre-commit', 'quality gate', 'check before'],
+  deploy: ['deploy', 'ci/cd', 'pipeline', 'kubernetes', 'docker'],
+  design: ['ui', 'ux', 'design', 'layout', 'component design', 'wireframe'],
+  perf: ['performance', 'slow', 'optimize', 'n+1', 'memory leak', 'bundle size'],
+  db: ['database', 'migration', 'schema', 'sql', 'query', 'index'],
+  audit: ['audit', 'health check', 'project assessment', 'codebase review'],
+  onboard: ['onboard', 'setup', 'configure project', 'get started'],
+  docs: ['document', 'readme', 'api docs', 'changelog'],
+  ba: ['requirements', 'business analysis', 'user stories', 'stakeholder'],
+  adversary: ['red team', 'challenge', 'stress test', 'edge case'],
+  incident: ['incident', 'outage', 'downtime', 'postmortem'],
+  surgeon: ['refactor', 'extract', 'strangler', 'decompose'],
+  'mcp-builder': ['mcp', 'mcp server', 'tool server', 'model context'],
+  'skill-forge': ['new skill', 'create skill', 'edit skill'],
+  'review-intake': ['pr feedback', 'review comments', 'received review'],
+  'logic-guardian': ['business logic', 'protect logic', 'critical path'],
+  marketing: ['marketing', 'landing page', 'seo', 'social media', 'copy'],
+  retro: ['retrospective', 'sprint review', 'velocity', 'team health'],
+};
+
+/**
+ * Generate skill-index.json — compiled intent mesh for runtime auto-trigger
+ *
+ * Extracts from parsed skills: name, description, layer, model, group,
+ * cross-references (connections), and maps intent keywords to skill chains.
+ *
+ * @param {Array} parsedSkills - array of parsed skill objects
+ * @returns {object} skill index with graph + intents
+ */
+function generateSkillIndex(parsedSkills) {
+  // Build adjacency graph from cross-references
+  const graph = {};
+  const skills = {};
+
+  for (const skill of parsedSkills) {
+    const outbound = [...new Set(skill.crossRefs.map((r) => r.skillName))];
+    graph[skill.name] = outbound;
+    skills[skill.name] = {
+      layer: skill.layer,
+      model: skill.model,
+      group: skill.group,
+      description: skill.description.slice(0, 200),
+      connections: outbound,
+      ...(skill.signals ? { signals: skill.signals } : {}),
+    };
+  }
+
+  // Build signal graph — maps each signal to its emitters and listeners
+  const signalGraph = buildSignalGraph(parsedSkills);
+
+  // Build intent patterns from INTENT_KEYWORDS + skill descriptions
+  const intents = {};
+  for (const [skillName, keywords] of Object.entries(INTENT_KEYWORDS)) {
+    if (!skills[skillName]) continue;
+    const skill = skills[skillName];
+
+    // Build chain: primary skill + its direct connections (1-hop)
+    const chain = [skillName, ...graph[skillName].filter((c) => skills[c]).slice(0, 5)];
+
+    intents[skillName] = {
+      keywords,
+      layer: skill.layer,
+      model: skill.model,
+      chain,
+    };
+  }
+
+  return {
+    version: 2,
+    generated: new Date().toISOString(),
+    skillCount: parsedSkills.length,
+    skills,
+    graph,
+    signals: signalGraph,
+    intents,
+  };
+}
+
+/**
+ * Build signal graph from parsed skills' emit/listen declarations.
+ * Maps each signal name to its emitters and listeners.
+ *
+ * @param {Array} parsedSkills
+ * @returns {object} { "code.changed": { emitters: ["fix"], listeners: ["test", "review"] } }
+ */
+function buildSignalGraph(parsedSkills) {
+  const signals = {};
+
+  for (const skill of parsedSkills) {
+    if (!skill.signals) continue;
+
+    for (const signal of skill.signals.emit) {
+      if (!signals[signal]) signals[signal] = { emitters: [], listeners: [] };
+      signals[signal].emitters.push(skill.name);
+    }
+
+    for (const signal of skill.signals.listen) {
+      if (!signals[signal]) signals[signal] = { emitters: [], listeners: [] };
+      signals[signal].listeners.push(skill.name);
+    }
+  }
+
+  // Sort for deterministic output
+  for (const entry of Object.values(signals)) {
+    entry.emitters.sort();
+    entry.listeners.sort();
+  }
+
+  return signals;
+}