@rune-kit/rune 2.4.0 → 2.6.0

package/compiler/parser.js

@@ -1,247 +1,267 @@
-/**
- * SKILL.md Parser
- *
- * Parses SKILL.md files into a structured intermediate representation (IR).
- * Extracts frontmatter, cross-references, tool references, HARD-GATE blocks, and sections.
- */
-
-const CROSS_REF_PATTERN = /`?rune:([a-z][\w-]*)`?/g;
-const TOOL_REF_PATTERN = /`(Read|Write|Edit|Glob|Grep|Bash|TodoWrite|Skill|Agent)`/g;
-const HARD_GATE_PATTERN = /<HARD-GATE>([\s\S]*?)<\/HARD-GATE>/g;
-const _SECTION_PATTERN = /^## (.+)$/gm;
-
-/**
- * Parse YAML-like frontmatter from SKILL.md
- * Handles nested metadata block
- */
-function parseFrontmatter(content) {
-  // Normalize line endings to \n for cross-platform compatibility
-  const normalized = content.replace(/\r\n/g, '\n');
-  const match = normalized.match(/^---\n([\s\S]*?)\n---/);
-  if (!match) return { frontmatter: {}, body: normalized };
-
-  const raw = match[1];
-  const body = normalized.slice(match[0].length).trim();
-  const frontmatter = {};
-
-  let currentIndent = null;
-  let nestedKey = null;
-  const _nestedObj = {};
-
-  for (const line of raw.split('\n')) {
-    const trimmed = line.trim();
-    if (!trimmed) continue;
-
-    // Detect nested block (e.g., metadata:)
-    if (/^\w+:\s*$/.test(trimmed)) {
-      nestedKey = trimmed.replace(':', '').trim();
-      frontmatter[nestedKey] = {};
-      currentIndent = 'nested';
-      continue;
-    }
-
-    if (currentIndent === 'nested' && line.startsWith('  ')) {
-      const kvMatch = trimmed.match(/^(\w+):\s*(.+)$/);
-      if (kvMatch) {
-        const value = kvMatch[2].replace(/^["']|["']$/g, '');
-        frontmatter[nestedKey][kvMatch[1]] = value;
-      }
-      continue;
-    }
-
-    // Top-level key-value
-    currentIndent = null;
-    nestedKey = null;
-    const kvMatch = trimmed.match(/^(\w[\w-]*):\s*(.+)$/);
-    if (kvMatch) {
-      const value = kvMatch[2].replace(/^["']|["']$/g, '');
-      frontmatter[kvMatch[1]] = value;
-    }
-  }
-
-  return { frontmatter, body };
-}
-
-/**
- * Extract all rune:<name> cross-references from body
- */
-export function extractCrossRefs(body) {
-  const refs = [];
-  const lines = body.split('\n');
-
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    let match;
-    const regex = new RegExp(CROSS_REF_PATTERN.source, 'g');
-
-    while ((match = regex.exec(line)) !== null) {
-      refs.push({
-        raw: match[0],
-        skillName: match[1],
-        line: i + 1,
-        context: line.trim(),
-      });
-    }
-  }
-
-  return refs;
-}
-
-/**
- * Extract all Claude Code tool references from body
- */
-export function extractToolRefs(body) {
-  const refs = [];
-  const lines = body.split('\n');
-
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    let match;
-    const regex = new RegExp(TOOL_REF_PATTERN.source, 'g');
-
-    while ((match = regex.exec(line)) !== null) {
-      refs.push({
-        raw: match[0],
-        toolName: match[1],
-        line: i + 1,
-        context: line.trim(),
-      });
-    }
-  }
-
-  return refs;
-}
-
-/**
- * Extract HARD-GATE blocks
- */
-function extractHardGates(body) {
-  const gates = [];
-  let match;
-  const regex = new RegExp(HARD_GATE_PATTERN.source, 'gs');
-
-  while ((match = regex.exec(body)) !== null) {
-    gates.push(match[1].trim());
-  }
-
-  return gates;
-}
-
-/**
- * Extract ## sections as a Map<sectionName, content>
- */
-function extractSections(body) {
-  const sections = new Map();
-  const lines = body.split('\n');
-  let currentSection = null;
-  let currentContent = [];
-
-  for (const line of lines) {
-    const sectionMatch = line.match(/^## (.+)$/);
-    if (sectionMatch) {
-      if (currentSection) {
-        sections.set(currentSection, currentContent.join('\n').trim());
-      }
-      currentSection = sectionMatch[1];
-      currentContent = [];
-    } else if (currentSection) {
-      currentContent.push(line);
-    }
-  }
-
-  if (currentSection) {
-    sections.set(currentSection, currentContent.join('\n').trim());
-  }
-
-  return sections;
-}
-
-/**
- * Parse a SKILL.md file content into structured IR
- *
- * @param {string} content - raw SKILL.md content
- * @param {string} [filePath] - optional file path for error reporting
- * @returns {ParsedSkill}
- */
-export function parseSkill(content, filePath = '') {
-  const { frontmatter, body } = parseFrontmatter(content);
-
-  const metadata = frontmatter.metadata || {};
-
-  return {
-    name: frontmatter.name || '',
-    description: frontmatter.description || '',
-    layer: metadata.layer || 'L2',
-    model: metadata.model || 'sonnet',
-    group: metadata.group || 'general',
-    contextFork: frontmatter.context === 'fork',
-    agentType: frontmatter.agent || null,
-    body,
-    crossRefs: extractCrossRefs(body),
-    toolRefs: extractToolRefs(body),
-    hardGates: extractHardGates(body),
-    sections: extractSections(body),
-    filePath,
-    frontmatter,
-  };
-}
-
-/**
- * Parse a PACK.md extension file (same format, slightly different metadata)
- * Supports both monolith format (all skills inline) and split format (skills in separate files)
- *
- * Split format detection: metadata.format === "split" OR metadata.skills array present
- */
-export function parsePack(content, filePath = '') {
-  const { frontmatter, body } = parseFrontmatter(content);
-  const metadata = frontmatter.metadata || {};
-
-  // Detect split format
-  const isSplit = metadata.format === 'split' || Array.isArray(metadata.skills);
-
-  return {
-    name: frontmatter.name || '',
-    description: frontmatter.description || '',
-    version: metadata.version || frontmatter.version || '1.0.0',
-    layer: 'L4',
-    group: 'extension',
-    isSplit,
-    skillManifest: isSplit ? parseSkillManifest(metadata.skills || []) : [],
-    body,
-    crossRefs: extractCrossRefs(body),
-    toolRefs: extractToolRefs(body),
-    hardGates: extractHardGates(body),
-    sections: extractSections(body),
-    filePath,
-    frontmatter,
-  };
-}
-
-/**
- * Parse the skills manifest from split PACK.md frontmatter
- *
- * @param {Array} skills - array of skill entries from frontmatter metadata.skills
- * @returns {Array<{name: string, file: string, model: string, description: string}>}
- */
-function parseSkillManifest(skills) {
-  if (!Array.isArray(skills)) return [];
-
-  return skills.map((skill) => {
-    // Handle both string format ("skill-name") and object format ({name, file, model, description})
-    if (typeof skill === 'string') {
-      return {
-        name: skill,
-        file: `skills/${skill}.md`,
-        model: 'sonnet',
-        description: '',
-      };
-    }
-
-    return {
-      name: skill.name || '',
-      file: skill.file || `skills/${skill.name}.md`,
-      model: skill.model || 'sonnet',
-      description: skill.description || '',
-    };
-  });
-}
+/**
+ * SKILL.md Parser
+ *
+ * Parses SKILL.md files into a structured intermediate representation (IR).
+ * Extracts frontmatter, cross-references, tool references, HARD-GATE blocks, and sections.
+ */
+
+/**
+ * Metadata fields that should be parsed as comma-separated arrays
+ * e.g. emit: code.changed, tests.passed → ["code.changed", "tests.passed"]
+ */
+const COMMA_LIST_FIELDS = new Set(['emit', 'listen']);
+
+const CROSS_REF_PATTERN = /`?rune:([a-z][\w-]*)`?/g;
+const TOOL_REF_PATTERN = /`(Read|Write|Edit|Glob|Grep|Bash|TodoWrite|Skill|Agent)`/g;
+const HARD_GATE_PATTERN = /<HARD-GATE>([\s\S]*?)<\/HARD-GATE>/g;
+const _SECTION_PATTERN = /^## (.+)$/gm;
+
+/**
+ * Parse YAML-like frontmatter from SKILL.md
+ * Handles nested metadata block
+ */
+function parseFrontmatter(content) {
+  // Normalize line endings to \n for cross-platform compatibility
+  const normalized = content.replace(/\r\n/g, '\n');
+  const match = normalized.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return { frontmatter: {}, body: normalized };
+
+  const raw = match[1];
+  const body = normalized.slice(match[0].length).trim();
+  const frontmatter = {};
+
+  let currentIndent = null;
+  let nestedKey = null;
+  const _nestedObj = {};
+
+  for (const line of raw.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+
+    // Detect nested block (e.g., metadata:)
+    if (/^\w+:\s*$/.test(trimmed)) {
+      nestedKey = trimmed.replace(':', '').trim();
+      frontmatter[nestedKey] = {};
+      currentIndent = 'nested';
+      continue;
+    }
+
+    if (currentIndent === 'nested' && line.startsWith('  ')) {
+      const kvMatch = trimmed.match(/^(\w[\w-]*):\s*(.+)$/);
+      if (kvMatch) {
+        const rawValue = kvMatch[2].replace(/^["']|["']$/g, '');
+        // Comma-separated list fields → parse as array
+        if (COMMA_LIST_FIELDS.has(kvMatch[1])) {
+          frontmatter[nestedKey][kvMatch[1]] = rawValue
+            .split(',')
+            .map((s) => s.trim())
+            .filter(Boolean);
+        } else {
+          frontmatter[nestedKey][kvMatch[1]] = rawValue;
+        }
+      }
+      continue;
+    }
+
+    // Top-level key-value
+    currentIndent = null;
+    nestedKey = null;
+    const kvMatch = trimmed.match(/^(\w[\w-]*):\s*(.+)$/);
+    if (kvMatch) {
+      const value = kvMatch[2].replace(/^["']|["']$/g, '');
+      frontmatter[kvMatch[1]] = value;
+    }
+  }
+
+  return { frontmatter, body };
+}
+
+/**
+ * Extract all rune:<name> cross-references from body
+ */
+export function extractCrossRefs(body) {
+  const refs = [];
+  const lines = body.split('\n');
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    let match;
+    const regex = new RegExp(CROSS_REF_PATTERN.source, 'g');
+
+    while ((match = regex.exec(line)) !== null) {
+      refs.push({
+        raw: match[0],
+        skillName: match[1],
+        line: i + 1,
+        context: line.trim(),
+      });
+    }
+  }
+
+  return refs;
+}
+
+/**
+ * Extract all Claude Code tool references from body
+ */
+export function extractToolRefs(body) {
+  const refs = [];
+  const lines = body.split('\n');
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    let match;
+    const regex = new RegExp(TOOL_REF_PATTERN.source, 'g');
+
+    while ((match = regex.exec(line)) !== null) {
+      refs.push({
+        raw: match[0],
+        toolName: match[1],
+        line: i + 1,
+        context: line.trim(),
+      });
+    }
+  }
+
+  return refs;
+}
+
+/**
+ * Extract HARD-GATE blocks
+ */
+function extractHardGates(body) {
+  const gates = [];
+  let match;
+  const regex = new RegExp(HARD_GATE_PATTERN.source, 'gs');
+
+  while ((match = regex.exec(body)) !== null) {
+    gates.push(match[1].trim());
+  }
+
+  return gates;
+}
+
+/**
+ * Extract ## sections as a Map<sectionName, content>
+ */
+function extractSections(body) {
+  const sections = new Map();
+  const lines = body.split('\n');
+  let currentSection = null;
+  let currentContent = [];
+
+  for (const line of lines) {
+    const sectionMatch = line.match(/^## (.+)$/);
+    if (sectionMatch) {
+      if (currentSection) {
+        sections.set(currentSection, currentContent.join('\n').trim());
+      }
+      currentSection = sectionMatch[1];
+      currentContent = [];
+    } else if (currentSection) {
+      currentContent.push(line);
+    }
+  }
+
+  if (currentSection) {
+    sections.set(currentSection, currentContent.join('\n').trim());
+  }
+
+  return sections;
+}
+
+/**
+ * Parse a SKILL.md file content into structured IR
+ *
+ * @param {string} content - raw SKILL.md content
+ * @param {string} [filePath] - optional file path for error reporting
+ * @returns {ParsedSkill}
+ */
+export function parseSkill(content, filePath = '') {
+  const { frontmatter, body } = parseFrontmatter(content);
+
+  const metadata = frontmatter.metadata || {};
+
+  // Extract signals — emit/listen arrays from metadata
+  const emit = Array.isArray(metadata.emit) ? metadata.emit : [];
+  const listen = Array.isArray(metadata.listen) ? metadata.listen : [];
+  const signals = emit.length > 0 || listen.length > 0 ? { emit, listen } : null;
+
+  return {
+    name: frontmatter.name || '',
+    description: frontmatter.description || '',
+    layer: metadata.layer || 'L2',
+    model: metadata.model || 'sonnet',
+    group: metadata.group || 'general',
+    signals,
+    contextFork: frontmatter.context === 'fork',
+    agentType: frontmatter.agent || null,
+    body,
+    crossRefs: extractCrossRefs(body),
+    toolRefs: extractToolRefs(body),
+    hardGates: extractHardGates(body),
+    sections: extractSections(body),
+    filePath,
+    frontmatter,
+  };
+}
+
+/**
+ * Parse a PACK.md extension file (same format, slightly different metadata)
+ * Supports both monolith format (all skills inline) and split format (skills in separate files)
+ *
+ * Split format detection: metadata.format === "split" OR metadata.skills array present
+ */
+export function parsePack(content, filePath = '') {
+  const { frontmatter, body } = parseFrontmatter(content);
+  const metadata = frontmatter.metadata || {};
+
+  // Detect split format
+  const isSplit = metadata.format === 'split' || Array.isArray(metadata.skills);
+
+  return {
+    name: frontmatter.name || '',
+    description: frontmatter.description || '',
+    version: metadata.version || frontmatter.version || '1.0.0',
+    layer: 'L4',
+    group: 'extension',
+    isSplit,
+    skillManifest: isSplit ? parseSkillManifest(metadata.skills || []) : [],
+    body,
+    crossRefs: extractCrossRefs(body),
+    toolRefs: extractToolRefs(body),
+    hardGates: extractHardGates(body),
+    sections: extractSections(body),
+    filePath,
+    frontmatter,
+  };
+}
+
+/**
+ * Parse the skills manifest from split PACK.md frontmatter
+ *
+ * @param {Array} skills - array of skill entries from frontmatter metadata.skills
+ * @returns {Array<{name: string, file: string, model: string, description: string}>}
+ */
+function parseSkillManifest(skills) {
+  if (!Array.isArray(skills)) return [];
+
+  return skills.map((skill) => {
+    // Handle both string format ("skill-name") and object format ({name, file, model, description})
+    if (typeof skill === 'string') {
+      return {
+        name: skill,
+        file: `skills/${skill}.md`,
+        model: 'sonnet',
+        description: '',
+      };
+    }
+
+    return {
+      name: skill.name || '',
+      file: skill.file || `skills/${skill.name}.md`,
+      model: skill.model || 'sonnet',
+      description: skill.description || '',
+    };
+  });
+}

package/hooks/hooks.json

@@ -12,6 +12,18 @@
         ]
       }
     ],
+    "UserPromptSubmit": [
+      {
+        "matcher": ".*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.cjs\" intent-router",
+            "async": true
+          }
+        ]
+      }
+    ],
     "PreToolUse": [
       {
         "matcher": "Read|Write|Edit",

package/hooks/intent-router/index.cjs

@@ -0,0 +1,108 @@
+// Rune Intent Router Hook — Compiled Intent Mesh (CIM)
+// Auto-suggests skill routing based on user prompt analysis
+// Runs as UserPromptSubmit hook — scores prompt against compiled skill-index.json
+//
+// Key difference from runtime scoring approaches:
+// - Compile-time generated index (zero runtime deps)
+// - Mesh-aware chain prediction (uses actual connection graph)
+// - Works on all platforms (index ships with every build)
+
+const fs = require('fs');
+const path = require('path');
+
+// Read user prompt from Claude Code hook stdin
+let input = '';
+process.stdin.setEncoding('utf-8');
+process.stdin.on('data', (chunk) => { input += chunk; });
+process.stdin.on('end', () => {
+  let userPrompt = '';
+  try {
+    const parsed = JSON.parse(input);
+    userPrompt = parsed.user_prompt || parsed.prompt || parsed.content || '';
+  } catch {
+    // Raw text input
+    userPrompt = input.trim();
+  }
+
+  if (!userPrompt || userPrompt.length < 3) {
+    process.exit(0);
+  }
+
+  // Find skill-index.json — check multiple locations
+  const pluginRoot = process.env.CLAUDE_PLUGIN_ROOT || path.resolve(__dirname, '../..');
+  const candidates = [
+    path.join(pluginRoot, '.cursor', 'rules', 'skill-index.json'),
+    path.join(pluginRoot, '.windsurf', 'rules', 'skill-index.json'),
+    path.join(pluginRoot, 'dist', 'cursor', 'skill-index.json'),
+    path.join(pluginRoot, 'dist', 'generic', 'skill-index.json'),
+    // Also check .rune/ for locally cached index
+    path.join(process.cwd(), '.rune', 'skill-index.json'),
+  ];
+
+  let index = null;
+  for (const candidate of candidates) {
+    try {
+      if (fs.existsSync(candidate)) {
+        index = JSON.parse(fs.readFileSync(candidate, 'utf-8'));
+        break;
+      }
+    } catch {
+      // Try next candidate
+    }
+  }
+
+  if (!index || !index.intents) {
+    // No index available — exit silently (not an error, just not built yet)
+    process.exit(0);
+  }
+
+  // Score prompt against intent patterns
+  const promptLower = userPrompt.toLowerCase();
+  const scores = [];
+
+  for (const [skillName, intent] of Object.entries(index.intents)) {
+    let score = 0;
+
+    for (const keyword of intent.keywords) {
+      if (promptLower.includes(keyword)) {
+        // Exact word boundary match scores higher
+        const wordBoundary = new RegExp(`\\b${keyword.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`, 'i');
+        score += wordBoundary.test(userPrompt) ? 3 : 1;
+      }
+    }
+
+    // Layer priority boost: L1 orchestrators get a small bonus (they're entry points)
+    if (intent.layer === 'L1') score += 1;
+
+    if (score > 0) {
+      scores.push({ skill: skillName, score, chain: intent.chain, model: intent.model, layer: intent.layer });
+    }
+  }
+
+  if (scores.length === 0) {
+    process.exit(0);
+  }
+
+  // Sort by score descending, take top match
+  scores.sort((a, b) => b.score - a.score);
+  const top = scores[0];
+
+  // Only suggest if confidence is reasonable (score >= 3 = at least one strong keyword match)
+  if (top.score < 3) {
+    process.exit(0);
+  }
+
+  // Format chain for display
+  const chainDisplay = top.chain.slice(0, 4).join(' → ');
+  const alternates = scores.slice(1, 3).map((s) => s.skill).join(', ');
+
+  // Output routing suggestion
+  console.log(`\n🧭 [Rune intent-router] Suggested: rune:${top.skill} (${top.layer}, ${top.model})`);
+  console.log(`   Chain: ${chainDisplay}`);
+  if (alternates) {
+    console.log(`   Also consider: ${alternates}`);
+  }
+  console.log('');
+
+  process.exit(0);
+});