@rune-kit/rune 2.6.0 → 2.8.0

package/compiler/doctor.js

@@ -7,7 +7,7 @@
 import { existsSync } from 'node:fs';
 import { readdir, readFile } from 'node:fs/promises';
 import path from 'node:path';
-import { parsePack } from './parser.js';
+import { parseOrgConfig, parsePack, parseTemplate } from './parser.js';
 
 /**
  * Run doctor checks on compiled output
@@ -124,6 +124,45 @@ export async function runDoctor({ outputRoot, adapter, config, runeRoot }) {
     }
   }
 
+  // Check 8: Reference injection rule validation
+  const injectionErrors = await checkInjectionRules(runeRoot, config);
+  if (injectionErrors.length === 0) {
+    results.checks.push({ name: 'Injection rules', status: 'pass' });
+  } else {
+    results.checks.push({
+      name: 'Injection rules',
+      status: 'warn',
+      detail: `${injectionErrors.length} issues`,
+    });
+    results.warnings.push(...injectionErrors);
+  }
+
+  // Check 9: Template signal validation (Pro/Business packs)
+  const templateErrors = await checkTemplateSignals(runeRoot, config);
+  if (templateErrors.length === 0) {
+    results.checks.push({ name: 'Template signals', status: 'pass' });
+  } else {
+    results.checks.push({
+      name: 'Template signals',
+      status: 'warn',
+      detail: `${templateErrors.length} issues`,
+    });
+    results.warnings.push(...templateErrors);
+  }
+
+  // Check 10: Org template validation (Business)
+  const orgErrors = await checkOrgTemplates(runeRoot, config);
+  if (orgErrors.length === 0) {
+    results.checks.push({ name: 'Org templates', status: 'pass' });
+  } else {
+    results.checks.push({
+      name: 'Org templates',
+      status: 'warn',
+      detail: `${orgErrors.length} issues`,
+    });
+    results.warnings.push(...orgErrors);
+  }
+
   if (results.errors.length > 0) results.healthy = false;
 
   return results;
@@ -183,6 +222,238 @@ async function checkSplitPacks(extensionsDir) {
   return errors;
 }
 
+/**
+ * Check that inject.json rules reference existing files and valid skills.
+ */
+async function checkInjectionRules(runeRoot, _config) {
+  const errors = [];
+  const parentDir = path.resolve(runeRoot, '..');
+
+  // Collect known skill names from Free core
+  const knownSkills = new Set();
+  const skillsDir = path.join(runeRoot, 'skills');
+  if (existsSync(skillsDir)) {
+    for (const entry of await readdir(skillsDir, { withFileTypes: true })) {
+      if (entry.isDirectory() && existsSync(path.join(skillsDir, entry.name, 'SKILL.md'))) {
+        knownSkills.add(entry.name);
+      }
+    }
+  }
+
+  // Scan tier directories for inject.json files
+  const tierDirs = [
+    path.join(runeRoot, 'extensions'),
+    path.join(parentDir, 'Pro', 'extensions'),
+    path.join(parentDir, 'Business', 'extensions'),
+  ];
+
+  for (const extDir of tierDirs) {
+    if (!existsSync(extDir)) continue;
+    for (const packEntry of await readdir(extDir, { withFileTypes: true })) {
+      if (!packEntry.isDirectory()) continue;
+      const injectFile = path.join(extDir, packEntry.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, packEntry.name);
+
+        for (const rule of config.injections || []) {
+          // Check target skill exists
+          if (rule.skill && !knownSkills.has(rule.skill)) {
+            errors.push(`${packEntry.name}/inject.json: target skill "${rule.skill}" not found in Free core`);
+          }
+          // Check reference file exists
+          if (rule.ref) {
+            const refPath = path.join(packDir, rule.ref);
+            if (!existsSync(refPath)) {
+              errors.push(`${packEntry.name}/inject.json: reference file "${rule.ref}" not found`);
+            }
+          }
+        }
+      } catch (e) {
+        errors.push(`${packEntry.name}/inject.json: invalid JSON — ${e.message}`);
+      }
+    }
+  }
+
+  return errors;
+}
+
+/**
+ * Check that template signal references exist in the skill ecosystem.
+ * Scans templates/ in Pro/Business extension dirs (relative to runeRoot parent).
+ */
+async function checkTemplateSignals(runeRoot, _config) {
+  const errors = [];
+  const parentDir = path.resolve(runeRoot, '..');
+
+  // Collect all known signals from core + pack skills
+  const knownSignals = new Set();
+  const skillsDir = path.join(runeRoot, 'skills');
+  if (existsSync(skillsDir)) {
+    for (const entry of await readdir(skillsDir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      const skillFile = path.join(skillsDir, entry.name, 'SKILL.md');
+      if (!existsSync(skillFile)) continue;
+      const content = await readFile(skillFile, 'utf-8');
+      for (const signal of extractFrontmatterSignals(content)) {
+        knownSignals.add(signal);
+      }
+    }
+  }
+
+  // Scan tier extension dirs for signals + templates
+  const tierDirs = [
+    path.join(runeRoot, 'extensions'),
+    path.join(parentDir, 'Pro', 'extensions'),
+    path.join(parentDir, 'Business', 'extensions'),
+  ];
+
+  const templateFiles = [];
+
+  for (const extDir of tierDirs) {
+    if (!existsSync(extDir)) continue;
+    for (const packEntry of await readdir(extDir, { withFileTypes: true })) {
+      if (!packEntry.isDirectory()) continue;
+      const packDir = path.join(extDir, packEntry.name);
+
+      // Collect signals from pack skills
+      const packSkillsDir = path.join(packDir, 'skills');
+      if (existsSync(packSkillsDir)) {
+        for (const sf of await readdir(packSkillsDir)) {
+          if (!sf.endsWith('.md')) continue;
+          const content = await readFile(path.join(packSkillsDir, sf), 'utf-8');
+          for (const signal of extractFrontmatterSignals(content)) {
+            knownSignals.add(signal);
+          }
+        }
+      }
+
+      // Collect template files
+      const templatesDir = path.join(packDir, 'templates');
+      if (existsSync(templatesDir)) {
+        for (const tf of await readdir(templatesDir)) {
+          if (!tf.endsWith('.md')) continue;
+          templateFiles.push(path.join(templatesDir, tf));
+        }
+      }
+    }
+  }
+
+  // Validate each template's signals
+  for (const templatePath of templateFiles) {
+    const content = await readFile(templatePath, 'utf-8');
+    const parsed = parseTemplate(content, templatePath);
+    const templateName = parsed.name || path.basename(templatePath, '.md');
+
+    for (const signal of parsed.signals.listen) {
+      if (!knownSignals.has(signal)) {
+        errors.push(`template "${templateName}": listens to "${signal}" but no skill emits it`);
+      }
+    }
+  }
+
+  return errors;
+}
+
+/**
+ * Extract emit/listen signal names from a file's frontmatter
+ */
+function extractFrontmatterSignals(content) {
+  const signals = [];
+  const normalized = content.replace(/\r\n/g, '\n');
+  const fmMatch = normalized.match(/^---\n([\s\S]*?)\n---/);
+  if (!fmMatch) return signals;
+
+  const raw = fmMatch[1];
+  for (const key of ['emit', 'listen']) {
+    const match = raw.match(new RegExp(`^\\s*${key}:\\s*(.+)$`, 'm'));
+    if (match) {
+      for (const s of match[1].split(',')) {
+        const trimmed = s.trim();
+        if (trimmed) signals.push(trimmed);
+      }
+    }
+  }
+  return signals;
+}
+
+/**
+ * Validate org templates in Business tier.
+ * Checks: valid frontmatter, required sections, policy structure.
+ */
+async function checkOrgTemplates(_runeRoot, config) {
+  const errors = [];
+  const tierSources = config.tierSources || {};
+  if (!tierSources.business) return errors;
+
+  const orgTemplatesDir = path.join(tierSources.business, 'org-templates');
+  if (!existsSync(orgTemplatesDir)) return errors;
+
+  let entries;
+  try {
+    entries = await readdir(orgTemplatesDir);
+  } catch {
+    return errors;
+  }
+
+  const mdFiles = entries.filter((f) => f.endsWith('.md'));
+  if (mdFiles.length === 0) {
+    errors.push('org-templates/: directory exists but contains no .md files');
+    return errors;
+  }
+
+  const requiredSections = ['Teams', 'Roles', 'Policies', 'Governance Level'];
+
+  for (const file of mdFiles) {
+    const filePath = path.join(orgTemplatesDir, file);
+    try {
+      const content = await readFile(filePath, 'utf-8');
+      const parsed = parseOrgConfig(content, filePath);
+
+      // Check required frontmatter
+      if (!parsed.name) {
+        errors.push(`org-templates/${file}: missing 'name' in frontmatter`);
+      }
+      if (!parsed.description) {
+        errors.push(`org-templates/${file}: missing 'description' in frontmatter`);
+      }
+
+      // Check required sections exist
+      for (const section of requiredSections) {
+        const pattern = new RegExp(`## ${section}`);
+        if (!pattern.test(content)) {
+          errors.push(`org-templates/${file}: missing required section '## ${section}'`);
+        }
+      }
+
+      // Check teams table has entries
+      if (parsed.teams.length === 0) {
+        errors.push(`org-templates/${file}: ## Teams table is empty`);
+      }
+
+      // Check roles table has entries
+      if (parsed.roles.length === 0) {
+        errors.push(`org-templates/${file}: ## Roles table is empty`);
+      }
+
+      // Check governance level is valid
+      const validLevels = ['minimal', 'moderate', 'maximum'];
+      if (!validLevels.includes(parsed.governanceLevel.level)) {
+        errors.push(
+          `org-templates/${file}: governance level '${parsed.governanceLevel.level}' not in [${validLevels.join(', ')}]`,
+        );
+      }
+    } catch (err) {
+      errors.push(`org-templates/${file}: parse error — ${err.message}`);
+    }
+  }
+
+  return errors;
+}
+
 /**
  * Format doctor results for console output
  */