ultra-builder-pro-cli 0.5.0

package/orchestrator/tests/code-graph-watcher.test.cjs

@@ -0,0 +1,183 @@
+'use strict';
+
+// Phase 6.4 — code-graph watcher:
+//   • fs-watch project code paths, debounce bursts, deliver batches via
+//     onBatch callback. The watcher itself does not talk to the external
+//     code-review-graph MCP server — that glue lives in callers (daemon /
+//     CLI / smoke scripts) so the watcher stays testable with just an
+//     onBatch spy.
+
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const watcher = require('../code-graph-watcher.cjs');
+
+function mkTree(layout = {}) {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-watch-'));
+  for (const [rel, content] of Object.entries(layout)) {
+    const file = path.join(root, rel);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, content);
+  }
+  return root;
+}
+
+function cleanupTree(root) {
+  try { fs.rmSync(root, { recursive: true, force: true }); } catch (_) { /* ignore */ }
+}
+
+function waitForBatches(batches, count, timeoutMs = 1500) {
+  return new Promise((resolve, reject) => {
+    const start = Date.now();
+    const timer = setInterval(() => {
+      if (batches.length >= count) { clearInterval(timer); resolve(); return; }
+      if (Date.now() - start > timeoutMs) { clearInterval(timer); reject(new Error(`timed out waiting for ${count} batches, got ${batches.length}`)); }
+    }, 20);
+  });
+}
+
+async function waitStable(handle) {
+  // Block on chokidar's 'ready' so initial add events from pre-existing
+  // files don't leak into test assertions.
+  await handle.ready();
+}
+
+test('touch a watched file → onBatch fires with that path after debounce', async () => {
+  const root = mkTree({ 'src/a.js': '// initial\n' });
+  const batches = [];
+  const handle = watcher.startWatcher({
+    repoRoot: root,
+    debounceMs: 80,
+    onBatch: (b) => batches.push(b),
+  });
+  try {
+    await waitStable(handle);
+    fs.writeFileSync(path.join(root, 'src/a.js'), '// changed\n');
+    await waitForBatches(batches, 1);
+    assert.equal(batches.length, 1);
+    assert.ok(batches[0].changes.some((c) => c.path.endsWith('src/a.js')));
+  } finally {
+    handle.stop();
+    cleanupTree(root);
+  }
+});
+
+test('debounce merges bursts: 3 writes within window → 1 batch', async () => {
+  const root = mkTree({ 'src/a.js': '0', 'src/b.js': '0', 'src/c.js': '0' });
+  const batches = [];
+  const handle = watcher.startWatcher({
+    repoRoot: root,
+    debounceMs: 100,
+    onBatch: (b) => batches.push(b),
+  });
+  try {
+    await waitStable(handle);
+    fs.writeFileSync(path.join(root, 'src/a.js'), '1');
+    fs.writeFileSync(path.join(root, 'src/b.js'), '1');
+    fs.writeFileSync(path.join(root, 'src/c.js'), '1');
+    await waitForBatches(batches, 1);
+    // Give a bit extra time in case a 2nd batch is coming (it shouldn't).
+    await new Promise((r) => setTimeout(r, 150));
+    assert.equal(batches.length, 1, `expected 1 merged batch, got ${batches.length}`);
+    const paths = new Set(batches[0].changes.map((c) => path.basename(c.path)));
+    assert.ok(paths.has('a.js') && paths.has('b.js') && paths.has('c.js'));
+  } finally {
+    handle.stop();
+    cleanupTree(root);
+  }
+});
+
+test('excludePaths: node_modules changes are ignored', async () => {
+  const root = mkTree({
+    'src/a.js': '0',
+    'node_modules/lib/x.js': '0',
+  });
+  const batches = [];
+  const handle = watcher.startWatcher({
+    repoRoot: root,
+    debounceMs: 80,
+    onBatch: (b) => batches.push(b),
+  });
+  try {
+    await waitStable(handle);
+    fs.writeFileSync(path.join(root, 'node_modules/lib/x.js'), '1');
+    await new Promise((r) => setTimeout(r, 200));
+    // If only node_modules was changed, no batch should fire.
+    assert.equal(batches.length, 0, 'node_modules write should be ignored');
+    // Sanity: a real source change still fires.
+    fs.writeFileSync(path.join(root, 'src/a.js'), '1');
+    await waitForBatches(batches, 1);
+    assert.equal(batches.length, 1);
+    assert.ok(batches[0].changes.every((c) => !c.path.includes('node_modules')));
+  } finally {
+    handle.stop();
+    cleanupTree(root);
+  }
+});
+
+test('stop(): subsequent writes do not deliver', async () => {
+  const root = mkTree({ 'src/a.js': '0' });
+  const batches = [];
+  const handle = watcher.startWatcher({
+    repoRoot: root,
+    debounceMs: 80,
+    onBatch: (b) => batches.push(b),
+  });
+  try {
+    await waitStable(handle);
+    handle.stop();
+    fs.writeFileSync(path.join(root, 'src/a.js'), '1');
+    await new Promise((r) => setTimeout(r, 200));
+    assert.equal(batches.length, 0);
+  } finally {
+    cleanupTree(root);
+  }
+});
+
+test('large_batch flag: >threshold changes in one burst', async () => {
+  const files = {};
+  for (let i = 0; i < 12; i++) files[`src/f${i}.js`] = '0';
+  const root = mkTree(files);
+  const batches = [];
+  const handle = watcher.startWatcher({
+    repoRoot: root,
+    debounceMs: 120,
+    largeBatchThreshold: 10, // lower for test speed
+    onBatch: (b) => batches.push(b),
+  });
+  try {
+    await waitStable(handle);
+    for (let i = 0; i < 12; i++) fs.writeFileSync(path.join(root, `src/f${i}.js`), '1');
+    await waitForBatches(batches, 1);
+    await new Promise((r) => setTimeout(r, 150));
+    assert.equal(batches.length, 1);
+    assert.equal(batches[0].changes.length, 12);
+    assert.equal(batches[0].large_batch, true);
+  } finally {
+    handle.stop();
+    cleanupTree(root);
+  }
+});
+
+test('non-code files ignored (e.g. .log, .tmp)', async () => {
+  const root = mkTree({ 'src/a.js': '0', 'run.log': '0', 'tmp.tmp': '0' });
+  const batches = [];
+  const handle = watcher.startWatcher({
+    repoRoot: root,
+    debounceMs: 80,
+    onBatch: (b) => batches.push(b),
+  });
+  try {
+    await waitStable(handle);
+    fs.writeFileSync(path.join(root, 'run.log'), '1');
+    fs.writeFileSync(path.join(root, 'tmp.tmp'), '1');
+    await new Promise((r) => setTimeout(r, 200));
+    assert.equal(batches.length, 0);
+  } finally {
+    handle.stop();
+    cleanupTree(root);
+  }
+});

package/orchestrator/tests/daemon.test.cjs

@@ -0,0 +1,260 @@
+'use strict';
+
+// Phase 5.4 — Orchestrator daemon:
+//   • routeTask: pure function — complexity_hint + availableRuntimes → runtime
+//   • runDaemon: poll loop that spawns pending tasks, respects admission +
+//     circuit breaker, and shuts down gracefully via stop().
+
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { execFileSync } = require('node:child_process');
+
+const { initStateDb, closeStateDb } = require('../../mcp-server/lib/state-db.cjs');
+const ops = require('../../mcp-server/lib/state-ops.cjs');
+const daemon = require('../daemon.cjs');
+
+const LONG_SLEEP_CMD = process.execPath;
+const LONG_SLEEP_ARGS = ['-e', 'setInterval(() => {}, 60000);'];
+
+function mkRepo() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-daemon-repo-'));
+  execFileSync('git', ['init', '-q'], { cwd: dir });
+  execFileSync('git', ['config', 'user.email', 'test@ubp.dev'], { cwd: dir });
+  execFileSync('git', ['config', 'user.name', 'ubp-test'], { cwd: dir });
+  fs.writeFileSync(path.join(dir, 'README.md'), '# test\n');
+  execFileSync('git', ['add', '-A'], { cwd: dir });
+  execFileSync('git', ['commit', '-q', '-m', 'seed'], { cwd: dir });
+  return dir;
+}
+
+function mkDb(repoRoot) {
+  const { db } = initStateDb(path.join(repoRoot, '.ultra', 'state.db'));
+  return db;
+}
+
+function cleanup(repoRoot, db, handle) {
+  if (handle) {
+    try { handle.stop(); } catch (_) { /* ignore */ }
+  }
+  // Kill any stray children spawned by the daemon.
+  try {
+    const rows = db.prepare("SELECT pid FROM sessions WHERE pid IS NOT NULL AND status = 'running'").all();
+    for (const r of rows) {
+      try { process.kill(r.pid, 'SIGKILL'); } catch (_) { /* ignore */ }
+    }
+  } catch (_) { /* ignore */ }
+  try { closeStateDb(db); } catch (_) { /* ignore */ }
+  try { fs.rmSync(repoRoot, { recursive: true, force: true }); } catch (_) { /* ignore */ }
+}
+
+// ─── routeTask ────────────────────────────────────────────────────────────
+
+test('routeTask: haiku hint prefers cheap runtimes', () => {
+  const runtime = daemon.routeTask(
+    { id: 't', complexity_hint: 'haiku' },
+    ['claude', 'opencode', 'codex', 'gemini'],
+  );
+  assert.ok(['opencode', 'gemini'].includes(runtime), `got ${runtime}`);
+});
+
+test('routeTask: opus hint prefers strong runtimes', () => {
+  const runtime = daemon.routeTask(
+    { id: 't', complexity_hint: 'opus' },
+    ['claude', 'opencode', 'codex', 'gemini'],
+  );
+  assert.ok(['claude', 'codex'].includes(runtime), `got ${runtime}`);
+});
+
+test('routeTask: sonnet hint middle-ground', () => {
+  const runtime = daemon.routeTask(
+    { id: 't', complexity_hint: 'sonnet' },
+    ['claude', 'opencode', 'codex', 'gemini'],
+  );
+  assert.ok(['claude', 'codex', 'opencode', 'gemini'].includes(runtime));
+});
+
+test('routeTask: respects availability constraint', () => {
+  const runtime = daemon.routeTask(
+    { id: 't', complexity_hint: 'opus' },
+    ['opencode', 'gemini'],
+  );
+  // Prefers claude/codex but those aren't available → fall back to any.
+  assert.ok(['opencode', 'gemini'].includes(runtime));
+});
+
+test('routeTask: no hint → first available', () => {
+  const runtime = daemon.routeTask({ id: 't' }, ['gemini', 'claude']);
+  assert.ok(['gemini', 'claude'].includes(runtime));
+});
+
+test('routeTask: no runtimes available → null', () => {
+  assert.equal(daemon.routeTask({ id: 't' }, []), null);
+});
+
+// ─── runDaemon ────────────────────────────────────────────────────────────
+
+test('runDaemon spawns pending task within pollMs window', async () => {
+  const repoRoot = mkRepo();
+  const db = mkDb(repoRoot);
+  let handle;
+  try {
+    ops.createTask(db, { id: 'd-1', title: 'pending target', type: 'feature', priority: 'P1' });
+    handle = daemon.runDaemon({
+      db, repoRoot,
+      runtimes: ['claude'],
+      pollMs: 50,
+      command: LONG_SLEEP_CMD,
+      commandArgs: LONG_SLEEP_ARGS,
+    });
+
+    // Wait up to 500ms for the daemon to pick up the task.
+    const start = Date.now();
+    let spawned = null;
+    while (Date.now() - start < 500) {
+      const sessions = db.prepare("SELECT * FROM sessions WHERE task_id = 'd-1'").all();
+      if (sessions.length > 0) { spawned = sessions[0]; break; }
+      await new Promise((r) => setTimeout(r, 25));
+    }
+    assert.ok(spawned, 'daemon should have spawned a session within 500ms');
+    assert.equal(spawned.status, 'running');
+    assert.equal(spawned.runtime, 'claude');
+  } finally {
+    cleanup(repoRoot, db, handle);
+  }
+});
+
+test('runDaemon skips tripped tasks', async () => {
+  const repoRoot = mkRepo();
+  const db = mkDb(repoRoot);
+  let handle;
+  try {
+    ops.createTask(db, { id: 'd-trip', title: 'tripped', type: 'feature', priority: 'P1' });
+    for (let i = 0; i < 3; i += 1) ops.recordTaskFailure(db, 'd-trip', { reason: 'x' });
+    assert.equal(ops.isCircuitTripped(db, 'd-trip'), true);
+
+    handle = daemon.runDaemon({
+      db, repoRoot,
+      runtimes: ['claude'],
+      pollMs: 50,
+      command: LONG_SLEEP_CMD,
+      commandArgs: LONG_SLEEP_ARGS,
+    });
+    await new Promise((r) => setTimeout(r, 300));
+    const sessions = db.prepare("SELECT * FROM sessions WHERE task_id = 'd-trip'").all();
+    assert.equal(sessions.length, 0, 'tripped task must not be spawned');
+  } finally {
+    cleanup(repoRoot, db, handle);
+  }
+});
+
+test('runDaemon does not double-spawn same task', async () => {
+  const repoRoot = mkRepo();
+  const db = mkDb(repoRoot);
+  let handle;
+  try {
+    ops.createTask(db, { id: 'd-once', title: 'single', type: 'feature', priority: 'P1' });
+    handle = daemon.runDaemon({
+      db, repoRoot,
+      runtimes: ['claude'],
+      pollMs: 30,
+      command: LONG_SLEEP_CMD,
+      commandArgs: LONG_SLEEP_ARGS,
+    });
+    await new Promise((r) => setTimeout(r, 400));
+    const sessions = db.prepare("SELECT * FROM sessions WHERE task_id = 'd-once'").all();
+    assert.equal(sessions.length, 1, 'daemon should not double-spawn');
+  } finally {
+    cleanup(repoRoot, db, handle);
+  }
+});
+
+test('runDaemon.stop() halts polling; existing children stay alive', async () => {
+  const repoRoot = mkRepo();
+  const db = mkDb(repoRoot);
+  let handle;
+  try {
+    ops.createTask(db, { id: 'd-stop', title: 'stop test', type: 'feature', priority: 'P1' });
+    handle = daemon.runDaemon({
+      db, repoRoot,
+      runtimes: ['claude'],
+      pollMs: 30,
+      command: LONG_SLEEP_CMD,
+      commandArgs: LONG_SLEEP_ARGS,
+    });
+    // Wait for spawn.
+    await new Promise((r) => setTimeout(r, 200));
+    const before = db.prepare("SELECT pid FROM sessions WHERE task_id = 'd-stop'").all();
+    assert.equal(before.length, 1);
+    const childPid = before[0].pid;
+
+    handle.stop();
+    // After stop: child still alive, no new spawn for a fresh task.
+    ops.createTask(db, { id: 'd-after-stop', title: 'after stop', type: 'feature', priority: 'P1' });
+    await new Promise((r) => setTimeout(r, 200));
+    const afterStop = db.prepare("SELECT * FROM sessions WHERE task_id = 'd-after-stop'").all();
+    assert.equal(afterStop.length, 0, 'no new spawns after stop');
+
+    try { process.kill(childPid, 0); } catch (err) {
+      assert.fail(`child ${childPid} should still be alive after daemon stop: ${err.message}`);
+    }
+  } finally {
+    cleanup(repoRoot, db, handle);
+  }
+});
+
+test('runDaemon branchScoped=true only spawns tasks matching cwd branch tag', async () => {
+  const repoRoot = mkRepo();
+  const db = mkDb(repoRoot);
+  let handle;
+  try {
+    // Normalize to a known branch name so the test doesn't depend on
+    // the dev machine's git init.defaultBranch config.
+    execFileSync('git', ['checkout', '-q', '-B', 'main'], { cwd: repoRoot });
+    ops.createTask(db, { id: 'd-branch-match', title: 'main task', type: 'feature', priority: 'P1', tag: 'main' });
+    ops.createTask(db, { id: 'd-branch-other', title: 'other task', type: 'feature', priority: 'P1', tag: 'feat-other' });
+    handle = daemon.runDaemon({
+      db, repoRoot,
+      runtimes: ['claude'],
+      pollMs: 50,
+      command: LONG_SLEEP_CMD,
+      commandArgs: LONG_SLEEP_ARGS,
+      branchScoped: true,
+    });
+    await new Promise((r) => setTimeout(r, 300));
+    const match = db.prepare("SELECT * FROM sessions WHERE task_id = 'd-branch-match'").all();
+    const other = db.prepare("SELECT * FROM sessions WHERE task_id = 'd-branch-other'").all();
+    assert.equal(match.length, 1, 'current-branch task must spawn');
+    assert.equal(other.length, 0, 'other-branch task must stay pending');
+  } finally {
+    cleanup(repoRoot, db, handle);
+  }
+});
+
+test('runDaemon applies complexity_hint route', async () => {
+  const repoRoot = mkRepo();
+  const db = mkDb(repoRoot);
+  let handle;
+  try {
+    ops.createTask(db, {
+      id: 'd-opus', title: 'opus task', type: 'architecture', priority: 'P0',
+      complexity_hint: 'opus',
+    });
+    handle = daemon.runDaemon({
+      db, repoRoot,
+      runtimes: ['claude', 'opencode', 'gemini'],
+      pollMs: 50,
+      command: LONG_SLEEP_CMD,
+      commandArgs: LONG_SLEEP_ARGS,
+    });
+    await new Promise((r) => setTimeout(r, 300));
+    const sessions = db.prepare("SELECT * FROM sessions WHERE task_id = 'd-opus'").all();
+    assert.equal(sessions.length, 1);
+    // opus should prefer claude over opencode/gemini.
+    assert.equal(sessions[0].runtime, 'claude');
+  } finally {
+    cleanup(repoRoot, db, handle);
+  }
+});

package/orchestrator/tests/dispatch-rules.test.cjs

@@ -0,0 +1,122 @@
+'use strict';
+
+// Phase 8B.1 — Dispatch rules declarative table.
+//
+// evaluate(ctx, rules) → { rule_id, action, runtime }.
+// DEFAULT_RULES must reproduce Phase 5.4 routeTask behavior (ROUTE_PREFERENCES
+// by complexity_hint, fall back to first available) so daemon.cjs keeps green.
+// New dimensions: breaker_state / deps_ready / wave conflict / custom rules.
+
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+
+const { evaluate, DEFAULT_RULES, ROUTE_PREFERENCES } = require('../dispatch-rules.cjs');
+
+function baseCtx(overrides = {}) {
+  return {
+    task: { id: 't1' },
+    deps_ready: true,
+    available_runtimes: ['claude', 'opencode', 'codex', 'gemini'],
+    breaker_state: 'ok',
+    wave: null,
+    ...overrides,
+  };
+}
+
+// ─── spawn_agent path (preference routing, 6 cases mirror routeTask) ──────
+
+test('evaluate: opus hint + all available → claude (preference head)', () => {
+  const d = evaluate(baseCtx({ task: { id: 't', complexity_hint: 'opus' } }));
+  assert.equal(d.action, 'spawn_agent');
+  assert.equal(d.runtime, 'claude');
+});
+
+test('evaluate: opus hint + only codex available → codex', () => {
+  const d = evaluate(baseCtx({
+    task: { id: 't', complexity_hint: 'opus' },
+    available_runtimes: ['codex', 'opencode'],
+  }));
+  assert.equal(d.runtime, 'codex');
+});
+
+test('evaluate: opus hint + preference exhausted → first available fallback', () => {
+  const d = evaluate(baseCtx({
+    task: { id: 't', complexity_hint: 'opus' },
+    available_runtimes: ['opencode', 'gemini'],
+  }));
+  assert.equal(d.action, 'spawn_agent');
+  assert.equal(d.runtime, 'opencode');
+});
+
+test('evaluate: haiku hint + all available → opencode (cheapest preference)', () => {
+  const d = evaluate(baseCtx({ task: { id: 't', complexity_hint: 'haiku' } }));
+  assert.equal(d.runtime, 'opencode');
+});
+
+test('evaluate: sonnet hint + all available → claude', () => {
+  const d = evaluate(baseCtx({ task: { id: 't', complexity_hint: 'sonnet' } }));
+  assert.equal(d.runtime, 'claude');
+});
+
+test('evaluate: no hint → first available fallback', () => {
+  const d = evaluate(baseCtx({
+    task: { id: 't' },
+    available_runtimes: ['gemini', 'claude'],
+  }));
+  assert.equal(d.action, 'spawn_agent');
+  assert.equal(d.runtime, 'gemini');
+});
+
+// ─── block / defer paths (new in 8B.1) ────────────────────────────────────
+
+test('evaluate: empty runtimes → block', () => {
+  const d = evaluate(baseCtx({ available_runtimes: [] }));
+  assert.equal(d.action, 'block');
+  assert.equal(d.runtime, null);
+});
+
+test('evaluate: breaker tripped → block (wins over spawn rules)', () => {
+  const d = evaluate(baseCtx({ breaker_state: 'tripped' }));
+  assert.equal(d.action, 'block');
+  assert.equal(d.rule_id, 'breaker-blocked');
+});
+
+test('evaluate: deps_ready=false → defer', () => {
+  const d = evaluate(baseCtx({ deps_ready: false }));
+  assert.equal(d.action, 'defer');
+  assert.equal(d.rule_id, 'deps-not-ready');
+});
+
+test('evaluate: serial wave already has running task → defer', () => {
+  const d = evaluate(baseCtx({
+    wave: { parallel: false, running_count: 1 },
+  }));
+  assert.equal(d.action, 'defer');
+  assert.equal(d.rule_id, 'wave-conflict');
+});
+
+// ─── composability: custom rules override defaults ────────────────────────
+
+test('evaluate: custom high-priority rule overrides defaults', () => {
+  const customRules = [
+    ...DEFAULT_RULES,
+    {
+      id: 'force-gemini',
+      priority: 999,
+      when: () => true,
+      action: 'spawn_agent',
+      resolve: () => 'gemini',
+    },
+  ];
+  const d = evaluate(baseCtx({ task: { id: 't', complexity_hint: 'opus' } }), customRules);
+  assert.equal(d.runtime, 'gemini');
+  assert.equal(d.rule_id, 'force-gemini');
+});
+
+// ─── ROUTE_PREFERENCES shape guard (regression: don't drift from Phase 5.4) ─
+
+test('DEFAULT_RULES preserves ROUTE_PREFERENCES shape', () => {
+  assert.deepEqual(Object.keys(ROUTE_PREFERENCES).sort(), ['haiku', 'opus', 'sonnet']);
+  assert.equal(ROUTE_PREFERENCES.opus[0], 'claude');
+  assert.equal(ROUTE_PREFERENCES.haiku[0], 'opencode');
+});