@rune-kit/rune 2.3.3 → 2.6.0

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);
+});

package/hooks/pre-tool-guard/index.cjs

@@ -1,68 +1,177 @@
-// Rune Pre-Tool Guard Hook
-// Preventive security gate — warns before AI reads/edits sensitive files
-// Runs as PreToolUse hook for Read, Write, Edit tools
-
-const path = require('path');
-
-// Read tool_input from Claude Code hook stdin
-let input = '';
-process.stdin.setEncoding('utf-8');
-process.stdin.on('data', (chunk) => { input += chunk; });
-process.stdin.on('end', () => {
-  let toolInput = {};
-  try {
-    const parsed = JSON.parse(input);
-    toolInput = parsed.tool_input || parsed;
-  } catch {
-    // If no stdin or parse fails, exit cleanly (non-blocking)
-    process.exit(0);
-  }
-
-  const filePath = toolInput.file_path || toolInput.path || '';
-  if (!filePath) process.exit(0);
-
-  const basename = path.basename(filePath);
-  const normalized = filePath.replace(/\\/g, '/');
-
-  // Sensitive file patterns
-  const sensitivePatterns = [
-    /^\.env$/,                         // .env exactly
-    /^\.env\.[^e]/,                    // .env.* but NOT .env.example
-    /\.pem$/,
-    /\.key$/,
-    /\.p12$/,
-    /\.pfx$/,
-    /^credentials\.json$/,
-    /\.secret$/,
-    /^\.netrc$/,
-    /^id_rsa$/,
-    /^id_ed25519$/,
-    /^id_ecdsa$/,
-    /^\.ssh\//,
-    /private.*key/i,
-    /secret.*key/i,
-  ];
-
-  // Exclude safe exceptions
-  const safeExceptions = [
-    /\.env\.example$/,
-    /\.env\.sample$/,
-    /\.env\.template$/,
-    /\.env\.test$/,
-    /test.*credential/i,
-    /fixture/i,
-    /mock/i,
-  ];
-
-  const isSensitive = sensitivePatterns.some((p) => p.test(basename) || p.test(normalized));
-  const isSafe = safeExceptions.some((p) => p.test(basename) || p.test(normalized));
-
-  if (isSensitive && !isSafe) {
-    // Output warning to user — does NOT hard-block (developer may legitimately need access)
-    console.log(`\n⚠ [Rune pre-tool-guard] Sensitive file detected: ${filePath}`);
-    console.log('  This file may contain secrets. Confirm this access is intentional.');
-    console.log('  If scanning for secrets, use /rune sentinel instead.\n');
-  }
-
-  process.exit(0);
-});
+// Rune Pre-Tool Guard Hook — Privacy Mesh
+// Three-tier security gate: ALLOW / WARN / BLOCK
+// Configurable via .rune/privacy.json per project
+// Skill-aware: sentinel/review can access files other skills cannot
+//
+// Upgrades over basic path matching:
+// - Per-project .rune/privacy.json config (custom patterns + overrides)
+// - Three tiers: ALLOW (silent), WARN (log), BLOCK (exit code 2)
+// - Content-aware: scans first bytes for secret patterns on WARN files
+
+const fs = require('fs');
+const path = require('path');
+
+// Read tool_input from Claude Code hook stdin
+let input = '';
+process.stdin.setEncoding('utf-8');
+process.stdin.on('data', (chunk) => { input += chunk; });
+process.stdin.on('end', () => {
+  let toolInput = {};
+  let toolName = '';
+  try {
+    const parsed = JSON.parse(input);
+    toolInput = parsed.tool_input || parsed;
+    toolName = parsed.tool_name || '';
+  } catch {
+    // If no stdin or parse fails, exit cleanly (non-blocking)
+    process.exit(0);
+  }
+
+  const filePath = toolInput.file_path || toolInput.path || '';
+  if (!filePath) process.exit(0);
+
+  const basename = path.basename(filePath);
+  const normalized = filePath.replace(/\\/g, '/');
+
+  // Load project-specific privacy config
+  const privacyConfig = loadPrivacyConfig();
+
+  // Default sensitive file patterns — BLOCK tier (hard block)
+  const blockPatterns = [
+    /^id_rsa$/,
+    /^id_ed25519$/,
+    /^id_ecdsa$/,
+    /\.p12$/,
+    /\.pfx$/,
+    /\.pem$/,
+    /^\.netrc$/,
+    /private[-_.]?key/i,
+    ...privacyConfig.block.map((p) => new RegExp(p)),
+  ];
+
+  // WARN tier (log warning, allow through)
+  const warnPatterns = [
+    /^\.env$/,
+    /^\.env\.[^e]/,                  // .env.* but NOT .env.example
+    /\.key$/,
+    /^credentials\.json$/,
+    /\.secret$/,
+    /secret[-_.]?key/i,
+    ...privacyConfig.warn.map((p) => new RegExp(p)),
+  ];
+
+  // Safe exceptions (always allow)
+  const safeExceptions = [
+    /\.env\.example$/,
+    /\.env\.sample$/,
+    /\.env\.template$/,
+    /\.env\.test$/,
+    /test.*credential/i,
+    /fixture/i,
+    /mock/i,
+    ...privacyConfig.allow.map((p) => new RegExp(p)),
+  ];
+
+  // Skills with elevated access (can read WARN-tier files without warning)
+  const elevatedSkills = new Set([
+    'sentinel', 'review', 'audit', 'secrets-scan', 'onboard',
+    ...privacyConfig.elevatedSkills,
+  ]);
+
+  // Detect active skill from environment (set by metrics-collector or skill invocation)
+  const activeSkill = process.env.RUNE_ACTIVE_SKILL || '';
+  const isElevated = elevatedSkills.has(activeSkill);
+
+  const isSafe = safeExceptions.some((p) => p.test(basename) || p.test(normalized));
+  if (isSafe) process.exit(0);
+
+  const isBlocked = blockPatterns.some((p) => p.test(basename) || p.test(normalized));
+  if (isBlocked) {
+    console.log(`\n🚫 [Rune privacy-mesh] BLOCKED: ${filePath}`);
+    console.log('  This file matches a BLOCK-tier pattern (private keys, certificates).');
+    console.log('  Override: add path to .rune/privacy.json "allow" list if intentional.\n');
+    process.exit(2); // Exit code 2 = BLOCK
+  }
+
+  const isWarned = warnPatterns.some((p) => p.test(basename) || p.test(normalized));
+  if (isWarned && !isElevated) {
+    // Content-aware check: scan first 4KB for secret patterns
+    const contentWarning = scanContentForSecrets(filePath);
+
+    console.log(`\n⚠ [Rune privacy-mesh] Sensitive file: ${filePath}`);
+    if (contentWarning) {
+      console.log(`  Content scan: ${contentWarning}`);
+    }
+    console.log('  This file may contain secrets. Confirm access is intentional.');
+    console.log('  Elevated skills (sentinel, review, audit) bypass this warning.\n');
+  }
+
+  process.exit(0);
+});
+
+/**
+ * Load .rune/privacy.json from project root
+ * Returns merged config with defaults
+ */
+function loadPrivacyConfig() {
+  const defaults = { block: [], warn: [], allow: [], elevatedSkills: [] };
+
+  const candidates = [
+    path.join(process.cwd(), '.rune', 'privacy.json'),
+    path.join(process.cwd(), 'privacy.json'),
+  ];
+
+  for (const configPath of candidates) {
+    try {
+      if (fs.existsSync(configPath)) {
+        const raw = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+        return {
+          block: Array.isArray(raw.block) ? raw.block : defaults.block,
+          warn: Array.isArray(raw.warn) ? raw.warn : defaults.warn,
+          allow: Array.isArray(raw.allow) ? raw.allow : defaults.allow,
+          elevatedSkills: Array.isArray(raw.elevatedSkills) ? raw.elevatedSkills : defaults.elevatedSkills,
+        };
+      }
+    } catch {
+      // Invalid config — use defaults
+    }
+  }
+
+  return defaults;
+}
+
+/**
+ * Scan first 4KB of a file for common secret patterns
+ * Returns a warning string if secrets detected, null otherwise
+ */
+function scanContentForSecrets(filePath) {
+  try {
+    const fd = fs.openSync(filePath, 'r');
+    const buffer = Buffer.alloc(4096);
+    const bytesRead = fs.readSync(fd, buffer, 0, 4096, 0);
+    fs.closeSync(fd);
+
+    if (bytesRead === 0) return null;
+
+    const content = buffer.toString('utf-8', 0, bytesRead);
+
+    const secretPatterns = [
+      { pattern: /AKIA[0-9A-Z]{16}/, label: 'AWS access key' },
+      { pattern: /gh[ps]_[A-Za-z0-9_]{36,}/, label: 'GitHub token' },
+      { pattern: /sk_(live|test)_[0-9a-zA-Z]{24,}/, label: 'Stripe key' },
+      { pattern: /-----BEGIN .* PRIVATE KEY-----/, label: 'Private key' },
+      { pattern: /xox[bpors]-[0-9a-zA-Z-]{10,}/, label: 'Slack token' },
+      { pattern: /sk-[a-zA-Z0-9]{32,}/, label: 'OpenAI/API key' },
+    ];
+
+    for (const { pattern, label } of secretPatterns) {
+      if (pattern.test(content)) {
+        return `Found ${label} pattern in file content`;
+      }
+    }
+  } catch {
+    // Can't read file (doesn't exist yet, permissions, etc.) — skip silently
+  }
+
+  return null;
+}

package/package.json

@@ -1,64 +1,63 @@
-{
-  "name": "@rune-kit/rune",
-  "version": "2.3.3",
-  "description": "59-skill mesh for AI coding assistants — 5-layer architecture, 200+ connections, 8 platforms (Claude Code, Cursor, Windsurf, Antigravity, Codex, OpenCode, OpenClaw, Generic)",
-  "type": "module",
-  "bin": {
-    "rune": "./compiler/bin/rune.js"
-  },
-  "scripts": {
-    "build": "node compiler/bin/rune.js build",
-    "doctor": "node compiler/bin/rune.js doctor && node scripts/version-sync-check.js",
-    "test": "node --test compiler/__tests__/*.test.js scripts/__tests__/*.test.js",
-    "test:coverage": "c8 --reporter=text --reporter=lcov node --test compiler/__tests__/*.test.js scripts/__tests__/*.test.js",
-    "lint": "biome check .",
-    "lint:fix": "biome check --fix .",
-    "format": "biome format --write .",
-    "ci": "biome check . && node --test compiler/__tests__/*.test.js scripts/__tests__/*.test.js && node compiler/bin/rune.js doctor",
-    "version-check": "node scripts/version-sync-check.js",
-    "prepublishOnly": "node scripts/version-sync-check.js"
-  },
-  "keywords": [
-    "claude-code",
-    "cursor",
-    "windsurf",
-    "antigravity",
-    "codex",
-    "opencode",
-    "openclaw",
-    "ai-assistant",
-    "ai-coding",
-    "skills",
-    "coding-agent",
-    "tdd",
-    "multi-platform"
-  ],
-  "author": "runedev",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/rune-kit/rune"
-  },
-  "engines": {
-    "node": ">=18"
-  },
-  "files": [
-    "compiler/",
-    "skills/",
-    "extensions/",
-    "contexts/",
-    "commands/",
-    "agents/",
-    "hooks/",
-    "docs/",
-    "references/"
-  ],
-  "homepage": "https://rune-kit.github.io/rune",
-  "bugs": {
-    "url": "https://github.com/rune-kit/rune/issues"
-  },
-  "devDependencies": {
-    "@biomejs/biome": "^2.4.7",
-    "c8": "^10.1.3"
-  }
-}
+{
+  "name": "@rune-kit/rune",
+  "version": "2.6.0",
+  "description": "61-skill mesh for AI coding assistants — 5-layer architecture, 200+ connections, 8 platforms (Claude Code, Cursor, Windsurf, Antigravity, Codex, OpenCode, OpenClaw, Generic)",
+  "type": "module",
+  "bin": {
+    "rune": "./compiler/bin/rune.js"
+  },
+  "scripts": {
+    "build": "node compiler/bin/rune.js build",
+    "doctor": "node compiler/bin/rune.js doctor && node scripts/version-sync-check.js",
+    "test": "node --test compiler/__tests__/*.test.js scripts/__tests__/*.test.js",
+    "test:coverage": "c8 --reporter=text --reporter=lcov node --test compiler/__tests__/*.test.js scripts/__tests__/*.test.js",
+    "lint": "biome check .",
+    "lint:fix": "biome check --fix .",
+    "format": "biome format --write .",
+    "ci": "biome check . && node --test compiler/__tests__/*.test.js scripts/__tests__/*.test.js && node compiler/bin/rune.js doctor",
+    "version-check": "node scripts/version-sync-check.js",
+    "prepublishOnly": "node scripts/version-sync-check.js"
+  },
+  "keywords": [
+    "claude-code",
+    "cursor",
+    "windsurf",
+    "antigravity",
+    "codex",
+    "opencode",
+    "openclaw",
+    "ai-assistant",
+    "ai-coding",
+    "skills",
+    "coding-agent",
+    "tdd",
+    "multi-platform"
+  ],
+  "author": "runedev",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/rune-kit/rune"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "compiler/",
+    "skills/",
+    "extensions/",
+    "contexts/",
+    "commands/",
+    "agents/",
+    "hooks/",
+    "references/"
+  ],
+  "homepage": "https://rune-kit.github.io/rune",
+  "bugs": {
+    "url": "https://github.com/rune-kit/rune/issues"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.4.7",
+    "c8": "^10.1.3"
+  }
+}

package/skills/brainstorm/SKILL.md

@@ -8,6 +8,8 @@ metadata:
   model: opus
   group: creation
   tools: "Read, Glob, Grep"
+  emit: ideas.ready
+  listen: codebase.scanned
 ---
 
 # brainstorm