@polderlabs/bizar 6.3.0 → 7.0.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 });
+  });
+});

package/config/trigger-patterns.json

@@ -0,0 +1,186 @@
+{
+  "$schema": "./trigger-patterns.v1.schema.json",
+  "version": 1,
+  "description": "Trigger-pattern table for the Bizar Background Workers dispatcher. Each worker maps zero-or-more regex patterns to a Bizar skill and/or agent. The dispatcher in cli/worker-dispatcher.mjs reads this file, matches user prompts against the regex arrays (case-insensitive), and emits 0..N suggestions ranked by weight.",
+  "workers": [
+    {
+      "id": "testgaps",
+      "regex": [
+        "missing tests",
+        "low coverage",
+        "no tests for",
+        "tests? for .+ that",
+        "test gaps?",
+        "test coverage",
+        "coverage report",
+        "add tests"
+      ],
+      "weight": 0.8,
+      "skill": "harness-engineering",
+      "agent": "forseti",
+      "description": "Identify test coverage gaps and untested code paths."
+    },
+    {
+      "id": "audit",
+      "regex": [
+        "security scan",
+        "security audit",
+        "vulnerab",
+        "cve",
+        "owasp",
+        "pentest"
+      ],
+      "weight": 0.9,
+      "skill": "harness-engineering",
+      "agent": "forseti",
+      "description": "Security analysis and vulnerability scanning."
+    },
+    {
+      "id": "deepdive",
+      "regex": [
+        "deep dive into",
+        "deep dive",
+        "explain .{20,}",
+        "how does .+ work",
+        "walk me through",
+        "in-depth analysis",
+        "comprehensive review"
+      ],
+      "weight": 0.7,
+      "skill": null,
+      "agent": "mimir",
+      "description": "Deep code analysis and thorough explanation."
+    },
+    {
+      "id": "refactor",
+      "regex": [
+        "refactor",
+        "clean up .{1,30}",
+        "simplify",
+        "restructure",
+        "improve code quality",
+        "make .+ more readable"
+      ],
+      "weight": 0.7,
+      "skill": null,
+      "agent": "thor",
+      "description": "Code refactoring suggestions and structural cleanup."
+    },
+    {
+      "id": "document",
+      "regex": [
+        "write docs",
+        "write readme",
+        "add jsdoc",
+        "document .{1,40}",
+        "api docs",
+        "generate docs",
+        "add documentation"
+      ],
+      "weight": 0.6,
+      "skill": null,
+      "agent": "baldr",
+      "description": "Auto-documentation generation (README, JSDoc, API docs)."
+    },
+    {
+      "id": "optimize",
+      "regex": [
+        "optimize .{1,40} for",
+        "performance issue",
+        "make .+ faster",
+        "speed up",
+        "reduce .{1,20}(memory|time)",
+        "improve performance"
+      ],
+      "weight": 0.7,
+      "skill": null,
+      "agent": "thor",
+      "description": "Performance optimization and tuning."
+    },
+    {
+      "id": "ultralearn",
+      "regex": [
+        "learn about",
+        "understand how",
+        "understand what",
+        "understand why",
+        "comprehensive guide",
+        "master .+"
+      ],
+      "weight": 0.65,
+      "skill": "harness-engineering",
+      "agent": "mimir",
+      "description": "Deep knowledge acquisition and learning."
+    },
+    {
+      "id": "consolidate",
+      "regex": [
+        "consolidate",
+        "merge memories",
+        "clean up memory",
+        "deduplicate",
+        "memory maintenance"
+      ],
+      "weight": 0.5,
+      "skill": "harness-engineering",
+      "agent": null,
+      "description": "Memory consolidation and cleanup."
+    },
+    {
+      "id": "predict",
+      "regex": [
+        "what will happen",
+        "predict",
+        "forecast",
+        "anticipate",
+        "prepare for"
+      ],
+      "weight": 0.55,
+      "skill": null,
+      "agent": "mimir",
+      "description": "Predictive preloading and anticipation."
+    },
+    {
+      "id": "map",
+      "regex": [
+        "map .{0,5}codebase",
+        "architecture overview",
+        "project structure",
+        "dependency graph",
+        "code map",
+        "explore codebase"
+      ],
+      "weight": 0.6,
+      "skill": "harness-engineering",
+      "agent": "mimir",
+      "description": "Codebase mapping and architecture analysis."
+    },
+    {
+      "id": "preload",
+      "regex": [
+        "preload",
+        "cache ahead",
+        "prefetch",
+        "warm .+ cache"
+      ],
+      "weight": 0.4,
+      "skill": null,
+      "agent": null,
+      "description": "Resource preloading and cache warming."
+    },
+    {
+      "id": "benchmark",
+      "regex": [
+        "benchmark",
+        "performance test",
+        "measure speed",
+        "stress test",
+        "load test"
+      ],
+      "weight": 0.65,
+      "skill": null,
+      "agent": "thor",
+      "description": "Performance benchmarking."
+    }
+  ]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polderlabs/bizar",
-  "version": "6.3.0",
+  "version": "7.0.0",
   "description": "Norse-pantheon multi-agent system for Claude Code — 14 agents across 4 cost tiers with cost-aware routing, plans, and a configurable agent harness. Ships as a single npm package with the dashboard server, Claude Code MCP server, and typed SDK.",
   "type": "module",
   "bin": {
@@ -23,7 +23,7 @@
     "test:sdk": "node_modules/.bin/vitest run --root packages/sdk",
     "test:web": "cd bizar-dash && npx vitest run",
     "test:sdk:watch": "node_modules/.bin/vitest --root packages/sdk",
-    "test": "npm run typecheck && npm run test:sdk && node --test cli/install.test.mjs cli/provision.test.mjs cli/commands/setup-provider.test.mjs cli/commands/rca.test.mjs && node --test bizar-dash/tests/path-safe.test.mjs",
+    "test": "npm run typecheck && npm run test:sdk && node --test cli/install.test.mjs cli/provision.test.mjs cli/worker-dispatcher.test.mjs cli/commands/setup-provider.test.mjs cli/commands/rca.test.mjs cli/__tests__/cost-gate.test.mjs cli/__tests__/feature-list-bridge.test.mjs && node --test bizar-dash/tests/path-safe.test.mjs",
     "build": "npm run build:sdk && npm run build:dash",
     "prepublishOnly": "npm run build"
   },

package/packages/sdk/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polderlabs/bizar-sdk",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",