@rune-kit/rune 2.4.0 → 2.7.0

package/compiler/parser.js

@@ -5,6 +5,12 @@
  * 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;
@@ -41,10 +47,29 @@ function parseFrontmatter(content) {
     }
 
     if (currentIndent === 'nested' && line.startsWith('  ')) {
-      const kvMatch = trimmed.match(/^(\w+):\s*(.+)$/);
+      // YAML list item (e.g. "  - value")
+      const listMatch = trimmed.match(/^-\s+(.+)$/);
+      if (listMatch) {
+        // Convert nested block to array if not already
+        if (!Array.isArray(frontmatter[nestedKey])) {
+          frontmatter[nestedKey] = [];
+        }
+        frontmatter[nestedKey].push(listMatch[1].replace(/^["']|["']$/g, ''));
+        continue;
+      }
+
+      const kvMatch = trimmed.match(/^(\w[\w-]*):\s*(.+)$/);
       if (kvMatch) {
-        const value = kvMatch[2].replace(/^["']|["']$/g, '');
-        frontmatter[nestedKey][kvMatch[1]] = value;
+        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;
     }
@@ -55,7 +80,15 @@ function parseFrontmatter(content) {
     const kvMatch = trimmed.match(/^(\w[\w-]*):\s*(.+)$/);
     if (kvMatch) {
       const value = kvMatch[2].replace(/^["']|["']$/g, '');
-      frontmatter[kvMatch[1]] = value;
+      // Comma-separated list fields at top level too (Pro/Business packs)
+      if (COMMA_LIST_FIELDS.has(kvMatch[1])) {
+        frontmatter[kvMatch[1]] = value
+          .split(',')
+          .map((s) => s.trim())
+          .filter(Boolean);
+      } else {
+        frontmatter[kvMatch[1]] = value;
+      }
     }
   }
 
@@ -168,12 +201,22 @@ export function parseSkill(content, filePath = '') {
 
   const metadata = frontmatter.metadata || {};
 
+  // Extract signals — emit/listen arrays from metadata or top-level (Pro/Business packs)
+  const emit = Array.isArray(metadata.emit) ? metadata.emit : Array.isArray(frontmatter.emit) ? frontmatter.emit : [];
+  const listen = Array.isArray(metadata.listen)
+    ? metadata.listen
+    : Array.isArray(frontmatter.listen)
+      ? frontmatter.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,
@@ -223,6 +266,214 @@ export function parsePack(content, filePath = '') {
  * @param {Array} skills - array of skill entries from frontmatter metadata.skills
  * @returns {Array<{name: string, file: string, model: string, description: string}>}
  */
+/**
+ * Parse a workflow template file (templates/*.md)
+ *
+ * Templates have the same frontmatter structure as skills but with additional
+ * template-specific fields: domain, chain, connections[]
+ *
+ * @param {string} content - raw template file content
+ * @param {string} [filePath] - optional file path for error reporting
+ * @returns {ParsedTemplate}
+ */
+export function parseTemplate(content, filePath = '') {
+  const { frontmatter, body } = parseFrontmatter(content);
+
+  // Parse signals — can be nested object { emit: "...", listen: "..." } or flat
+  const signalsRaw = frontmatter.signals || {};
+  const emit =
+    typeof signalsRaw.emit === 'string'
+      ? signalsRaw.emit
+          .split(',')
+          .map((s) => s.trim())
+          .filter(Boolean)
+      : Array.isArray(signalsRaw.emit)
+        ? signalsRaw.emit
+        : [];
+  const listen =
+    typeof signalsRaw.listen === 'string'
+      ? signalsRaw.listen
+          .split(',')
+          .map((s) => s.trim())
+          .filter(Boolean)
+      : Array.isArray(signalsRaw.listen)
+        ? signalsRaw.listen
+        : [];
+
+  // Parse connections array — supports both comma-separated string and YAML array
+  let connections = [];
+  if (frontmatter.connections) {
+    if (typeof frontmatter.connections === 'string') {
+      connections = frontmatter.connections
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean);
+    } else if (Array.isArray(frontmatter.connections)) {
+      connections = frontmatter.connections;
+    }
+  }
+
+  return {
+    name: frontmatter.name || '',
+    pack: frontmatter.pack || '',
+    version: frontmatter.version || '1.0.0',
+    description: frontmatter.description || '',
+    domain: frontmatter.domain || '',
+    chain: frontmatter.chain || 'standard',
+    signals: { emit, listen },
+    connections,
+    body,
+    crossRefs: extractCrossRefs(body),
+    sections: extractSections(body),
+    filePath,
+    frontmatter,
+  };
+}
+
+/**
+ * Parse organization config from .rune/org/org.md
+ * Extracts teams, roles, policies, approval flows, and governance level.
+ */
+export function parseOrgConfig(content, filePath = '') {
+  const { frontmatter, body } = parseFrontmatter(content);
+
+  const teams = parseMarkdownTable(body, 'Teams');
+  const roles = parseMarkdownTable(body, 'Roles');
+  const policies = parseOrgPolicies(body);
+  const approvalFlows = parseApprovalFlows(body);
+  const governanceLevel = parseGovernanceLevel(body);
+
+  return {
+    name: frontmatter.name || '',
+    description: frontmatter.description || '',
+    version: frontmatter.version || '1.0.0',
+    tier: frontmatter.tier || 'business',
+    teams,
+    roles,
+    policies,
+    approvalFlows,
+    governanceLevel,
+    body,
+    filePath,
+    frontmatter,
+  };
+}
+
+/**
+ * Parse a Markdown table under a ## heading into array of objects.
+ * Handles | col1 | col2 | format with header row + separator row + data rows.
+ */
+function parseMarkdownTable(body, sectionName) {
+  // Find the section
+  const sectionPattern = new RegExp(`## ${sectionName}\\s*\\n([\\s\\S]*?)(?=\\n## |$)`);
+  const sectionMatch = body.match(sectionPattern);
+  if (!sectionMatch) return [];
+
+  const sectionContent = sectionMatch[1];
+  const lines = sectionContent.split('\n').filter((l) => l.trim().startsWith('|'));
+  if (lines.length < 3) return []; // need header + separator + at least 1 row
+
+  const parseRow = (line) =>
+    line
+      .split('|')
+      .slice(1, -1)
+      .map((cell) => cell.trim());
+
+  const headers = parseRow(lines[0]).map((h) => h.toLowerCase().replace(/\s+/g, '_'));
+  // Skip separator row (lines[1])
+  const rows = [];
+  for (let i = 2; i < lines.length; i++) {
+    const cells = parseRow(lines[i]);
+    if (cells.length === 0) continue;
+    const row = {};
+    headers.forEach((h, idx) => {
+      row[h] = cells[idx] || '';
+    });
+    rows.push(row);
+  }
+  return rows;
+}
+
+/**
+ * Parse ### subsections under ## Policies into a map of policy name → rules array.
+ */
+function parseOrgPolicies(body) {
+  const policiesPattern = /## Policies\s*\n([\s\S]*?)(?=\n## [^#]|$)/;
+  const policiesMatch = body.match(policiesPattern);
+  if (!policiesMatch) return {};
+
+  // Prepend \n so first ### subsection is also captured by split
+  const policiesContent = `\n${policiesMatch[1].trimStart()}`;
+  const policies = {};
+  const subSections = policiesContent.split(/\n### /);
+
+  for (let i = 1; i < subSections.length; i++) {
+    const lines = subSections[i].split('\n');
+    const name = lines[0].trim().toLowerCase().replace(/\s+/g, '_');
+    const rules = lines
+      .slice(1)
+      .filter((l) => l.trim().startsWith('- **'))
+      .map((l) => {
+        const match = l.match(/- \*\*(.+?)\*\*:\s*(.+)/);
+        if (!match) return null;
+        return {
+          key: match[1].trim().toLowerCase().replace(/\s+/g, '_'),
+          value: match[2].trim(),
+        };
+      })
+      .filter(Boolean);
+    policies[name] = rules;
+  }
+  return policies;
+}
+
+/**
+ * Parse ### subsections under ## Approval Flows into named flow strings.
+ */
+function parseApprovalFlows(body) {
+  const flowsPattern = /## Approval Flows\s*\n([\s\S]*?)(?=\n## [^#]|$)/;
+  const flowsMatch = body.match(flowsPattern);
+  if (!flowsMatch) return {};
+
+  // Prepend \n so first ### subsection is also captured by split
+  const flowsContent = `\n${flowsMatch[1].trimStart()}`;
+  const flows = {};
+  const subSections = flowsContent.split(/\n### /);
+
+  for (let i = 1; i < subSections.length; i++) {
+    const lines = subSections[i].split('\n');
+    const name = lines[0].trim().toLowerCase().replace(/\s+/g, '_');
+    // Extract content between ``` blocks
+    const codeMatch = subSections[i].match(/```\n([\s\S]*?)```/);
+    if (codeMatch) {
+      flows[name] = codeMatch[1].trim();
+    }
+  }
+  return flows;
+}
+
+/**
+ * Parse ## Governance Level section for governance mode and settings.
+ */
+function parseGovernanceLevel(body) {
+  const govPattern = /## Governance Level\s*\n([\s\S]*?)(?=\n## |$)/;
+  const govMatch = body.match(govPattern);
+  if (!govMatch) return { level: 'unknown', settings: [] };
+
+  const content = govMatch[1];
+  // Extract bold level: **Minimal**, **Moderate**, **Maximum**
+  const levelMatch = content.match(/\*\*(\w+)\*\*/);
+  const level = levelMatch ? levelMatch[1].toLowerCase() : 'unknown';
+
+  // Extract bullet settings
+  const settings = content
+    .split('\n')
+    .filter((l) => l.trim().startsWith('- '))
+    .map((l) => l.trim().replace(/^- /, ''));
+
+  return { level, settings };
+}
+
 function parseSkillManifest(skills) {
   if (!Array.isArray(skills)) return [];
 

package/compiler/status.js

@@ -0,0 +1,342 @@
+/**
+ * Status — Project Neofetch
+ *
+ * Shows a rich boxed dashboard of the current Rune project.
+ * Output varies by detected tier: Free, Pro, Business.
+ */
+
+import { existsSync } from 'node:fs';
+import { readdir, readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { parseSkill } from './parser.js';
+
+// ─── Constants ───
+
+// ─── Box Drawing ───
+
+function box(lines, { title = '', width = 52 } = {}) {
+  const inner = width - 2;
+  const output = [];
+
+  const titleStr = title ? ` ${title} ` : '';
+  const topFill = inner - titleStr.length - 1;
+  output.push(`╭─${titleStr}${'─'.repeat(Math.max(topFill, 0))}╮`);
+
+  for (const line of lines) {
+    const dw = displayWidth(line);
+    const pad = inner - dw;
+    output.push(`│ ${line}${' '.repeat(Math.max(pad, 0))}│`);
+  }
+
+  output.push(`╰${'─'.repeat(inner + 1)}╯`);
+  return output.join('\n');
+}
+
+function displayWidth(str) {
+  let w = 0;
+  for (const ch of str) {
+    const code = ch.codePointAt(0);
+    // Emoji and wide chars take 2 columns
+    if (
+      code > 0x1f600 ||
+      (code >= 0x2600 && code <= 0x27bf) ||
+      (code >= 0x2700 && code <= 0x27bf) ||
+      code === 0x2713 ||
+      code === 0x2717 ||
+      code === 0x2192 ||
+      code === 0x2593 ||
+      code === 0x2591
+    ) {
+      w += 1; // These specific Unicode symbols are single-width in most terminals
+    } else if (code > 0xffff) {
+      w += 2; // Emoji (surrogate pairs) are double-width
+    } else {
+      w += 1;
+    }
+  }
+  return w;
+}
+
+function progressBar(pct, width = 20) {
+  const filled = Math.round((pct / 100) * width);
+  const empty = width - filled;
+  return '▓'.repeat(filled) + '░'.repeat(empty);
+}
+
+// ─── Data Collection ───
+
+export async function collectStats(runeRoot, tierSources = {}) {
+  const skillsDir = path.join(runeRoot, 'skills');
+  const extDir = path.join(runeRoot, 'extensions');
+
+  // Count core skills by layer
+  const layers = { L0: 0, L1: 0, L2: 0, L3: 0 };
+  const skillNames = [];
+  let signalCount = 0;
+  const signalMap = { emitters: {}, listeners: {} };
+  const parsedSkills = [];
+
+  if (existsSync(skillsDir)) {
+    const entries = await readdir(skillsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const skillFile = path.join(skillsDir, entry.name, 'SKILL.md');
+      if (!existsSync(skillFile)) continue;
+
+      const content = await readFile(skillFile, 'utf-8');
+      const parsed = parseSkill(content, skillFile);
+      parsedSkills.push(parsed);
+      skillNames.push(parsed.name);
+
+      const layer = parsed.layer || 'L3';
+      if (layers[layer] !== undefined) layers[layer]++;
+
+      if (parsed.signals?.emit && parsed.signals?.listen) {
+        for (const sig of parsed.signals.emit) {
+          if (!signalMap.emitters[sig]) signalMap.emitters[sig] = [];
+          signalMap.emitters[sig].push(parsed.name);
+        }
+        for (const sig of parsed.signals.listen) {
+          if (!signalMap.listeners[sig]) signalMap.listeners[sig] = [];
+          signalMap.listeners[sig].push(parsed.name);
+        }
+      }
+    }
+    const allSignals = new Set([...Object.keys(signalMap.emitters), ...Object.keys(signalMap.listeners)]);
+    signalCount = allSignals.size;
+  }
+
+  // Count connections
+  let totalConnections = 0;
+  for (const skill of parsedSkills) {
+    totalConnections += new Set((skill.crossRefs ?? []).map((r) => r.skillName)).size;
+  }
+  const avgConnections = parsedSkills.length > 0 ? (totalConnections / parsedSkills.length).toFixed(1) : '0';
+
+  // Count free packs
+  const freePacks = [];
+  if (existsSync(extDir)) {
+    const entries = await readdir(extDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const packFile = path.join(extDir, entry.name, 'PACK.md');
+      if (!existsSync(packFile)) continue;
+      freePacks.push(entry.name);
+    }
+  }
+
+  // Count Pro packs
+  const proPacks = await scanTierPacks(tierSources.pro);
+  const bizPacks = await scanTierPacks(tierSources.business);
+
+  // Detect tier
+  const tier = bizPacks.length > 0 ? 'business' : proPacks.length > 0 ? 'pro' : 'free';
+
+  return {
+    tier,
+    skillCount: parsedSkills.length,
+    layers,
+    signalCount,
+    signalMap,
+    totalConnections,
+    avgConnections,
+    freePacks,
+    proPacks,
+    bizPacks,
+    parsedSkills,
+  };
+}
+
+async function scanTierPacks(tierDir) {
+  const packs = [];
+  if (!tierDir || !existsSync(tierDir)) return packs;
+
+  const entries = await readdir(tierDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const packDir = path.join(tierDir, entry.name);
+    const packFile = path.join(packDir, 'PACK.md');
+    if (!existsSync(packFile)) continue;
+
+    // Count total lines in pack
+    let lines = 0;
+    const subEntries = await readdir(packDir, { withFileTypes: true });
+    for (const sub of subEntries) {
+      if (sub.isFile() && sub.name.endsWith('.md')) {
+        const content = await readFile(path.join(packDir, sub.name), 'utf-8');
+        lines += content.split('\n').length;
+      }
+    }
+
+    packs.push({ name: entry.name, lines });
+  }
+  return packs;
+}
+
+// ─── Rendering ───
+
+function tierIcon(tier) {
+  if (tier === 'business') return '🏢';
+  if (tier === 'pro') return '⚡';
+  return '🔮';
+}
+
+function tierLabel(tier) {
+  if (tier === 'business') return 'Rune Business';
+  if (tier === 'pro') return 'Rune Pro';
+  return 'Rune';
+}
+
+function fmtNum(n) {
+  return n.toLocaleString('en-US');
+}
+
+export function renderStatus(stats, { version = '', platform = '', projectName = '' } = {}) {
+  const lines = [];
+  const icon = tierIcon(stats.tier);
+  const label = tierLabel(stats.tier);
+
+  // Header
+  lines.push('');
+
+  // Project info
+  if (projectName) lines.push(`Project     ${projectName}`);
+  if (platform) lines.push(`Platform    ${platform}`);
+  if (version) lines.push(`Version     ${version}`);
+  if (projectName || platform || version) lines.push('');
+
+  // Core stats
+  const layerStr = Object.entries(stats.layers)
+    .filter(([, v]) => v > 0)
+    .map(([k, v]) => `${k}:${v}`)
+    .join(' ');
+  lines.push(`Skills      ${stats.skillCount} core (${layerStr})`);
+
+  const packParts = [`${stats.freePacks.length} free`];
+  if (stats.proPacks.length > 0) packParts.push(`${stats.proPacks.length} pro`);
+  if (stats.bizPacks.length > 0) packParts.push(`${stats.bizPacks.length} business`);
+  lines.push(`Packs       ${packParts.join(' + ')}`);
+
+  lines.push(`Signals     ${stats.signalCount} defined`);
+  lines.push(`Mesh        ${stats.totalConnections}+ connections (${stats.avgConnections} avg/skill)`);
+  lines.push('');
+
+  // Health bar (based on signals + connections + pack count as simple heuristic)
+  const healthScore = computeHealth(stats);
+  lines.push(`${progressBar(healthScore)} ${healthScore}% mesh health`);
+  lines.push('');
+
+  // Pro section
+  if (stats.proPacks.length > 0) {
+    lines.push('Pro Packs');
+    for (const pack of stats.proPacks) {
+      lines.push(`  ✓ ${formatPackName(pack.name, 'pro')}  ${fmtNum(pack.lines)} lines`);
+    }
+    lines.push('');
+  }
+
+  // Business section
+  if (stats.bizPacks.length > 0) {
+    lines.push('Business Packs');
+    for (const pack of stats.bizPacks) {
+      lines.push(`  ✓ ${formatPackName(pack.name, 'business')}  ${fmtNum(pack.lines)} lines`);
+    }
+    lines.push('');
+  }
+
+  // Top signals (show signal flow)
+  const topSignals = getTopSignals(stats.signalMap, 3);
+  if (topSignals.length > 0) {
+    lines.push('Active Signals');
+    for (const sig of topSignals) {
+      const emitters = sig.emitters.slice(0, 2).join(', ');
+      const listeners = sig.listeners.slice(0, 3).join(', ');
+      let sigLine = `  → ${sig.name} (${emitters} → ${listeners})`;
+      if (sigLine.length > 64) sigLine = `${sigLine.slice(0, 61)}...`;
+      lines.push(sigLine);
+    }
+    lines.push('');
+  }
+
+  const title = `${icon} ${label}`;
+  const maxLineLen = lines.reduce((max, l) => Math.max(max, displayWidth(l)), 48);
+  const boxWidth = Math.min(Math.max(maxLineLen + 4, 52), 72);
+
+  return box(lines, { title, width: boxWidth });
+}
+
+export function renderStatusJson(stats, { version = '', platform = '', projectName = '' } = {}) {
+  return JSON.stringify(
+    {
+      project: projectName || undefined,
+      platform: platform || undefined,
+      version: version || undefined,
+      tier: stats.tier,
+      skills: {
+        total: stats.skillCount,
+        layers: stats.layers,
+      },
+      packs: {
+        free: stats.freePacks.length,
+        pro: stats.proPacks.map((p) => ({ name: p.name, lines: p.lines })),
+        business: stats.bizPacks.map((p) => ({ name: p.name, lines: p.lines })),
+      },
+      signals: {
+        count: stats.signalCount,
+        top: getTopSignals(stats.signalMap, 5).map((s) => ({
+          name: s.name,
+          emitters: s.emitters,
+          listeners: s.listeners,
+        })),
+      },
+      mesh: {
+        connections: stats.totalConnections,
+        avgPerSkill: parseFloat(stats.avgConnections),
+      },
+      health: computeHealth(stats),
+    },
+    null,
+    2,
+  );
+}
+
+function formatPackName(dirName, tier = 'free') {
+  const baseName = dirName.replace(/^(pro|business)-/, '');
+  if (tier === 'business') return `@rune-biz/${baseName}`.padEnd(26);
+  if (tier === 'pro') return `@rune-pro/${baseName}`.padEnd(26);
+  return `@rune/${baseName}`.padEnd(26);
+}
+
+function getTopSignals(signalMap, limit) {
+  const signals = new Set([...Object.keys(signalMap.emitters), ...Object.keys(signalMap.listeners)]);
+
+  const scored = [...signals].map((name) => ({
+    name,
+    emitters: signalMap.emitters[name] || [],
+    listeners: signalMap.listeners[name] || [],
+    score: (signalMap.emitters[name]?.length || 0) + (signalMap.listeners[name]?.length || 0),
+  }));
+
+  scored.sort((a, b) => b.score - a.score);
+  return scored.slice(0, limit);
+}
+
+function computeHealth(stats) {
+  let score = 0;
+
+  // Skills (max 25)
+  score += Math.min(stats.skillCount / 60, 1) * 25;
+
+  // Signals (max 25)
+  score += Math.min(stats.signalCount / 15, 1) * 25;
+
+  // Connections density (max 25)
+  const avgConn = parseFloat(stats.avgConnections);
+  score += Math.min(avgConn / 3.5, 1) * 25;
+
+  // Pack coverage (max 25)
+  const totalPacks = stats.freePacks.length + stats.proPacks.length + stats.bizPacks.length;
+  score += Math.min(totalPacks / 14, 1) * 25;
+
+  return Math.round(score);
+}