ultra-builder-pro-cli 0.13.0 → 0.15.0

package/mcp-server/tests/commit-hash-flow.test.cjs

@@ -1,117 +0,0 @@
-'use strict';
-
-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 { spawnSync } = require('node:child_process');
-
-const { initStateDb, closeStateDb } = require('../lib/state-db.cjs');
-const ops = require('../lib/state-ops.cjs');
-const projector = require('../lib/projector.cjs');
-
-function gitRun(cwd, args, opts = {}) {
-  const env = {
-    ...process.env,
-    GIT_AUTHOR_NAME: 'ubp-test',
-    GIT_AUTHOR_EMAIL: 'ubp@example.com',
-    GIT_COMMITTER_NAME: 'ubp-test',
-    GIT_COMMITTER_EMAIL: 'ubp@example.com',
-  };
-  const r = spawnSync('git', args, { cwd, encoding: 'utf8', env, ...opts });
-  if (r.status !== 0 && !opts.allowFail) {
-    throw new Error(`git ${args.join(' ')} failed: ${r.stderr || r.stdout}`);
-  }
-  return { code: r.status, stdout: r.stdout.trim(), stderr: r.stderr };
-}
-
-function tmpRepo() {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-hash-flow-'));
-  gitRun(dir, ['init', '-q', '-b', 'main']);
-  gitRun(dir, ['config', 'commit.gpgsign', 'false']);
-  // Ignore the SQLite WAL/SHM sidecars so they don't appear as modifications.
-  fs.writeFileSync(path.join(dir, '.gitignore'), '.ultra/state.db-shm\n.ultra/state.db-wal\n');
-  return dir;
-}
-
-test('two-commit flow lands feat then chore with the right SHA in context md', () => {
-  const dir = tmpRepo();
-  try {
-    const dbPath = path.join(dir, '.ultra', 'state.db');
-    const init = initStateDb(dbPath);
-    const db = init.db;
-
-    // Task starts pending, no completion_commit yet.
-    ops.createTask(db, { id: 'task-h1', title: 'commit hash flow', type: 'feature', priority: 'P1' });
-    projector.projectAll(db, { rootDir: dir });
-
-    // Stage initial state and land the feat commit.
-    fs.writeFileSync(path.join(dir, 'src.js'), '// implementation\n');
-    gitRun(dir, ['add', '-A']);
-    gitRun(dir, ['commit', '-q', '-m', 'feat: task-h1 — commit hash flow']);
-
-    const featSha = gitRun(dir, ['rev-parse', 'HEAD']).stdout;
-
-    // Step 3 — update state.db with the new SHA.
-    ops.patchTask(db, 'task-h1', { completion_commit: featSha });
-
-    // Step 4 — re-project the context so its YAML carries the hash.
-    projector.projectContext(db, 'task-h1', {}, { rootDir: dir });
-
-    // Step 5 — chore commit captures the projection update.
-    gitRun(dir, ['add', '-A']);
-    gitRun(dir, ['commit', '-q', '-m', 'chore: record task-h1 completion hash']);
-
-    const log = gitRun(dir, ['log', '--oneline', '-2']).stdout.split('\n');
-    assert.match(log[0], /chore: record task-h1 completion hash/);
-    assert.match(log[1], /feat: task-h1 — commit hash flow/);
-
-    const ctxFile = path.join(dir, '.ultra', 'tasks', 'contexts', 'task-task-h1.md');
-    const ctxText = fs.readFileSync(ctxFile, 'utf8');
-    // The chore commit's working tree must reflect the recorded SHA.
-    const dbRow = db.prepare("SELECT completion_commit FROM tasks WHERE id = 'task-h1'").get();
-    assert.equal(dbRow.completion_commit, featSha);
-    // Header is regenerated; ensure projector wrote v4.5 + the right task_id.
-    assert.match(ctxText, /^---/);
-    assert.match(ctxText, /schema_version: 4\.5/);
-    assert.match(ctxText, /task_id: task-h1/);
-    closeStateDb(db);
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test('rerunning steps 4–5 against the same SHA produces an empty chore commit attempt', () => {
-  const dir = tmpRepo();
-  try {
-    const dbPath = path.join(dir, '.ultra', 'state.db');
-    const init = initStateDb(dbPath);
-    const db = init.db;
-    ops.createTask(db, { id: 'task-h2', title: 'idempotent', type: 'feature', priority: 'P1' });
-    projector.projectAll(db, { rootDir: dir });
-
-    fs.writeFileSync(path.join(dir, 'a.js'), '// a\n');
-    gitRun(dir, ['add', '-A']);
-    gitRun(dir, ['commit', '-q', '-m', 'feat: task-h2 — idempotent']);
-    const sha = gitRun(dir, ['rev-parse', 'HEAD']).stdout;
-    ops.patchTask(db, 'task-h2', { completion_commit: sha });
-    projector.projectContext(db, 'task-h2', {}, { rootDir: dir });
-    gitRun(dir, ['add', '-A']);
-    gitRun(dir, ['commit', '-q', '-m', 'chore: record task-h2 completion hash']);
-
-    // Idempotency: re-projecting the same db state must produce byte-identical
-    // context md (generated_at is derived from tasks.updated_at, not now()).
-    projector.projectContext(db, 'task-h2', {}, { rootDir: dir });
-    gitRun(dir, ['add', '-A']);
-    const status = gitRun(dir, ['status', '--porcelain']).stdout;
-    assert.equal(status, '', 're-projection of unchanged state must leave nothing to commit');
-
-    // A retry chore commit on an empty diff must be refused by git.
-    const r = gitRun(dir, ['commit', '-q', '-m', 'chore: idempotent retry'], { allowFail: true });
-    assert.notEqual(r.code, 0, 'a follow-up empty chore commit must fail');
-    closeStateDb(db);
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});

package/mcp-server/tests/concurrency-update.test.cjs

@@ -1,96 +0,0 @@
-'use strict';
-
-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 { Worker, isMainThread, workerData, parentPort } = require('node:worker_threads');
-
-const { initStateDb, openStateDb, closeStateDb } = require('../lib/state-db.cjs');
-const ops = require('../lib/state-ops.cjs');
-
-const WORKER_COUNT = 20;
-const TASKS_PER_WORKER = 50;
-
-function tmpDb() {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-conc-up-'));
-  return { dir, file: path.join(dir, 'state.db') };
-}
-
-if (!isMainThread) {
-  const { dbPath, workerIdx, count } = workerData;
-  const db = openStateDb(dbPath);
-  const completed = [];
-  for (let i = 0; i < count; i++) {
-    const id = `w${workerIdx}-t${i}`;
-    ops.updateTaskStatus(db, id, 'in_progress');
-    ops.updateTaskStatus(db, id, 'completed');
-    completed.push(id);
-  }
-  closeStateDb(db);
-  parentPort.postMessage({ workerIdx, completed });
-} else {
-  test(`${WORKER_COUNT} workers × ${TASKS_PER_WORKER} updateTaskStatus — no loss, monotonic events`, async () => {
-    const { dir, file } = tmpDb();
-    try {
-      const init = initStateDb(file);
-      const db = init.db;
-
-      // Pre-seed disjoint tasks so workers never contend on the same row.
-      for (let w = 0; w < WORKER_COUNT; w++) {
-        for (let t = 0; t < TASKS_PER_WORKER; t++) {
-          ops.createTask(db, {
-            id: `w${w}-t${t}`,
-            title: `seed w${w}t${t}`,
-            type: 'feature',
-            priority: 'P3',
-          });
-        }
-      }
-      closeStateDb(db);
-
-      const expectedTasks = WORKER_COUNT * TASKS_PER_WORKER;
-      const results = await Promise.all(
-        Array.from({ length: WORKER_COUNT }, (_, idx) =>
-          new Promise((resolve, reject) => {
-            const w = new Worker(__filename, {
-              workerData: { dbPath: file, workerIdx: idx, count: TASKS_PER_WORKER },
-            });
-            w.on('message', resolve);
-            w.on('error', reject);
-            w.on('exit', (code) => {
-              if (code !== 0) reject(new Error(`worker ${idx} exit ${code}`));
-            });
-          }),
-        ),
-      );
-
-      const completedClaims = results.flatMap((r) => r.completed);
-      assert.equal(completedClaims.length, expectedTasks);
-
-      const verify = openStateDb(file);
-      const completedRows = verify.prepare("SELECT id, status FROM tasks WHERE status = @status").all({ status: 'completed' });
-      assert.equal(completedRows.length, expectedTasks, 'every task must end in completed');
-
-      // Each task contributes 1 task_created + 1 task_started + 1 task_completed = 3 events.
-      const totalEvents = verify.prepare('SELECT COUNT(*) AS n FROM events').get().n;
-      assert.equal(totalEvents, expectedTasks * 3, 'every transition must record an event');
-
-      const ids = verify.prepare('SELECT id FROM events ORDER BY id ASC').all().map((r) => r.id);
-      assert.equal(new Set(ids).size, ids.length, 'event ids must be unique');
-      for (let i = 1; i < ids.length; i++) {
-        assert.ok(ids[i] > ids[i - 1], 'event ids must be strictly monotonic');
-      }
-
-      const startedCount = verify.prepare("SELECT COUNT(*) AS n FROM events WHERE type = @type").get({ type: 'task_started' }).n;
-      const completedCount = verify.prepare("SELECT COUNT(*) AS n FROM events WHERE type = @type").get({ type: 'task_completed' }).n;
-      assert.equal(startedCount, expectedTasks, 'every task got a task_started event');
-      assert.equal(completedCount, expectedTasks, 'every task got a task_completed event');
-
-      closeStateDb(verify);
-    } finally {
-      fs.rmSync(dir, { recursive: true, force: true });
-    }
-  });
-}

package/mcp-server/tests/concurrency.test.cjs

@@ -1,112 +0,0 @@
-'use strict';
-
-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 { Worker, isMainThread, workerData, parentPort } = require('node:worker_threads');
-
-const { initStateDb, openStateDb, closeStateDb } = require('../lib/state-db.cjs');
-
-function tmpDb() {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-conc-'));
-  return { dir, file: path.join(dir, 'state.db') };
-}
-
-function appendEventRaw(db, type, payload) {
-  const stmt = db.prepare(
-    `INSERT INTO events (type, runtime, payload_json) VALUES (?, ?, ?)`,
-  );
-  return stmt.run(type, 'claude', JSON.stringify(payload)).lastInsertRowid;
-}
-
-function withRetry(fn, attempts = 3, baseMs = 25) {
-  let lastErr;
-  for (let i = 0; i < attempts; i++) {
-    try {
-      return fn();
-    } catch (err) {
-      if (!String(err.code || err.message).includes('SQLITE_BUSY')) throw err;
-      lastErr = err;
-      const wait = baseMs * Math.pow(2, i);
-      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, wait);
-    }
-  }
-  throw lastErr;
-}
-
-if (!isMainThread) {
-  const { dbPath, role, count, baseId } = workerData;
-  const db = openStateDb(dbPath);
-  const written = [];
-  for (let i = 0; i < count; i++) {
-    const id = withRetry(() =>
-      appendEventRaw(db, 'task_created', { role, baseId, i }),
-    );
-    written.push(Number(id));
-  }
-  closeStateDb(db);
-  parentPort.postMessage({ role, written });
-} else {
-  test('three concurrent writers append to events with no loss and monotonic id', async () => {
-    const { dir, file } = tmpDb();
-    try {
-      const init = initStateDb(file);
-      closeStateDb(init.db);
-
-      const roles = ['mcp', 'cli', 'daemon'];
-      const COUNT_PER_WORKER = 100;
-      const expected = roles.length * COUNT_PER_WORKER;
-
-      const results = await Promise.all(
-        roles.map(
-          (role, idx) =>
-            new Promise((resolve, reject) => {
-              const w = new Worker(__filename, {
-                workerData: {
-                  dbPath: file,
-                  role,
-                  count: COUNT_PER_WORKER,
-                  baseId: idx * COUNT_PER_WORKER,
-                },
-              });
-              w.on('message', (m) => resolve(m));
-              w.on('error', reject);
-              w.on('exit', (code) => {
-                if (code !== 0) reject(new Error(`worker ${role} exit ${code}`));
-              });
-            }),
-        ),
-      );
-
-      const verify = openStateDb(file);
-      const total = verify.prepare('SELECT COUNT(*) AS n FROM events').get().n;
-      assert.equal(total, expected, 'total event count must match');
-
-      const ids = verify.prepare('SELECT id FROM events ORDER BY id ASC').all().map((r) => r.id);
-      assert.equal(new Set(ids).size, ids.length, 'event ids must be unique');
-      for (let i = 1; i < ids.length; i++) {
-        assert.ok(ids[i] > ids[i - 1], 'event ids must be strictly monotonic');
-      }
-      const minId = ids[0];
-      const maxId = ids[ids.length - 1];
-      assert.ok(maxId - minId + 1 >= ids.length, 'sequence must not have collisions');
-
-      const perRole = verify
-        .prepare("SELECT json_extract(payload_json, '$.role') AS role, COUNT(*) AS n FROM events GROUP BY role")
-        .all();
-      for (const row of perRole) {
-        assert.equal(row.n, COUNT_PER_WORKER, `role ${row.role} count`);
-      }
-      closeStateDb(verify);
-
-      // Workers should each have observed their own row ids returned cleanly.
-      const collected = results.flatMap((r) => r.written);
-      assert.equal(collected.length, expected);
-      assert.equal(new Set(collected).size, expected, 'no duplicate ids reported by workers');
-    } finally {
-      fs.rmSync(dir, { recursive: true, force: true });
-    }
-  });
-}

package/mcp-server/tests/db-ops.test.cjs

@@ -1,121 +0,0 @@
-'use strict';
-
-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 { spawnSync } = require('node:child_process');
-
-const Database = require('better-sqlite3');
-
-const REPO_ROOT = path.resolve(__dirname, '..', '..');
-const CLI = path.join(REPO_ROOT, 'ultra-tools', 'cli.cjs');
-const { EXPECTED_VERSION, initStateDb, closeStateDb } = require('../lib/state-db.cjs');
-const ops = require('../lib/state-ops.cjs');
-
-function tmpDir() {
-  return fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-db-ops-'));
-}
-
-function runCli(args) {
-  const r = spawnSync(process.execPath, [CLI, 'db', ...args], { encoding: 'utf8' });
-  const lines = r.stdout.trim().split('\n').filter(Boolean);
-  const last = lines[lines.length - 1] || '{}';
-  return { code: r.status, envelope: JSON.parse(last), stderr: r.stderr };
-}
-
-test('db checkpoint runs PRAGMA wal_checkpoint(TRUNCATE) and reports counters', () => {
-  const dir = tmpDir();
-  const dbPath = path.join(dir, 'state.db');
-  try {
-    closeStateDb(initStateDb(dbPath).db);
-    const { code, envelope } = runCli(['checkpoint', '--path', dbPath]);
-    assert.equal(code, 0);
-    assert.equal(envelope.ok, true);
-    assert.equal(typeof envelope.data.busy, 'number');
-    assert.equal(typeof envelope.data.checkpointed, 'number');
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test('db vacuum reports reclaimed bytes after deleting rows', () => {
-  const dir = tmpDir();
-  const dbPath = path.join(dir, 'state.db');
-  try {
-    const init = initStateDb(dbPath);
-    for (let i = 0; i < 50; i++) {
-      ops.appendEvent(init.db, {
-        type: 'task_created',
-        task_id: `t-${i}`,
-        payload: { padding: 'x'.repeat(16 * 1024) },
-      });
-    }
-    init.db.prepare('DELETE FROM events').run();
-    closeStateDb(init.db);
-
-    const { code, envelope } = runCli(['vacuum', '--path', dbPath]);
-    assert.equal(code, 0);
-    assert.equal(envelope.ok, true);
-    assert.ok(envelope.data.bytes_after <= envelope.data.bytes_before);
-    assert.equal(typeof envelope.data.reclaimed_bytes, 'number');
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test('db integrity returns ok on a healthy database', () => {
-  const dir = tmpDir();
-  const dbPath = path.join(dir, 'state.db');
-  try {
-    closeStateDb(initStateDb(dbPath).db);
-    const { code, envelope } = runCli(['integrity', '--path', dbPath]);
-    assert.equal(code, 0);
-    assert.equal(envelope.ok, true);
-    assert.equal(envelope.data.integrity_ok, true);
-    assert.deepEqual(envelope.data.messages, ['ok']);
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test('db backup writes a file that opens independently with the same schema', () => {
-  const dir = tmpDir();
-  const dbPath = path.join(dir, 'state.db');
-  const backupPath = path.join(dir, 'snap.db');
-  try {
-    const init = initStateDb(dbPath);
-    ops.createTask(init.db, { id: 'b-1', title: 'backup', type: 'feature', priority: 'P1' });
-    closeStateDb(init.db);
-
-    const { code, envelope } = runCli(['backup', '--path', dbPath, '--to', backupPath]);
-    assert.equal(code, 0);
-    assert.equal(envelope.ok, true);
-    assert.equal(envelope.data.target, path.resolve(backupPath));
-    assert.ok(envelope.data.size_bytes > 0);
-
-    // Independently open the backup with a fresh connection
-    const snap = new Database(backupPath);
-    const v = snap.prepare('SELECT version FROM schema_version WHERE version = ?').get(EXPECTED_VERSION);
-    assert.equal(v.version, EXPECTED_VERSION);
-    const t = snap.prepare("SELECT id FROM tasks WHERE id = 'b-1'").get();
-    assert.equal(t.id, 'b-1');
-    snap.close();
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test('db <verb> on a missing database returns DB_NOT_FOUND with exit 2', () => {
-  const dir = tmpDir();
-  try {
-    const missing = path.join(dir, 'missing.db');
-    const { code, envelope } = runCli(['integrity', '--path', missing]);
-    assert.equal(code, 2);
-    assert.equal(envelope.ok, false);
-    assert.equal(envelope.error.code, 'DB_NOT_FOUND');
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});