@rune-kit/rune 2.10.0 → 2.12.0

package/compiler/__tests__/doctor-mesh.test.js

@@ -0,0 +1,229 @@
+/**
+ * Tests for doctor mesh integrity checks
+ */
+
+import assert from 'node:assert';
+import { mkdir, rm, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, test } from 'node:test';
+import { fileURLToPath } from 'node:url';
+import { checkMeshIntegrity, formatMeshResults } from '../doctor.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const TEST_ROOT = path.join(__dirname, '.test-mesh-skills');
+
+describe('checkMeshIntegrity', () => {
+  beforeEach(async () => {
+    await mkdir(path.join(TEST_ROOT, 'skills', 'skill-a'), { recursive: true });
+    await mkdir(path.join(TEST_ROOT, 'skills', 'skill-b'), { recursive: true });
+  });
+
+  afterEach(async () => {
+    await rm(TEST_ROOT, { recursive: true, force: true });
+  });
+
+  test('detects missing reciprocal connections', async () => {
+    // skill-a calls skill-b, but skill-b doesn't acknowledge
+    await writeFile(
+      path.join(TEST_ROOT, 'skills', 'skill-a', 'SKILL.md'),
+      `---
+name: skill-a
+metadata:
+  version: "1.0.0"
+---
+# skill-a
+## Calls (outbound)
+- \`skill-b\` (L2): some reason
+## Called By (inbound)
+None
+## Sharp Edges
+| Mode | Sev | Mit |
+## Done When
+- done
+## Cost Profile
+~100 tokens
+`,
+    );
+
+    await writeFile(
+      path.join(TEST_ROOT, 'skills', 'skill-b', 'SKILL.md'),
+      `---
+name: skill-b
+metadata:
+  version: "1.0.0"
+---
+# skill-b
+## Calls (outbound)
+None
+## Called By (inbound)
+None
+## Sharp Edges
+| Mode | Sev | Mit |
+## Done When
+- done
+## Cost Profile
+~100 tokens
+`,
+    );
+
+    const results = await checkMeshIntegrity(TEST_ROOT);
+
+    assert.strictEqual(results.stats.skills, 2, 'Should find 2 skills');
+    assert.strictEqual(results.stats.missingReciprocals, 1, 'Should detect 1 missing reciprocal');
+    assert.ok(
+      results.warnings.some((w) => w.includes('skill-b') && w.includes('skill-a')),
+      'Should warn that skill-b is missing skill-a in Called By',
+    );
+  });
+
+  test('passes when reciprocals are correct', async () => {
+    await writeFile(
+      path.join(TEST_ROOT, 'skills', 'skill-a', 'SKILL.md'),
+      `---
+name: skill-a
+metadata:
+  version: "1.0.0"
+---
+# skill-a
+## Calls (outbound)
+- \`skill-b\` (L2): some reason
+## Called By (inbound)
+None
+## Sharp Edges
+| Mode | Sev | Mit |
+## Done When
+- done
+## Cost Profile
+~100 tokens
+`,
+    );
+
+    await writeFile(
+      path.join(TEST_ROOT, 'skills', 'skill-b', 'SKILL.md'),
+      `---
+name: skill-b
+metadata:
+  version: "1.0.0"
+---
+# skill-b
+## Calls (outbound)
+None
+## Called By (inbound)
+- \`skill-a\` (L2): caller
+## Sharp Edges
+| Mode | Sev | Mit |
+## Done When
+- done
+## Cost Profile
+~100 tokens
+`,
+    );
+
+    const results = await checkMeshIntegrity(TEST_ROOT);
+
+    assert.strictEqual(results.stats.missingReciprocals, 0, 'Should have no missing reciprocals');
+    assert.strictEqual(
+      results.checks.find((c) => c.name === 'Reciprocal connections')?.status,
+      'pass',
+      'Reciprocal check should pass',
+    );
+  });
+
+  test('suggests version bump for mature skills', async () => {
+    await writeFile(
+      path.join(TEST_ROOT, 'skills', 'skill-a', 'SKILL.md'),
+      `---
+name: skill-a
+metadata:
+  version: "0.9.0"
+---
+# skill-a
+## Calls (outbound)
+None
+## Called By (inbound)
+None
+## Sharp Edges
+| Mode | Sev | Mit |
+## Done When
+- done
+## Cost Profile
+~100 tokens
+## Returns
+| Artifact | Format | Location |
+`,
+    );
+
+    const results = await checkMeshIntegrity(TEST_ROOT);
+
+    assert.ok(
+      results.warnings.some((w) => w.includes('skill-a') && w.includes('1.0')),
+      'Should suggest promoting to 1.0',
+    );
+  });
+
+  test('detects missing required sections', async () => {
+    await writeFile(
+      path.join(TEST_ROOT, 'skills', 'skill-a', 'SKILL.md'),
+      `---
+name: skill-a
+metadata:
+  version: "1.0.0"
+---
+# skill-a
+## Calls (outbound)
+None
+## Called By (inbound)
+None
+`,
+    );
+
+    const results = await checkMeshIntegrity(TEST_ROOT);
+
+    assert.ok(
+      results.warnings.some((w) => w.includes('skill-a') && w.includes('Sharp Edges')),
+      'Should warn about missing Sharp Edges',
+    );
+    assert.ok(
+      results.warnings.some((w) => w.includes('skill-a') && w.includes('Done When')),
+      'Should warn about missing Done When',
+    );
+  });
+});
+
+describe('formatMeshResults', () => {
+  test('formats results for console output', () => {
+    const results = {
+      checks: [
+        { name: 'Reciprocal connections', status: 'pass' },
+        { name: 'Version maturity', status: 'warn', detail: '2 skills ready for 1.0' },
+      ],
+      warnings: ['skill-a v0.9.0: consider promoting to 1.0'],
+      errors: [],
+      stats: { skills: 10, connections: 50, missingReciprocals: 0 },
+    };
+
+    const output = formatMeshResults(results);
+
+    assert.ok(output.includes('Skills: 10'), 'Should show skill count');
+    assert.ok(output.includes('Connections: 50'), 'Should show connection count');
+    assert.ok(output.includes('[✓] Reciprocal'), 'Should show pass icon');
+    assert.ok(output.includes('[!] Version'), 'Should show warn icon');
+    assert.ok(output.includes('skill-a v0.9.0'), 'Should include warnings');
+  });
+});
+
+describe('integration: real skills', () => {
+  test('runs mesh check on actual Rune skills directory', async () => {
+    const runeRoot = path.resolve(__dirname, '../..');
+    const results = await checkMeshIntegrity(runeRoot);
+
+    // Should find skills
+    assert.ok(results.stats.skills > 50, `Should find 50+ skills, got ${results.stats.skills}`);
+
+    // Should find connections
+    assert.ok(results.stats.connections > 100, `Should find 100+ connections, got ${results.stats.connections}`);
+
+    // Should not have errors
+    assert.strictEqual(results.errors.length, 0, `Should have no errors: ${results.errors.join(', ')}`);
+  });
+});

package/compiler/__tests__/hook-dispatch.test.js

@@ -0,0 +1,91 @@
+import assert from 'node:assert';
+import { PassThrough } from 'node:stream';
+import { describe, test } from 'node:test';
+import { dispatchHook } from '../commands/hook-dispatch.js';
+
+function makeIO({ stdinData = '' } = {}) {
+  const stdin = new PassThrough();
+  stdin.setEncoding = () => {};
+  stdin.isTTY = false;
+  if (stdinData) {
+    stdin.write(stdinData);
+  }
+  stdin.end();
+
+  const stdout = new PassThrough();
+  const stderr = new PassThrough();
+  let out = '';
+  let err = '';
+  stdout.on('data', (chunk) => {
+    out += chunk.toString();
+  });
+  stderr.on('data', (chunk) => {
+    err += chunk.toString();
+  });
+  return { stdin, stdout, stderr, getOut: () => out, getErr: () => err };
+}
+
+describe('dispatchHook', () => {
+  test('unknown skill exits 1 in strict mode', async () => {
+    const io = makeIO();
+    const code = await dispatchHook(['evil-skill'], io);
+    assert.strictEqual(code, 1);
+    assert.match(io.getErr(), /unknown skill/);
+  });
+
+  test('unknown skill exits 0 in gentle mode', async () => {
+    const io = makeIO();
+    const code = await dispatchHook(['evil-skill', '--gentle'], io);
+    assert.strictEqual(code, 0);
+    assert.match(io.getErr(), /unknown skill/);
+  });
+
+  test('missing skill name errors', async () => {
+    const io = makeIO();
+    const code = await dispatchHook([], io);
+    assert.strictEqual(code, 1);
+    assert.match(io.getErr(), /missing skill/);
+  });
+
+  test('known skill succeeds and emits advisory line', async () => {
+    const io = makeIO({ stdinData: JSON.stringify({ tool_name: 'Edit' }) });
+    const code = await dispatchHook(['preflight', '--gentle'], io);
+    assert.strictEqual(code, 0);
+    assert.match(io.getOut(), /rune-hook: preflight/);
+    assert.match(io.getOut(), /advisory/);
+    assert.match(io.getOut(), /Edit/);
+  });
+
+  test('strict mode prints enforcing label', async () => {
+    const io = makeIO({ stdinData: '{}' });
+    const code = await dispatchHook(['sentinel'], io);
+    assert.strictEqual(code, 0);
+    assert.match(io.getOut(), /enforcing/);
+  });
+
+  test('malformed stdin does not crash', async () => {
+    const io = makeIO({ stdinData: 'not json at all' });
+    const code = await dispatchHook(['completion-gate', '--gentle'], io);
+    assert.strictEqual(code, 0);
+  });
+
+  // T5: invalid skill name (not in allowlist) → exits non-zero, stderr contains rejected name
+  test('T5: skill not in allowlist exits 1 in strict mode with name in stderr', async () => {
+    const io = makeIO();
+    const code = await dispatchHook(['totally-fake-skill'], io);
+    assert.strictEqual(code, 1);
+    assert.ok(io.getErr().includes('totally-fake-skill'), 'stderr must contain the rejected skill name');
+  });
+
+  // T6: stdin larger than 1MB → truncates or errors gracefully (no OOM)
+  test('T6: stdin larger than 1MB is rejected gracefully', async () => {
+    // Build a payload just over the 1MB limit
+    const big = 'x'.repeat(1_100_000);
+    const io = makeIO({ stdinData: big });
+    // Should not throw — must return an exit code (0 or 1, gentle or strict)
+    const code = await dispatchHook(['preflight', '--gentle'], io);
+    assert.ok(typeof code === 'number', 'must return a numeric exit code');
+    // gentle mode: still exits 0 even if stdin was discarded
+    assert.strictEqual(code, 0);
+  });
+});

package/compiler/__tests__/hooks-antigravity.test.js

@@ -0,0 +1,118 @@
+import assert from 'node:assert';
+import { existsSync } from 'node:fs';
+import { mkdir, mkdtemp, readdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, test } from 'node:test';
+import * as antigravity from '../adapters/hooks/antigravity.js';
+import { installHooks } from '../commands/hooks/install.js';
+import { hookStatus } from '../commands/hooks/status.js';
+import { uninstallHooks } from '../commands/hooks/uninstall.js';
+
+const RUNE_ROOT = path.resolve(import.meta.dirname, '..', '..');
+const RULES_DIR = '.antigravity/rules';
+
+let tmpRoot;
+
+async function seedAntigravity(root) {
+  await mkdir(path.join(root, '.antigravity'), { recursive: true });
+}
+
+beforeEach(async () => {
+  tmpRoot = await mkdtemp(path.join(tmpdir(), 'rune-antigravity-'));
+});
+
+afterEach(async () => {
+  if (tmpRoot) await rm(tmpRoot, { recursive: true, force: true });
+});
+
+describe('antigravity adapter', () => {
+  test('detect() true when .antigravity exists', async () => {
+    await seedAntigravity(tmpRoot);
+    assert.strictEqual(antigravity.detect(tmpRoot), true);
+  });
+
+  test('emit(gentle) returns 3 rule markdowns with WARN mode', async () => {
+    const plan = await antigravity.emit({ preset: 'gentle', projectRoot: tmpRoot });
+    assert.strictEqual(plan.files.length, 3);
+    for (const file of plan.files) {
+      assert.ok(file.content.includes('rune-managed: true'));
+      assert.ok(file.content.includes('mode: WARN'));
+    }
+  });
+
+  test('emit(strict) renders BLOCK mode', async () => {
+    const plan = await antigravity.emit({ preset: 'strict', projectRoot: tmpRoot });
+    for (const file of plan.files) {
+      assert.ok(file.content.includes('mode: BLOCK'));
+    }
+  });
+
+  test('emit() rejects invalid preset', async () => {
+    await assert.rejects(antigravity.emit({ preset: 'weird', projectRoot: tmpRoot }), /invalid preset/);
+  });
+
+  test('emit() notes call out experimental status', async () => {
+    const plan = await antigravity.emit({ preset: 'gentle', projectRoot: tmpRoot });
+    assert.ok(plan.notes.some((n) => n.toLowerCase().includes('experimental')));
+  });
+
+  test('install writes rule files under .antigravity/rules/', async () => {
+    await seedAntigravity(tmpRoot);
+    const result = await installHooks(tmpRoot, { preset: 'gentle', platform: 'antigravity' });
+    assert.strictEqual(result.written, true);
+    const files = await readdir(path.join(tmpRoot, RULES_DIR));
+    assert.ok(files.includes('rune-preflight.md'));
+    assert.ok(files.includes('rune-sentinel.md'));
+    assert.ok(files.includes('rune-dependency-doctor.md'));
+  });
+
+  test('idempotent re-install', async () => {
+    await seedAntigravity(tmpRoot);
+    await installHooks(tmpRoot, { preset: 'gentle', platform: 'antigravity' });
+    const first = await readFile(path.join(tmpRoot, RULES_DIR, 'rune-preflight.md'), 'utf-8');
+    await installHooks(tmpRoot, { preset: 'gentle', platform: 'antigravity' });
+    const second = await readFile(path.join(tmpRoot, RULES_DIR, 'rune-preflight.md'), 'utf-8');
+    assert.strictEqual(first, second);
+  });
+
+  test('uninstall removes Rune rules, preserves user rules', async () => {
+    await seedAntigravity(tmpRoot);
+    const rulesDir = path.join(tmpRoot, RULES_DIR);
+    await mkdir(rulesDir, { recursive: true });
+    await writeFile(path.join(rulesDir, 'user-rule.md'), '# User rule\n', 'utf-8');
+
+    await installHooks(tmpRoot, { preset: 'gentle', platform: 'antigravity' });
+    await uninstallHooks(tmpRoot, { platform: 'antigravity' });
+
+    const remaining = await readdir(rulesDir);
+    assert.ok(remaining.includes('user-rule.md'), 'user rule must survive');
+    assert.ok(!remaining.some((f) => f.startsWith('rune-')), 'no rune-* files should remain');
+  });
+
+  test('uninstall leaves non-managed rune-* files alone', async () => {
+    await seedAntigravity(tmpRoot);
+    const rulesDir = path.join(tmpRoot, RULES_DIR);
+    await mkdir(rulesDir, { recursive: true });
+    await writeFile(path.join(rulesDir, 'rune-fake.md'), '---\ndescription: imposter\n---\n\nnot ours\n', 'utf-8');
+
+    await uninstallHooks(tmpRoot, { platform: 'antigravity' });
+    assert.ok(existsSync(path.join(rulesDir, 'rune-fake.md')));
+  });
+
+  test('status after install reports wired skills', async () => {
+    await seedAntigravity(tmpRoot);
+    await installHooks(tmpRoot, { preset: 'strict', platform: 'antigravity' });
+    const result = await hookStatus(tmpRoot, RUNE_ROOT, { platform: 'antigravity' });
+    const r = result.results.find((x) => x.platform === 'antigravity');
+    assert.strictEqual(r.installed, true);
+    assert.strictEqual(r.preset, 'strict');
+    assert.ok(r.wired.includes('preflight'));
+  });
+
+  test('status reports not installed when .antigravity missing', async () => {
+    const result = await hookStatus(tmpRoot, RUNE_ROOT, { platform: 'antigravity' });
+    const r = result.results.find((x) => x.platform === 'antigravity');
+    assert.strictEqual(r.installed, false);
+  });
+});

package/compiler/__tests__/hooks-cursor.test.js

@@ -0,0 +1,139 @@
+import assert from 'node:assert';
+import { existsSync } from 'node:fs';
+import { mkdir, mkdtemp, readdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, test } from 'node:test';
+import * as cursor from '../adapters/hooks/cursor.js';
+import { installHooks } from '../commands/hooks/install.js';
+import { hookStatus } from '../commands/hooks/status.js';
+import { uninstallHooks } from '../commands/hooks/uninstall.js';
+
+const RUNE_ROOT = path.resolve(import.meta.dirname, '..', '..');
+const RULES_DIR = '.cursor/rules';
+
+let tmpRoot;
+
+async function seedCursor(root) {
+  await mkdir(path.join(root, '.cursor'), { recursive: true });
+}
+
+beforeEach(async () => {
+  tmpRoot = await mkdtemp(path.join(tmpdir(), 'rune-cursor-'));
+});
+
+afterEach(async () => {
+  if (tmpRoot) await rm(tmpRoot, { recursive: true, force: true });
+});
+
+describe('cursor adapter', () => {
+  test('detect() true when .cursor exists', async () => {
+    await seedCursor(tmpRoot);
+    assert.strictEqual(cursor.detect(tmpRoot), true);
+  });
+
+  test('detect() false when .cursor missing', () => {
+    assert.strictEqual(cursor.detect(tmpRoot), false);
+  });
+
+  test('emit(gentle) returns 3 .mdc rule files', async () => {
+    const plan = await cursor.emit({ preset: 'gentle', projectRoot: tmpRoot });
+    assert.strictEqual(plan.files.length, 3);
+    const names = plan.files.map((f) => path.basename(f.path)).sort();
+    assert.deepStrictEqual(names, ['rune-dependency-doctor.mdc', 'rune-preflight.mdc', 'rune-sentinel.mdc']);
+    for (const file of plan.files) {
+      assert.ok(file.content.includes('rune-managed: true'));
+      assert.ok(file.content.includes('@rune-kit/rune hook-dispatch'));
+    }
+  });
+
+  test('emit(strict) renders WARN → BLOCK guidance', async () => {
+    const gentle = await cursor.emit({ preset: 'gentle', projectRoot: tmpRoot });
+    const strict = await cursor.emit({ preset: 'strict', projectRoot: tmpRoot });
+    const gentlePreflight = gentle.files.find((f) => f.path.endsWith('rune-preflight.mdc')).content;
+    const strictPreflight = strict.files.find((f) => f.path.endsWith('rune-preflight.mdc')).content;
+    assert.ok(gentlePreflight.includes('WARN'));
+    assert.ok(strictPreflight.includes('BLOCK'));
+  });
+
+  test('emit(off) delegates to uninstall', async () => {
+    await seedCursor(tmpRoot);
+    await installHooks(tmpRoot, { preset: 'gentle', platform: 'cursor' });
+    const plan = await cursor.emit({ preset: 'off', projectRoot: tmpRoot });
+    assert.ok(plan.files.every((f) => f.content === null));
+    assert.ok(plan.files.length >= 1);
+  });
+
+  test('emit() rejects invalid preset', async () => {
+    await assert.rejects(cursor.emit({ preset: 'loose', projectRoot: tmpRoot }), /invalid preset/);
+  });
+
+  test('install writes .mdc files to .cursor/rules/', async () => {
+    await seedCursor(tmpRoot);
+    const result = await installHooks(tmpRoot, { preset: 'gentle', platform: 'cursor' });
+    assert.strictEqual(result.written, true);
+    const rulesDir = path.join(tmpRoot, RULES_DIR);
+    const files = await readdir(rulesDir);
+    assert.ok(files.includes('rune-preflight.mdc'));
+    assert.ok(files.includes('rune-sentinel.mdc'));
+    assert.ok(files.includes('rune-dependency-doctor.mdc'));
+  });
+
+  test('idempotent re-install produces identical content', async () => {
+    await seedCursor(tmpRoot);
+    await installHooks(tmpRoot, { preset: 'gentle', platform: 'cursor' });
+    const rulesDir = path.join(tmpRoot, RULES_DIR);
+    const first = await readFile(path.join(rulesDir, 'rune-preflight.mdc'), 'utf-8');
+    await installHooks(tmpRoot, { preset: 'gentle', platform: 'cursor' });
+    const second = await readFile(path.join(rulesDir, 'rune-preflight.mdc'), 'utf-8');
+    assert.strictEqual(first, second);
+  });
+
+  test('uninstall removes only Rune-managed .mdc files', async () => {
+    await seedCursor(tmpRoot);
+    const rulesDir = path.join(tmpRoot, RULES_DIR);
+    await mkdir(rulesDir, { recursive: true });
+    await writeFile(path.join(rulesDir, 'user-custom.mdc'), '---\ndescription: user\n---\n\n# User rule\n', 'utf-8');
+
+    await installHooks(tmpRoot, { preset: 'gentle', platform: 'cursor' });
+    await uninstallHooks(tmpRoot, { platform: 'cursor' });
+
+    const remaining = await readdir(rulesDir);
+    assert.ok(remaining.includes('user-custom.mdc'), 'user rule must survive');
+    assert.ok(!remaining.some((f) => f.startsWith('rune-')), 'no rune-* files should remain');
+  });
+
+  test('uninstall skips files without rune-managed signature', async () => {
+    await seedCursor(tmpRoot);
+    const rulesDir = path.join(tmpRoot, RULES_DIR);
+    await mkdir(rulesDir, { recursive: true });
+    // A file that happens to start with "rune-" but is NOT managed by Rune
+    await writeFile(
+      path.join(rulesDir, 'rune-fake.mdc'),
+      '---\ndescription: user imposter\n---\n\nnot ours\n',
+      'utf-8',
+    );
+
+    await uninstallHooks(tmpRoot, { platform: 'cursor' });
+    assert.ok(existsSync(path.join(rulesDir, 'rune-fake.mdc')), 'non-managed rune-* file must survive');
+  });
+
+  test('status reports installed preset after install', async () => {
+    await seedCursor(tmpRoot);
+    await installHooks(tmpRoot, { preset: 'strict', platform: 'cursor' });
+    const result = await hookStatus(tmpRoot, RUNE_ROOT, { platform: 'cursor' });
+    const r = result.results.find((x) => x.platform === 'cursor');
+    assert.strictEqual(r.installed, true);
+    assert.strictEqual(r.preset, 'strict');
+    assert.ok(r.wired.includes('preflight'));
+    assert.ok(r.wired.includes('sentinel'));
+    assert.ok(r.wired.includes('dependency-doctor'));
+  });
+
+  test('status reports not installed when .cursor missing', async () => {
+    const result = await hookStatus(tmpRoot, RUNE_ROOT, { platform: 'cursor' });
+    const r = result.results.find((x) => x.platform === 'cursor');
+    assert.strictEqual(r.installed, false);
+    assert.ok(r.missing.includes('preflight'));
+  });
+});