ultra-builder-pro-cli 0.13.0 → 0.15.0

package/mcp-server/lib/task-expander.test.cjs

@@ -1,324 +0,0 @@
-'use strict';
-
-// Integration tests for task-expander — real SQLite (Testcontainers-style
-// in-process) so parent_id column + status transition + task_expanded event
-// are exercised end-to-end. The only Test Double is the LLM client, which
-// we inject with deterministic child fixtures.
-
-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 { initStateDb, closeStateDb } = require('./state-db.cjs');
-const ops = require('./state-ops.cjs');
-const changes = require('./change-workflow.cjs');
-const { expandTask, TaskExpandError } = require('./task-expander.cjs');
-
-function tmpDb() {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-expand-'));
-  const { db } = initStateDb(path.join(dir, 'state.db'));
-  db.prepare(
-    `INSERT INTO baselines
-     (id, project_name, mode, status, approved_by, approval_note, converged_at)
-     VALUES ('test-baseline', 'fixture', 'greenfield', 'ready', 'test', 'fixture', ?)`,
-  ).run(new Date().toISOString());
-  return { dir, db };
-}
-
-function cleanup({ dir, db }) {
-  closeStateDb(db);
-  fs.rmSync(dir, { recursive: true, force: true });
-}
-
-function fakeLlm(childrenJson, { shouldFail = false, usage = {} } = {}) {
-  return {
-    provider: 'anthropic',
-    model: 'claude-sonnet-4-6',
-    async completeJson() {
-      if (shouldFail) throw new Error('upstream LLM 500');
-      return {
-        json: { children: childrenJson },
-        raw: JSON.stringify({ children: childrenJson }),
-        usage,
-        model: 'claude-sonnet-4-6',
-        provider: 'anthropic',
-      };
-    },
-  };
-}
-
-function seedParent(db, overrides = {}) {
-  return ops.createTask(db, {
-    id: 'parent-1',
-    title: 'Build authentication module',
-    type: 'feature',
-    priority: 'P1',
-    complexity: 9,
-    files_modified: ['src/auth/index.ts'],
-    ...overrides,
-  });
-}
-
-const HAPPY_CHILDREN = [
-  { id: 'child-1', title: 'Design auth schema',       type: 'architecture', priority: 'P1', complexity: 4, deps: [],          files_modified: ['src/auth/schema.ts'] },
-  { id: 'child-2', title: 'Implement login endpoint', type: 'feature',      priority: 'P1', complexity: 5, deps: ['child-1'], files_modified: ['src/auth/login.ts']  },
-  { id: 'child-3', title: 'Add signup endpoint',      type: 'feature',      priority: 'P2', complexity: 3, deps: ['child-1'], files_modified: ['src/auth/signup.ts'] },
-];
-
-test('expandTask happy path: creates children, flips parent status, emits task_expanded', async () => {
-  const ctx = tmpDb();
-  try {
-    seedParent(ctx.db);
-    const result = await expandTask(ctx.db, {
-      id: 'parent-1',
-      strategy: 'llm',
-      llmClient: fakeLlm(HAPPY_CHILDREN),
-    });
-    assert.equal(result.parent_id, 'parent-1');
-    assert.equal(result.children.length, 3);
-
-    const parentAfter = ops.readTask(ctx.db, 'parent-1');
-    assert.equal(parentAfter.status, 'expanded');
-
-    for (const child of HAPPY_CHILDREN) {
-      const row = ops.readTask(ctx.db, child.id);
-      assert.ok(row, `child ${child.id} missing`);
-      assert.equal(row.parent_id, 'parent-1');
-      assert.equal(row.status, 'pending');
-    }
-
-    const events = ops.subscribeEventsSince(ctx.db, { since_id: 0, limit: 100 });
-    const expandedEvents = events.events.filter((e) => e.type === 'task_expanded');
-    assert.equal(expandedEvents.length, 1);
-    assert.equal(expandedEvents[0].task_id, 'parent-1');
-    const createdEvents = events.events.filter((e) => e.type === 'task_created');
-    assert.ok(createdEvents.length >= 4, 'parent + 3 children task_created events');
-  } finally {
-    cleanup(ctx);
-  }
-});
-
-test('expandTask: missing parent → TASK_NOT_FOUND', async () => {
-  const ctx = tmpDb();
-  try {
-    await assert.rejects(
-      expandTask(ctx.db, {
-        id: 'does-not-exist',
-        llmClient: fakeLlm(HAPPY_CHILDREN),
-      }),
-      (err) => err instanceof TaskExpandError && err.code === 'TASK_NOT_FOUND',
-    );
-  } finally {
-    cleanup(ctx);
-  }
-});
-
-test('expandTask: already-expanded parent → ALREADY_EXPANDED', async () => {
-  const ctx = tmpDb();
-  try {
-    seedParent(ctx.db);
-    // First expansion succeeds
-    await expandTask(ctx.db, {
-      id: 'parent-1',
-      llmClient: fakeLlm(HAPPY_CHILDREN),
-    });
-    // Second attempt must refuse
-    await assert.rejects(
-      expandTask(ctx.db, {
-        id: 'parent-1',
-        llmClient: fakeLlm(HAPPY_CHILDREN.map((c, i) => ({ ...c, id: `other-${i}` }))),
-      }),
-      (err) => err instanceof TaskExpandError && err.code === 'ALREADY_EXPANDED',
-    );
-  } finally {
-    cleanup(ctx);
-  }
-});
-
-test('expandTask: strategy="manual" → NOT_IMPLEMENTED', async () => {
-  const ctx = tmpDb();
-  try {
-    seedParent(ctx.db);
-    await assert.rejects(
-      expandTask(ctx.db, {
-        id: 'parent-1',
-        strategy: 'manual',
-        llmClient: fakeLlm(HAPPY_CHILDREN),
-      }),
-      (err) => err instanceof TaskExpandError && err.code === 'NOT_IMPLEMENTED',
-    );
-  } finally {
-    cleanup(ctx);
-  }
-});
-
-test('expandTask: missing llmClient → NO_LLM_CLIENT', async () => {
-  const ctx = tmpDb();
-  try {
-    seedParent(ctx.db);
-    await assert.rejects(
-      expandTask(ctx.db, { id: 'parent-1' }),
-      (err) => err instanceof TaskExpandError && err.code === 'NO_LLM_CLIENT',
-    );
-  } finally {
-    cleanup(ctx);
-  }
-});
-
-test('expandTask: LLM throws → LLM_CALL_FAILED', async () => {
-  const ctx = tmpDb();
-  try {
-    seedParent(ctx.db);
-    await assert.rejects(
-      expandTask(ctx.db, {
-        id: 'parent-1',
-        llmClient: fakeLlm([], { shouldFail: true }),
-      }),
-      (err) => err instanceof TaskExpandError && err.code === 'LLM_CALL_FAILED',
-    );
-    // parent status must be unchanged
-    assert.equal(ops.readTask(ctx.db, 'parent-1').status, 'pending');
-  } finally {
-    cleanup(ctx);
-  }
-});
-
-test('expandTask: invalid child shape → INVALID_OUTPUT, parent untouched', async () => {
-  const ctx = tmpDb();
-  try {
-    seedParent(ctx.db);
-    const bad = [{ id: 'child-1', title: 'x', type: 'feature', priority: 'P1' }]; // title too short
-    await assert.rejects(
-      expandTask(ctx.db, { id: 'parent-1', llmClient: fakeLlm(bad) }),
-      (err) => err instanceof TaskExpandError && err.code === 'INVALID_OUTPUT',
-    );
-    assert.equal(ops.readTask(ctx.db, 'parent-1').status, 'pending');
-  } finally {
-    cleanup(ctx);
-  }
-});
-
-test('expandTask: duplicate child id → INVALID_OUTPUT', async () => {
-  const ctx = tmpDb();
-  try {
-    seedParent(ctx.db);
-    const dup = [
-      { id: 'same', title: 'First child',  type: 'feature', priority: 'P2' },
-      { id: 'same', title: 'Second child', type: 'feature', priority: 'P2' },
-    ];
-    await assert.rejects(
-      expandTask(ctx.db, { id: 'parent-1', llmClient: fakeLlm(dup) }),
-      (err) => err instanceof TaskExpandError && err.code === 'INVALID_OUTPUT',
-    );
-  } finally {
-    cleanup(ctx);
-  }
-});
-
-test('expandTask: tx rollback — child id collides with existing task → parent status unchanged, no children inserted', async () => {
-  const ctx = tmpDb();
-  try {
-    seedParent(ctx.db);
-    // Pre-create a task with the same id one of the children will try
-    ops.createTask(ctx.db, {
-      id: 'child-1',
-      title: 'Pre-existing task',
-      type: 'bugfix',
-      priority: 'P3',
-    });
-    await assert.rejects(
-      expandTask(ctx.db, { id: 'parent-1', llmClient: fakeLlm(HAPPY_CHILDREN) }),
-      /* any error is acceptable — the point is no partial state */
-    );
-    assert.equal(ops.readTask(ctx.db, 'parent-1').status, 'pending');
-    // child-2 / child-3 must NOT have been inserted
-    assert.equal(ops.readTask(ctx.db, 'child-2'), null);
-    assert.equal(ops.readTask(ctx.db, 'child-3'), null);
-  } finally {
-    cleanup(ctx);
-  }
-});
-
-test('expandTask: children inherit parent tag', async () => {
-  const ctx = tmpDb();
-  try {
-    seedParent(ctx.db, { tag: 'feat-auth' });
-    await expandTask(ctx.db, {
-      id: 'parent-1',
-      llmClient: fakeLlm(HAPPY_CHILDREN),
-    });
-    for (const child of HAPPY_CHILDREN) {
-      const row = ops.readTask(ctx.db, child.id);
-      assert.equal(row.tag, 'feat-auth');
-    }
-  } finally {
-    cleanup(ctx);
-  }
-});
-
-test('expandTask blocks new children when baseline authority is missing, draft, or migrated', async () => {
-  for (const baseline of ['missing', 'draft', 'migrated']) {
-    const ctx = tmpDb();
-    try {
-      seedParent(ctx.db);
-      if (baseline === 'missing') ctx.db.prepare('DELETE FROM baselines').run();
-      else if (baseline === 'draft') {
-        ctx.db.prepare("UPDATE baselines SET status = 'draft' WHERE id = 'test-baseline'").run();
-      } else {
-        ctx.db.prepare(
-          "UPDATE baselines SET mode = 'migrated', status = 'adopting' WHERE id = 'test-baseline'",
-        ).run();
-      }
-      await assert.rejects(
-        expandTask(ctx.db, {
-          id: 'parent-1', llmClient: fakeLlm(HAPPY_CHILDREN), rootDir: ctx.dir,
-        }),
-        (error) => error.code === 'BASELINE_NOT_READY',
-      );
-      assert.equal(ops.readTask(ctx.db, 'child-1'), null);
-      assert.equal(ops.readTask(ctx.db, 'parent-1').status, 'pending');
-    } finally { cleanup(ctx); }
-  }
-});
-
-test('expandTask preserves active ordinary and approved incident change ownership while adoption is incomplete', async () => {
-  for (const kind of ['quick', 'incident']) {
-    const ctx = tmpDb();
-    try {
-      if (kind === 'incident') {
-        ctx.db.prepare(
-          "UPDATE baselines SET mode = 'brownfield', status = 'adopting' WHERE id = 'test-baseline'",
-        ).run();
-      }
-      const changeId = `expand-${kind}`;
-      changes.createChange(ctx.db, {
-        id: changeId,
-        title: kind === 'incident' ? 'Recover production expansion' : 'Continue planned expansion',
-        kind,
-        intent: 'Keep every expanded child inside the already-authorized continuous change.',
-        ...(kind === 'incident' ? {
-          baseline_bypass: {
-            approved_by: 'incident-commander',
-            reason: 'Production recovery requires a bounded task expansion before adoption converges.',
-          },
-        } : {}),
-      }, { rootDir: ctx.dir });
-      seedParent(ctx.db, { change_id: changeId });
-      if (kind === 'quick') {
-        ctx.db.prepare(
-          "UPDATE baselines SET mode = 'brownfield', status = 'adopting' WHERE id = 'test-baseline'",
-        ).run();
-      }
-
-      const result = await expandTask(ctx.db, {
-        id: 'parent-1', llmClient: fakeLlm(HAPPY_CHILDREN), rootDir: ctx.dir,
-      });
-      assert.equal(result.children.length, HAPPY_CHILDREN.length);
-      for (const child of HAPPY_CHILDREN) {
-        assert.equal(ops.readTask(ctx.db, child.id).change_id, changeId);
-      }
-    } finally { cleanup(ctx); }
-  }
-});

package/mcp-server/lib/topo.test.cjs

@@ -1,158 +0,0 @@
-'use strict';
-
-const test = require('node:test');
-const assert = require('node:assert/strict');
-
-const { computeWaves } = require('./topo.cjs');
-
-function makeTask(id, deps = []) {
-  return { id, deps };
-}
-
-function idsSet(ids) {
-  return new Set(ids);
-}
-
-function asWaveSets(waves) {
-  return waves.map(idsSet);
-}
-
-test('topo: empty array → empty waves and cycles', () => {
-  const r = computeWaves([]);
-  assert.deepEqual(r.waves, []);
-  assert.deepEqual(r.cycles, []);
-});
-
-test('topo: single task with no deps → single wave', () => {
-  const r = computeWaves([makeTask('A')]);
-  assert.deepEqual(r.waves, [['A']]);
-  assert.deepEqual(r.cycles, []);
-});
-
-test('topo fixture 1: linear chain A, B(A), C(B) → three serial waves', () => {
-  const r = computeWaves([
-    makeTask('A'),
-    makeTask('B', ['A']),
-    makeTask('C', ['B']),
-  ]);
-  assert.deepEqual(asWaveSets(r.waves), [idsSet(['A']), idsSet(['B']), idsSet(['C'])]);
-  assert.deepEqual(r.cycles, []);
-});
-
-test('topo fixture 2: fan-out A→{B,C} + independent D→E → 2 waves', () => {
-  const r = computeWaves([
-    makeTask('A'),
-    makeTask('B', ['A']),
-    makeTask('C', ['A']),
-    makeTask('D'),
-    makeTask('E', ['D']),
-  ]);
-  assert.equal(r.waves.length, 2);
-  assert.deepEqual(asWaveSets(r.waves), [
-    idsSet(['A', 'D']),
-    idsSet(['B', 'C', 'E']),
-  ]);
-  assert.deepEqual(r.cycles, []);
-});
-
-test('topo fixture 3: double diamond merges waves correctly', () => {
-  const r = computeWaves([
-    makeTask('A'),
-    makeTask('B', ['A']),
-    makeTask('C', ['A']),
-    makeTask('D', ['B', 'C']),
-    makeTask('E'),
-    makeTask('F', ['E']),
-    makeTask('G', ['E']),
-    makeTask('H', ['F', 'G']),
-  ]);
-  assert.deepEqual(asWaveSets(r.waves), [
-    idsSet(['A', 'E']),
-    idsSet(['B', 'C', 'F', 'G']),
-    idsSet(['D', 'H']),
-  ]);
-  assert.deepEqual(r.cycles, []);
-});
-
-test('topo fixture 4: 2-node cycle A↔B → cycle reported, no waves', () => {
-  const r = computeWaves([
-    makeTask('A', ['B']),
-    makeTask('B', ['A']),
-  ]);
-  assert.deepEqual(r.waves, []);
-  assert.equal(r.cycles.length, 1);
-  assert.deepEqual(idsSet(r.cycles[0]), idsSet(['A', 'B']));
-});
-
-test('topo fixture 5: two independent cycles A↔B and C↔D → both reported', () => {
-  const r = computeWaves([
-    makeTask('A', ['B']),
-    makeTask('B', ['A']),
-    makeTask('C', ['D']),
-    makeTask('D', ['C']),
-  ]);
-  assert.deepEqual(r.waves, []);
-  assert.equal(r.cycles.length, 2);
-  const cycleSets = r.cycles.map((c) => idsSet(c));
-  const expected = [idsSet(['A', 'B']), idsSet(['C', 'D'])];
-  for (const exp of expected) {
-    const found = cycleSets.some(
-      (s) => s.size === exp.size && [...s].every((x) => exp.has(x)),
-    );
-    assert.ok(found, `cycle ${[...exp].join(',')} not reported`);
-  }
-});
-
-test('topo: self-loop counts as cycle', () => {
-  const r = computeWaves([makeTask('A', ['A'])]);
-  assert.deepEqual(r.waves, []);
-  assert.equal(r.cycles.length, 1);
-  assert.deepEqual(r.cycles[0], ['A']);
-});
-
-test('topo: cycle plus acyclic tail — tail is waved, cycle isolated', () => {
-  const r = computeWaves([
-    makeTask('A', ['B']),
-    makeTask('B', ['A']),
-    makeTask('X'),
-    makeTask('Y', ['X']),
-  ]);
-  assert.deepEqual(asWaveSets(r.waves), [idsSet(['X']), idsSet(['Y'])]);
-  assert.equal(r.cycles.length, 1);
-  assert.deepEqual(idsSet(r.cycles[0]), idsSet(['A', 'B']));
-});
-
-test('topo: external deps (ids not in task_ids) are treated as satisfied', () => {
-  const r = computeWaves([makeTask('A', ['X'])]);
-  assert.deepEqual(r.waves, [['A']]);
-  assert.deepEqual(r.cycles, []);
-});
-
-test('topo: input order does not change wave membership', () => {
-  const tasks = [
-    makeTask('A'),
-    makeTask('B', ['A']),
-    makeTask('C', ['A']),
-    makeTask('D', ['B', 'C']),
-  ];
-  const r1 = computeWaves(tasks);
-  const r2 = computeWaves([...tasks].reverse());
-  assert.deepEqual(asWaveSets(r1.waves), asWaveSets(r2.waves));
-  assert.deepEqual(r1.cycles, r2.cycles);
-});
-
-test('topo: rejects non-array input', () => {
-  assert.throws(() => computeWaves(null), TypeError);
-  assert.throws(() => computeWaves({}), TypeError);
-});
-
-test('topo: 3-node cycle A→B→C→A surfaced intact', () => {
-  const r = computeWaves([
-    makeTask('A', ['C']),
-    makeTask('B', ['A']),
-    makeTask('C', ['B']),
-  ]);
-  assert.deepEqual(r.waves, []);
-  assert.equal(r.cycles.length, 1);
-  assert.deepEqual(idsSet(r.cycles[0]), idsSet(['A', 'B', 'C']));
-});

package/mcp-server/tests/circuit-breaker.test.cjs

@@ -1,125 +0,0 @@
-'use strict';
-
-// Phase 5.2 — Circuit breaker:
-// per-task consecutive failures ≥3 → trip; tripped tasks refused spawn.
-
-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 { initStateDb, closeStateDb } = require('../lib/state-db.cjs');
-const ops = require('../lib/state-ops.cjs');
-
-function freshDb() {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-cb-'));
-  const file = path.join(dir, 'state.db');
-  const init = initStateDb(file);
-  return { dir, db: init.db };
-}
-
-function teardown(dir, db) {
-  try { closeStateDb(db); } catch (_) { /* ignore */ }
-  try { fs.rmSync(dir, { recursive: true, force: true }); } catch (_) { /* ignore */ }
-}
-
-function seedTask(db, id) {
-  ops.createTask(db, { id, title: 'cb target', type: 'feature', priority: 'P1' });
-  return id;
-}
-
-test('isCircuitTripped: unrecorded task → false', () => {
-  const { dir, db } = freshDb();
-  try {
-    seedTask(db, 'cb-1');
-    assert.equal(ops.isCircuitTripped(db, 'cb-1'), false);
-  } finally { teardown(dir, db); }
-});
-
-test('recordTaskFailure: 3 consecutive → trips + task_circuit_broken event', () => {
-  const { dir, db } = freshDb();
-  try {
-    seedTask(db, 'cb-2');
-    ops.recordTaskFailure(db, 'cb-2', { reason: 'test1' });
-    assert.equal(ops.isCircuitTripped(db, 'cb-2'), false);
-    ops.recordTaskFailure(db, 'cb-2', { reason: 'test2' });
-    assert.equal(ops.isCircuitTripped(db, 'cb-2'), false);
-    ops.recordTaskFailure(db, 'cb-2', { reason: 'test3' });
-    assert.equal(ops.isCircuitTripped(db, 'cb-2'), true);
-
-    const { events } = ops.subscribeEventsSince(db, { since_id: 0, limit: 500 });
-    const brokenEvents = events.filter((e) => e.type === 'task_circuit_broken' && e.task_id === 'cb-2');
-    assert.equal(brokenEvents.length, 1, 'circuit broken event should fire exactly once');
-    const failures = events.filter((e) => e.type === 'task_failure' && e.task_id === 'cb-2');
-    assert.equal(failures.length, 3);
-  } finally { teardown(dir, db); }
-});
-
-test('recordTaskFailure: 4th + 5th failure does not re-emit task_circuit_broken', () => {
-  const { dir, db } = freshDb();
-  try {
-    seedTask(db, 'cb-3');
-    for (let i = 0; i < 5; i += 1) {
-      ops.recordTaskFailure(db, 'cb-3', { reason: `test${i}` });
-    }
-    assert.equal(ops.isCircuitTripped(db, 'cb-3'), true);
-    const { events } = ops.subscribeEventsSince(db, { since_id: 0, limit: 500 });
-    const brokenEvents = events.filter((e) => e.type === 'task_circuit_broken' && e.task_id === 'cb-3');
-    assert.equal(brokenEvents.length, 1, 'should only emit on the trip transition');
-  } finally { teardown(dir, db); }
-});
-
-test('resetCircuitBreaker: clears count and tripped_at', () => {
-  const { dir, db } = freshDb();
-  try {
-    seedTask(db, 'cb-4');
-    ops.recordTaskFailure(db, 'cb-4', { reason: 'x' });
-    ops.recordTaskFailure(db, 'cb-4', { reason: 'x' });
-    ops.recordTaskFailure(db, 'cb-4', { reason: 'x' });
-    assert.equal(ops.isCircuitTripped(db, 'cb-4'), true);
-
-    ops.resetCircuitBreaker(db, 'cb-4');
-    assert.equal(ops.isCircuitTripped(db, 'cb-4'), false);
-
-    // Next failure starts count at 1, not accumulating pre-reset.
-    ops.recordTaskFailure(db, 'cb-4', { reason: 'x' });
-    assert.equal(ops.isCircuitTripped(db, 'cb-4'), false);
-    ops.recordTaskFailure(db, 'cb-4', { reason: 'x' });
-    assert.equal(ops.isCircuitTripped(db, 'cb-4'), false);
-  } finally { teardown(dir, db); }
-});
-
-test('admissionCheck: tripped task → can_spawn=false, recommended=blocked_by_breaker', () => {
-  const { dir, db } = freshDb();
-  try {
-    seedTask(db, 'cb-5');
-    for (let i = 0; i < 3; i += 1) ops.recordTaskFailure(db, 'cb-5', { reason: 'x' });
-
-    const verdict = ops.admissionCheck(db, 'cb-5');
-    assert.equal(verdict.can_spawn, false);
-    assert.equal(verdict.recommended_action, 'blocked_by_breaker');
-  } finally { teardown(dir, db); }
-});
-
-test('admissionCheck: reset after trip → can_spawn=true', () => {
-  const { dir, db } = freshDb();
-  try {
-    seedTask(db, 'cb-6');
-    for (let i = 0; i < 3; i += 1) ops.recordTaskFailure(db, 'cb-6', { reason: 'x' });
-    ops.resetCircuitBreaker(db, 'cb-6');
-    const verdict = ops.admissionCheck(db, 'cb-6');
-    assert.equal(verdict.can_spawn, true);
-  } finally { teardown(dir, db); }
-});
-
-test('custom threshold: fail_threshold=2 trips on 2nd failure', () => {
-  const { dir, db } = freshDb();
-  try {
-    seedTask(db, 'cb-7');
-    ops.recordTaskFailure(db, 'cb-7', { reason: 'x', fail_threshold: 2 });
-    assert.equal(ops.isCircuitTripped(db, 'cb-7'), false);
-    ops.recordTaskFailure(db, 'cb-7', { reason: 'x', fail_threshold: 2 });
-    assert.equal(ops.isCircuitTripped(db, 'cb-7'), true);
-  } finally { teardown(dir, db); }
-});