@polderlabs/bizar 6.2.5 → 7.0.0

package/cli/utils.mjs

@@ -15,30 +15,56 @@ export function repoPath(...parts) {
 }
 
 /**
- * Resolve the Cline global config directory.
-*
-  * Mirrors Cline's `resolveClineDir()` in `@cline/shared/storage`:
-  *   1. `process.env.CLINE_DIR` (explicit override)
-  *   2. `$HOME/.cline` (the Cline default since v3.0)
-  *
-  * v6.1.0 — Bizar is Cline-only. The pre-v5.6 `~/.config/cline/` path
-  * (the OpenCode-era layout) is no longer supported; the previous
-  * `legacyClineConfigDir()` helper has been removed.
-  */
-export function clineConfigDir() {
-  if (process.env.CLINE_DIR && process.env.CLINE_DIR.trim()) {
-    return process.env.CLINE_DIR.trim();
+ * Resolve the Claude Code global config directory.
+ *
+ * v6.3.0 — Bizar is Claude Code-native. The legacy `~/.cline/`
+ * path is kept as a back-compat alias via the wrappers below.
+ *
+ *   1. `process.env.CLAUDE_CONFIG_DIR` (explicit override)
+ *   2. `$HOME/.claude` (Claude Code default)
+ */
+export function claudeConfigDir() {
+  if (process.env.CLAUDE_CONFIG_DIR && process.env.CLAUDE_CONFIG_DIR.trim()) {
+    return process.env.CLAUDE_CONFIG_DIR.trim();
   }
   if (isWin) {
     return process.env.APPDATA
-      ? join(process.env.APPDATA, 'cline')
-      : join(homedir(), '.cline');
+      ? join(process.env.APPDATA, 'claude')
+      : join(homedir(), '.claude');
   }
-  return join(homedir(), '.cline');
+  return join(homedir(), '.claude');
 }
 
+export function claudeAgentsDir() {
+  return join(claudeConfigDir(), 'agents');
+}
+
+export function claudeSkillsDir() {
+  return join(claudeConfigDir(), 'skills');
+}
+
+export function claudeCommandsDir() {
+  return join(claudeConfigDir(), 'commands');
+}
+
+export function claudeHooksDir() {
+  return join(claudeConfigDir(), 'hooks');
+}
+
+/**
+ * @deprecated v6.3.0 — Claude Code migration. Use `claudeConfigDir()`.
+ * Thin wrapper so older scripts that haven't been migrated keep working.
+ */
+export function clineConfigDir() {
+  return claudeConfigDir();
+}
+
+/**
+ * @deprecated v6.3.0 — Claude Code migration. Use `claudeAgentsDir()`.
+ * Thin wrapper so older scripts that haven't been migrated keep working.
+ */
 export function clineAgentsDir() {
-  return join(clineConfigDir(), 'agents');
+  return claudeAgentsDir();
 }
 
 async function tryReadVersion(filePath) {
@@ -58,53 +84,41 @@ function commandExists(command) {
   return probe.status === 0;
 }
 
+/**
+ * @deprecated v6.3.0 — Claude Code migration. Use `detectClaude()`.
+ * Probe for the legacy Cline CLI to power compat reports.
+ */
 export async function detectCline() {
-  const configDir = clineConfigDir();
-  const agentsDir = clineAgentsDir();
-
+  const configDir = claudeConfigDir();
+  const agentsDir = claudeAgentsDir();
   let exists = false;
   let version = '';
-
   try {
     await access(configDir, constants.F_OK);
     exists = true;
+  } catch {
+    exists = false;
+  }
+  return { exists, version, configDir, agentsDir };
+}
 
-    if (isWin) {
-      const winPaths = [
-        join(process.env.APPDATA || homedir(), 'npm', 'node_modules', 'cline', 'package.json'),
-        join(process.env.APPDATA || homedir(), 'npm', 'node_modules', 'cline', 'package.json'),
-        join(process.env.APPDATA || homedir(), 'npm-global', 'node_modules', 'cline', 'package.json'),
-        join(process.env.APPDATA || homedir(), 'npm-global', 'node_modules', 'cline', 'package.json'),
-        join(homedir(), 'node_modules', 'cline', 'package.json'),
-        join(homedir(), 'node_modules', 'cline', 'package.json'),
-      ];
-      for (const p of winPaths) {
-        version = await tryReadVersion(p);
-        if (version) break;
-      }
-    } else {
-      const posixPaths = [
-        join(homedir(), '.local', 'share', 'cline', 'package.json'),
-        join(homedir(), '.local', 'share', 'cline', 'package.json'),
-        '/usr/local/lib/node_modules/cline/package.json',
-        '/usr/local/lib/node_modules/cline/package.json',
-        '/usr/lib/node_modules/cline/package.json',
-        '/usr/lib/node_modules/cline/package.json',
-        join(homedir(), '.npm-global', 'lib', 'node_modules', 'cline', 'package.json'),
-        join(homedir(), '.npm-global', 'lib', 'node_modules', 'cline', 'package.json'),
-        join(homedir(), 'node_modules', 'cline', 'package.json'),
-        join(homedir(), 'node_modules', 'cline', 'package.json'),
-      ];
-      for (const p of posixPaths) {
-        version = await tryReadVersion(p);
-        if (version) break;
-      }
+/**
+ * Probe for the Claude Code CLI on PATH.
+ * Returns `{ exists, version }`. v6.3.0+ replacement for `detectCline()`.
+ */
+export async function detectClaude() {
+  let exists = false;
+  let version = '';
+  try {
+    const probe = spawnSync('claude', ['--version'], { encoding: 'utf8', timeout: 5000 });
+    if (probe.status === 0) {
+      exists = true;
+      version = (probe.stdout || probe.stderr || '').trim().split('\n')[0];
     }
   } catch {
     exists = false;
   }
-
-  return { exists, version, configDir, agentsDir };
+  return { exists, version, configDir: claudeConfigDir(), agentsDir: claudeAgentsDir() };
 }
 
 export async function detectHeadroom() {
@@ -133,7 +147,7 @@ export async function detectSkillsCli() {
 }
 
 export async function detectInstalledAgents() {
-  const agentsDir = clineAgentsDir();
+  const agentsDir = claudeAgentsDir();
   try {
     await access(agentsDir, constants.F_OK);
     return agentsDir;
@@ -148,9 +162,9 @@ export function buildSummary(components, agents, target, skillPacks = []) {
   if (components.includes('agents-md')) parts.push('AGENTS.md');
   if (components.includes('skill-bizar')) parts.push('bizar skill');
   if (components.includes('skill-improve')) parts.push('self-improvement skill');
-  if (components.includes('cline-json')) parts.push('cline.json');
+  if (components.includes('settings-json')) parts.push('settings.json');
   if (components.includes('bizar')) parts.push('.bizar/ folder');
-  if (components.includes('plugin-bizar')) parts.push('Bizar plugin');
+  if (components.includes('mcp-bizar')) parts.push('Bizar MCP server');
   if (components.includes('rules')) parts.push('rules');
   if (components.includes('hooks')) parts.push('hooks');
   if (components.includes('commands')) parts.push('commands');
@@ -167,7 +181,7 @@ export function buildSummary(components, agents, target, skillPacks = []) {
   };
 }
 
-// ── Path helpers ─────────────────────────────────────────────────────────────────
+// Path helpers
 
 /**
  * Return the platform-specific Bizar config directory.
@@ -204,4 +218,4 @@ export function whichPath(cmd) {
   } catch {
     return null;
   }
-}
+}

package/cli/worker-dispatcher.mjs

@@ -0,0 +1,259 @@
+#!/usr/bin/env node
+/**
+ * cli/worker-dispatcher.mjs
+ *
+ * Bizar Background Workers — trigger-pattern dispatcher.
+ *
+ * Reads `config/trigger-patterns.json` (cached for the lifetime of the
+ * process) and matches user prompts against each worker's `regex` array.
+ * Returns up to `opts.maxSuggestions` (default 3) weighted matches, sorted
+ * by weight desc.
+ *
+ * The hook at `.claude/hooks/worker-suggest.mjs` calls `dispatch()` on
+ * every `UserPromptSubmit` event. Pure JS, no external deps; safe to
+ * import from either Node or Bun.
+ *
+ * Public API
+ * ──────────
+ *   dispatch(text, { maxSuggestions }?) -> Array<{
+ *     workerId: string,
+ *     weight: number,
+ *     skill: string | null,
+ *     agent: string | null,
+ *     description: string | undefined,
+ *     matchedPattern: string,        // the literal regex string that hit
+ *     matchedIndex: number           // the prompt char-offset of the match
+ *   }>
+ *
+ *   listWorkers() -> string[]        // all worker ids (even with no regex)
+ *
+ *   resetCache() -> void             // force re-read of the JSON on next dispatch
+ *
+ *   loadPatterns({ configPath? }?) -> object   // explicit loader for tests
+ *
+ * Honesty note: ruflo's equivalent worker bodies are stubs
+ * (`await new Promise(r => setTimeout(r, …))`); this port is just a
+ * dispatcher — actual work happens in Bizar skills/agents invoked
+ * separately by the model.
+ */
+'use strict';
+
+import { readFileSync, existsSync } from 'node:fs';
+import { dirname, resolve, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+// ── Config path resolution ──────────────────────────────────────────────────
+
+/**
+ * Locate `config/trigger-patterns.json`. Resolution order:
+ *   1. opts.configPath (explicit, used by tests)
+ *   2. BIZAR_TRIGGER_PATTERNS env var
+ *   3. <projectRoot>/config/trigger-patterns.json   (projectRoot = parent of cli/)
+ */
+export function defaultConfigPath() {
+  if (process.env.BIZAR_TRIGGER_PATTERNS) {
+    return process.env.BIZAR_TRIGGER_PATTERNS;
+  }
+  const projectRoot = resolve(__dirname, '..');
+  return join(projectRoot, 'config', 'trigger-patterns.json');
+}
+
+// ── Cached patterns + pre-compiled regexes ──────────────────────────────────
+
+/** @type {Array<CompiledWorker> | null} */
+let _cache = null;
+/** @type {string | null} */
+let _cachePath = null;
+
+/**
+ * @typedef CompiledWorker
+ * @property {string} id
+ * @property {number} weight
+ * @property {string|null} skill
+ * @property {string|null} agent
+ * @property {string|undefined} description
+ * @property {Array<{ pattern: string, regex: RegExp }>} compiled
+ */
+
+/**
+ * Load + compile the patterns file. Cached on first call.
+ * @param {{ configPath?: string }=} opts
+ * @returns {Array<CompiledWorker>}
+ */
+export function loadPatterns(opts = {}) {
+  const path = opts.configPath || defaultConfigPath();
+  if (_cache && _cachePath === path) return _cache;
+
+  if (!existsSync(path)) {
+    // Empty dispatcher — no patterns means no suggestions, but the API
+    // remains available (so a missing config never throws at the hook).
+    _cache = [];
+    _cachePath = path;
+    return _cache;
+  }
+
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync(path, 'utf8'));
+  } catch (err) {
+    // Invalid JSON is a config bug, not a runtime bug — log + fall back
+    // to an empty dispatcher so the hook still exits 0.
+    process.stderr.write(
+      `[bizar.workers] WARN: failed to parse ${path}: ${
+        err && err.message ? err.message : String(err)
+      }\n`,
+    );
+    _cache = [];
+    _cachePath = path;
+    return _cache;
+  }
+
+  const workers = Array.isArray(raw && raw.workers) ? raw.workers : [];
+
+  /** @type {Array<CompiledWorker>} */
+  const compiled = [];
+  for (const w of workers) {
+    if (!w || typeof w.id !== 'string') continue;
+    const regexSources = Array.isArray(w.regex) ? w.regex : [];
+    /** @type {Array<{ pattern: string, regex: RegExp }>} */
+    const compiled_ = [];
+    for (const src of regexSources) {
+      if (typeof src !== 'string' || src.length === 0) continue;
+      try {
+        compiled_.push({ pattern: src, regex: new RegExp(src, 'i') });
+      } catch {
+        // Skip invalid regex sources; never throw from the hook path.
+      }
+    }
+    compiled.push({
+      id: w.id,
+      weight: typeof w.weight === 'number' ? w.weight : 0.5,
+      skill: typeof w.skill === 'string' ? w.skill : null,
+      agent: typeof w.agent === 'string' ? w.agent : null,
+      description: typeof w.description === 'string' ? w.description : undefined,
+      compiled: compiled_,
+    });
+  }
+
+  _cache = compiled;
+  _cachePath = path;
+  return _cache;
+}
+
+/** Force re-read of the patterns JSON on the next `dispatch()` call. */
+export function resetCache() {
+  _cache = null;
+  _cachePath = null;
+}
+
+// ── Public API ──────────────────────────────────────────────────────────────
+
+const DEFAULT_MAX_SUGGESTIONS = 3;
+
+/**
+ * Match a prompt against all worker patterns and return ranked suggestions.
+ *
+ * @param {string} text
+ * @param {{ maxSuggestions?: number, configPath?: string }=} opts
+ * @returns {Array<{
+ *   workerId: string,
+ *   weight: number,
+ *   skill: string|null,
+ *   agent: string|null,
+ *   description: string|undefined,
+ *   matchedPattern: string,
+ *   matchedIndex: number
+ * }>}
+ */
+export function dispatch(text, opts = {}) {
+  const out = [];
+  const source = typeof text === 'string' ? text : '';
+  if (source.length === 0) return out;
+
+  const workers = loadPatterns(
+    opts.configPath ? { configPath: opts.configPath } : {},
+  );
+  if (workers.length === 0) return out;
+
+  const max = Number.isInteger(opts.maxSuggestions)
+    ? Math.max(0, opts.maxSuggestions)
+    : DEFAULT_MAX_SUGGESTIONS;
+
+  for (const w of workers) {
+    let bestIndex = -1;
+    let bestPattern = null;
+    for (const c of w.compiled) {
+      const m = c.regex.exec(source);
+      if (m && m.index >= 0) {
+        if (bestIndex === -1 || m.index < bestIndex) {
+          bestIndex = m.index;
+          bestPattern = c.pattern;
+        }
+      }
+    }
+    if (bestPattern !== null) {
+      out.push({
+        workerId: w.id,
+        weight: w.weight,
+        skill: w.skill,
+        agent: w.agent,
+        description: w.description,
+        matchedPattern: bestPattern,
+        matchedIndex: bestIndex,
+      });
+    }
+  }
+
+  out.sort((a, b) => {
+    if (b.weight !== a.weight) return b.weight - a.weight;
+    // Tie-break deterministically by workerId so the output is stable
+    // across runs (useful for tests + logs).
+    return a.workerId.localeCompare(b.workerId);
+  });
+
+  return max === 0 ? [] : out.slice(0, max);
+}
+
+/**
+ * Return all worker ids declared in the patterns file. Workers with no
+ * regex are returned too — they simply never surface as suggestions.
+ *
+ * @param {{ configPath?: string }=} opts
+ * @returns {string[]}
+ */
+export function listWorkers(opts = {}) {
+  const workers = loadPatterns(
+    opts.configPath ? { configPath: opts.configPath } : {},
+  );
+  return workers.map((w) => w.id);
+}
+
+// Direct CLI entrypoint for dry-runs / debugging.
+//   node cli/worker-dispatcher.mjs "your prompt here" [--max N] [--list]
+if (
+  process.argv[1] &&
+  fileURLToPath(import.meta.url) === process.argv[1]
+) {
+  const argv = process.argv.slice(2);
+  const wantList = argv.includes('--list');
+  const maxIdx = argv.indexOf('--max');
+  const maxVal =
+    maxIdx >= 0 && argv[maxIdx + 1] ? Number.parseInt(argv[maxIdx + 1], 10) : undefined;
+
+  if (wantList) {
+    const ids = listWorkers();
+    process.stdout.write(JSON.stringify(ids, null, 2) + '\n');
+    process.exit(0);
+  }
+
+  // Build the prompt by dropping only `--max` and the value that follows it
+  // (and only when `--max` was actually present).
+  const prompt = argv
+    .filter((a, i) => !(maxIdx >= 0 && (i === maxIdx || i === maxIdx + 1)))
+    .join(' ');
+  const result = dispatch(prompt, { maxSuggestions: maxVal });
+  process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+  process.exit(0);
+}

package/cli/worker-dispatcher.test.mjs

@@ -0,0 +1,204 @@
+/**
+ * cli/worker-dispatcher.test.mjs
+ *
+ * F-034 Background Workers — unit tests for the trigger-pattern dispatcher.
+ * Uses Node's built-in `node:test`. No external test framework.
+ *
+ * Strategy:
+ *   - Use the real `config/trigger-patterns.json` (already on disk).
+ *   - Call `dispatch()` and `listWorkers()` exported from
+ *     `cli/worker-dispatcher.mjs`.
+ *   - 5 sample prompts → expected worker ids (the canonical F-034 dry run).
+ *   - Edge cases: empty prompt, case-insensitive matches, maxSuggestions
+ *     clipping, no-match prompt, listWorkers completeness.
+ */
+import { test, describe, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, writeFileSync, rmSync, existsSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+const dispatcherModule = await import('./worker-dispatcher.mjs');
+const { dispatch, listWorkers, resetCache, loadPatterns } = dispatcherModule;
+
+// ── Fixture: optional override path (not used by the canonical suite) ──────
+const ORIG_BIZAR = process.env.BIZAR_TRIGGER_PATTERNS;
+
+after(() => {
+  if (ORIG_BIZAR === undefined) delete process.env.BIZAR_TRIGGER_PATTERNS;
+  else process.env.BIZAR_TRIGGER_PATTERNS = ORIG_BIZAR;
+});
+
+// ── Canonical F-034 dry-run: 5 sample prompts → expected worker ids ─────────
+
+describe('dispatch() — canonical 5-prompt dry run', () => {
+  let tmpdir_created = false;
+  // Make sure cache is fresh for each run.
+  before(() => { resetCache(); });
+
+  test('"missing tests" → suggests testgaps', () => {
+    const out = dispatch('missing tests in the auth module');
+    const ids = out.map((s) => s.workerId);
+    assert.ok(ids.includes('testgaps'), `expected testgaps, got ${JSON.stringify(ids)}`);
+    assert.equal(out.find((s) => s.workerId === 'testgaps').matchedPattern, 'missing tests');
+  });
+
+  test('"deep dive into fn()" → suggests deepdive', () => {
+    const out = dispatch('deep dive into fn()');
+    const ids = out.map((s) => s.workerId);
+    assert.ok(ids.includes('deepdive'), `expected deepdive, got ${JSON.stringify(ids)}`);
+  });
+
+  test('"refactor this module" → suggests refactor', () => {
+    const out = dispatch('refactor this module');
+    const ids = out.map((s) => s.workerId);
+    assert.ok(ids.includes('refactor'), `expected refactor, got ${JSON.stringify(ids)}`);
+  });
+
+  test('"security scan the API" → suggests audit', () => {
+    const out = dispatch('security scan the API');
+    const ids = out.map((s) => s.workerId);
+    assert.ok(ids.includes('audit'), `expected audit, got ${JSON.stringify(ids)}`);
+  });
+
+  test('"optimize the build for size" → suggests optimize', () => {
+    const out = dispatch('optimize the build for size');
+    const ids = out.map((s) => s.workerId);
+    assert.ok(ids.includes('optimize'), `expected optimize, got ${JSON.stringify(ids)}`);
+  });
+});
+
+// ── Empty / no-match paths ──────────────────────────────────────────────────
+
+describe('dispatch() — edge cases', () => {
+  before(() => { resetCache(); });
+
+  test('empty prompt returns []', () => {
+    assert.deepEqual(dispatch(''), []);
+    assert.deepEqual(dispatch('   '), []);
+  });
+
+  test('no-match prompt returns []', () => {
+    assert.deepEqual(dispatch('hello world, no actionable words here'), []);
+  });
+
+  test('case-insensitive match', () => {
+    const a = dispatch('Refactor this MODULE');
+    const b = dispatch('refactor this module');
+    const aIds = a.map((s) => s.workerId).sort();
+    const bIds = b.map((s) => s.workerId).sort();
+    assert.ok(aIds.includes('refactor'), 'refactor must match even in ALLCAPS');
+    assert.deepEqual(aIds, bIds);
+  });
+
+  test('maxSuggestions: 1 clips to a single suggestion', () => {
+    // Construct a prompt that hits MANY workers (refactor + optimize +
+    // document + audit + testgaps). With maxSuggestions=1 we get exactly 1.
+    const out = dispatch(
+      'refactor this module; optimize the build for size; write docs; security scan; missing tests',
+      { maxSuggestions: 1 },
+    );
+    assert.equal(out.length, 1, 'should clip to maxSuggestions=1');
+  });
+
+  test('maxSuggestions: 0 returns []', () => {
+    const out = dispatch('missing tests', { maxSuggestions: 0 });
+    assert.deepEqual(out, []);
+  });
+
+  test('default maxSuggestions clips at 3', () => {
+    // Same long prompt as above — default should clamp at 3.
+    const out = dispatch(
+      'refactor this module; optimize the build for size; write docs; security scan; missing tests',
+    );
+    assert.equal(out.length, 3, 'default maxSuggestions must be 3');
+  });
+
+  test('output is sorted by weight desc (then workerId)', () => {
+    const out = dispatch(
+      'refactor this module; security scan; missing tests; write docs',
+    );
+    // Find weights and assert strictly non-increasing.
+    for (let i = 1; i < out.length; i++) {
+      assert.ok(
+        out[i - 1].weight >= out[i].weight,
+        `weights must be non-increasing (${out[i - 1].workerId}=${out[i - 1].weight} < ${out[i].workerId}=${out[i].weight})`,
+      );
+    }
+  });
+
+  test('every suggestion exposes skill + agent + matchedPattern', () => {
+    const out = dispatch('missing tests');
+    for (const s of out) {
+      assert.equal(typeof s.workerId, 'string');
+      assert.equal(typeof s.weight, 'number');
+      assert.ok(s.skill === null || typeof s.skill === 'string');
+      assert.ok(s.agent === null || typeof s.agent === 'string');
+      assert.equal(typeof s.matchedPattern, 'string');
+      assert.ok(s.matchedPattern.length > 0);
+    }
+  });
+});
+
+// ── listWorkers / loadPatterns ───────────────────────────────────────────────
+
+describe('listWorkers()', () => {
+  before(() => { resetCache(); });
+
+  test('returns the full worker set (all 12)', () => {
+    const ids = listWorkers();
+    const expected = [
+      'testgaps', 'audit', 'deepdive', 'refactor', 'document', 'optimize',
+      'ultralearn', 'consolidate', 'predict', 'map', 'preload', 'benchmark',
+    ];
+    for (const id of expected) {
+      assert.ok(ids.includes(id), `expected worker ${id} in ${JSON.stringify(ids)}`);
+    }
+    assert.equal(ids.length, expected.length, `worker count must be exactly ${expected.length}`);
+  });
+});
+
+describe('loadPatterns()', () => {
+  before(() => { resetCache(); });
+
+  test('caches on second call (same instance)', () => {
+    const a = loadPatterns();
+    const b = loadPatterns();
+    assert.equal(a, b, 'second call must return cached array');
+  });
+
+  test('resetCache() forces a fresh load', () => {
+    const a = loadPatterns();
+    resetCache();
+    const b = loadPatterns();
+    assert.notEqual(a, b, 'after resetCache the new array must be a fresh object');
+  });
+
+  test('missing configPath yields empty dispatcher (no throw)', () => {
+    resetCache();
+    const tmp = mkdtempSync(join(tmpdir(), 'bizar-workers-'));
+    const phantom = join(tmp, 'does-not-exist.json');
+    const out = dispatch('missing tests', { configPath: phantom });
+    assert.deepEqual(out, []);
+    // Restore default config by clearing the override.
+    delete process.env.BIZAR_TRIGGER_PATTERNS;
+    resetCache();
+    // Sanity: the real config still works.
+    assert.ok(dispatch('missing tests').length > 0);
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  test('malformed JSON yields empty dispatcher (no throw)', () => {
+    resetCache();
+    const tmp = mkdtempSync(join(tmpdir(), 'bizar-workers-'));
+    const broken = join(tmp, 'broken.json');
+    writeFileSync(broken, '{not valid json');
+    const out = dispatch('missing tests', { configPath: broken });
+    assert.deepEqual(out, []);
+    resetCache();
+    rmSync(tmp, { recursive: true, force: true });
+  });
+});