ultra-builder-pro-cli 0.14.0 → 0.15.0

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

@@ -1,190 +0,0 @@
-'use strict';
-
-// Phase 5.3 — Task staleness consumer:
-//   • markTasksStaleBySpecSections: UPDATE pending tasks whose trace_to
-//     matches a changed spec section → stale=1 + task_stale_marked event.
-//   • consumeSpecChangedEvents: pulls unprocessed spec_changed events from
-//     the event stream and applies the rule above, advancing a cursor.
-
-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');
-const projector = require('../lib/projector.cjs');
-
-function freshDb() {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-stale-'));
-  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 seed(db, id, { trace_to, status = 'pending' } = {}) {
-  ops.createTask(db, { id, title: `task ${id}`, type: 'feature', priority: 'P2', trace_to });
-  if (status !== 'pending') ops.patchTask(db, id, { status });
-}
-
-test('markTasksStaleBySpecSections: marks pending tasks with matching trace_to', () => {
-  const { dir, db } = freshDb();
-  try {
-    seed(db, 't-prod', { trace_to: 'product' });
-    seed(db, 't-arch', { trace_to: 'arch' });
-    seed(db, 't-exec', { trace_to: 'exec' });
-
-    const result = ops.markTasksStaleBySpecSections(db, ['product']);
-    assert.equal(result.marked_count, 1);
-    assert.deepEqual(result.marked_ids, ['t-prod']);
-
-    assert.equal(ops.readTask(db, 't-prod').stale, true);
-    assert.equal(ops.readTask(db, 't-arch').stale, false);
-    assert.equal(ops.readTask(db, 't-exec').stale, false);
-  } finally { teardown(dir, db); }
-});
-
-test('markTasksStaleBySpecSections: multi-section update', () => {
-  const { dir, db } = freshDb();
-  try {
-    seed(db, 't-a', { trace_to: 'product' });
-    seed(db, 't-b', { trace_to: 'arch' });
-    seed(db, 't-c', { trace_to: 'exec' });
-
-    const result = ops.markTasksStaleBySpecSections(db, ['product', 'arch']);
-    assert.equal(result.marked_count, 2);
-    assert.ok(result.marked_ids.includes('t-a'));
-    assert.ok(result.marked_ids.includes('t-b'));
-    assert.equal(ops.readTask(db, 't-c').stale, false);
-  } finally { teardown(dir, db); }
-});
-
-test('markTasksStaleBySpecSections: skips non-pending tasks', () => {
-  const { dir, db } = freshDb();
-  try {
-    seed(db, 't-running', { trace_to: 'product' });
-    ops.patchTask(db, 't-running', { status: 'in_progress' });
-
-    seed(db, 't-done', { trace_to: 'product' });
-    ops.patchTask(db, 't-done', { status: 'in_progress' });
-    ops.patchTask(db, 't-done', { status: 'completed' });
-
-    seed(db, 't-pending', { trace_to: 'product' });
-
-    const result = ops.markTasksStaleBySpecSections(db, ['product']);
-    assert.equal(result.marked_count, 1);
-    assert.deepEqual(result.marked_ids, ['t-pending']);
-  } finally { teardown(dir, db); }
-});
-
-test('markTasksStaleBySpecSections: emits task_stale_marked event per task', () => {
-  const { dir, db } = freshDb();
-  try {
-    seed(db, 't-e1', { trace_to: 'product' });
-    seed(db, 't-e2', { trace_to: 'product' });
-
-    const { events: before } = ops.subscribeEventsSince(db, { since_id: 0, limit: 500 });
-    ops.markTasksStaleBySpecSections(db, ['product']);
-    const { events: after } = ops.subscribeEventsSince(db, { since_id: 0, limit: 500 });
-
-    const marked = after.slice(before.length).filter((e) => e.type === 'task_stale_marked');
-    assert.equal(marked.length, 2);
-    const taskIds = marked.map((e) => e.task_id).sort();
-    assert.deepEqual(taskIds, ['t-e1', 't-e2']);
-  } finally { teardown(dir, db); }
-});
-
-test('markTasksStaleBySpecSections: idempotent — re-mark already-stale task does not double-emit', () => {
-  const { dir, db } = freshDb();
-  try {
-    seed(db, 't-idem', { trace_to: 'product' });
-    ops.markTasksStaleBySpecSections(db, ['product']);
-
-    const { events: before } = ops.subscribeEventsSince(db, { since_id: 0, limit: 500 });
-    ops.markTasksStaleBySpecSections(db, ['product']);
-    const { events: after } = ops.subscribeEventsSince(db, { since_id: 0, limit: 500 });
-
-    const newEvents = after.slice(before.length);
-    const marked = newEvents.filter((e) => e.type === 'task_stale_marked');
-    assert.equal(marked.length, 0, 'should not re-emit for already-stale task');
-  } finally { teardown(dir, db); }
-});
-
-test('consumeSpecChangedEvents: processes queued events and advances cursor', () => {
-  const { dir, db } = freshDb();
-  try {
-    seed(db, 't-c1', { trace_to: 'product' });
-    seed(db, 't-c2', { trace_to: 'arch' });
-
-    ops.appendEvent(db, { type: 'spec_changed', payload: { sections: ['product'] } });
-    ops.appendEvent(db, { type: 'spec_changed', payload: { sections: ['arch'] } });
-
-    const result = ops.consumeSpecChangedEvents(db, { since_id: 0 });
-    assert.equal(result.processed, 2);
-    assert.ok(result.next_since_id > 0);
-    assert.equal(ops.readTask(db, 't-c1').stale, true);
-    assert.equal(ops.readTask(db, 't-c2').stale, true);
-  } finally { teardown(dir, db); }
-});
-
-test('consumeSpecChangedEvents: cursor prevents reprocessing', () => {
-  const { dir, db } = freshDb();
-  try {
-    seed(db, 't-cur', { trace_to: 'product' });
-    ops.appendEvent(db, { type: 'spec_changed', payload: { sections: ['product'] } });
-
-    const first = ops.consumeSpecChangedEvents(db, { since_id: 0 });
-    assert.equal(first.processed, 1);
-
-    // second call from the new cursor — no new spec_changed events.
-    const second = ops.consumeSpecChangedEvents(db, { since_id: first.next_since_id });
-    assert.equal(second.processed, 0);
-    assert.equal(second.next_since_id, first.next_since_id);
-  } finally { teardown(dir, db); }
-});
-
-test('consumeSpecChangedEvents: ignores non-spec_changed events', () => {
-  const { dir, db } = freshDb();
-  try {
-    seed(db, 't-other', { trace_to: 'product' });
-    ops.appendEvent(db, { type: 'task_failure', task_id: 't-other', payload: { reason: 'noise' } });
-
-    const result = ops.consumeSpecChangedEvents(db, { since_id: 0 });
-    assert.equal(result.processed, 0);
-    assert.equal(ops.readTask(db, 't-other').stale, false);
-  } finally { teardown(dir, db); }
-});
-
-test('projector: stale task context md carries STALE banner before body', () => {
-  const { dir, db } = freshDb();
-  const rootDir = dir;
-  try {
-    seed(db, 't-proj', { trace_to: 'product' });
-    ops.markTasksStaleBySpecSections(db, ['product']);
-
-    const result = projector.projectContext(db, 't-proj', {}, { rootDir });
-    const text = fs.readFileSync(result.path, 'utf8');
-    // Banner goes after YAML frontmatter end + blank line.
-    const frontmatterEnd = text.indexOf('\n---', 3);
-    assert.ok(frontmatterEnd > 0, 'frontmatter should exist');
-    const body = text.slice(frontmatterEnd + 4);
-    assert.match(body, /⚠️\s*STALE/, 'stale banner should render');
-    assert.match(body, /spec/i, 'banner should mention spec');
-  } finally { teardown(dir, db); }
-});
-
-test('projector: non-stale task context md has no STALE banner', () => {
-  const { dir, db } = freshDb();
-  try {
-    seed(db, 't-fresh', { trace_to: 'product' });
-    const result = projector.projectContext(db, 't-fresh', {}, { rootDir: dir });
-    const text = fs.readFileSync(result.path, 'utf8');
-    assert.doesNotMatch(text, /STALE/);
-  } finally { teardown(dir, db); }
-});

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

@@ -1,106 +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 stateDb = require('../lib/state-db.cjs');
-
-test('initStateDb upgrades a pre-10.0 database through Context Spine into baseline authority', () => {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-db-upgrade-'));
-  const file = path.join(dir, 'state.db');
-  try {
-    const db = stateDb.openStateDb(file);
-    db.exec(`
-      CREATE TABLE tasks (
-        id TEXT PRIMARY KEY,
-        title TEXT NOT NULL,
-        type TEXT NOT NULL,
-        priority TEXT NOT NULL,
-        complexity INTEGER,
-        status TEXT NOT NULL DEFAULT 'pending',
-        deps TEXT,
-        files_modified TEXT,
-        session_id TEXT,
-        stale INTEGER NOT NULL DEFAULT 0,
-        complexity_hint TEXT,
-        tag TEXT,
-        trace_to TEXT,
-        context_file TEXT,
-        completion_commit TEXT,
-        parent_id TEXT,
-        created_at TEXT NOT NULL,
-        updated_at TEXT NOT NULL
-      );
-      CREATE TABLE events (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        ts TEXT NOT NULL,
-        type TEXT NOT NULL,
-        task_id TEXT,
-        session_id TEXT,
-        runtime TEXT,
-        payload_json TEXT
-      );
-      CREATE TABLE schema_version (
-        version TEXT PRIMARY KEY,
-        applied_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
-        description TEXT
-      );
-      INSERT INTO schema_version (version, applied_at, description)
-      VALUES ('8A.1', '2026-01-01T00:00:00.000Z', 'legacy fixture');
-    `);
-    stateDb.closeStateDb(db);
-
-    const upgraded = stateDb.initStateDb(file);
-    const columns = upgraded.db.prepare('PRAGMA table_info(tasks)').all().map((row) => row.name);
-    assert.ok(columns.includes('estimated_days'));
-    assert.ok(columns.includes('change_id'));
-    const eventColumns = upgraded.db.prepare('PRAGMA table_info(events)').all().map((row) => row.name);
-    assert.ok(eventColumns.includes('change_id'));
-    assert.equal(upgraded.schema_version, '12.0');
-    assert.ok(upgraded.backup_path);
-    assert.ok(fs.existsSync(upgraded.backup_path));
-    assert.ok(upgraded.db.prepare("SELECT 1 FROM schema_version WHERE version = '10.0'").get());
-    const contextColumns = upgraded.db.prepare('PRAGMA table_info(context_snapshots)').all()
-      .map((row) => row.name);
-    for (const column of ['role', 'gate', 'next_action', 'readiness', 'context_json', 'token_budget']) {
-      assert.ok(contextColumns.includes(column), column);
-    }
-    assert.ok(upgraded.db.prepare(
-      "SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'spec_learning_candidates'",
-    ).get());
-    const baseline = upgraded.db.prepare(
-      "SELECT mode, status FROM baselines WHERE id = 'migrated-baseline'",
-    ).get();
-    assert.deepEqual(baseline, { mode: 'migrated', status: 'adopting' });
-    const contextMigration = upgraded.db.prepare(
-      "SELECT from_version, to_version, notes FROM migration_history WHERE to_version = '10.0' ORDER BY id DESC LIMIT 1",
-    ).get();
-    assert.equal(contextMigration.from_version, '9.1');
-    assert.equal(contextMigration.to_version, '10.0');
-    assert.match(contextMigration.notes, /Context Spine/);
-    const baselineMigration = upgraded.db.prepare(
-      "SELECT from_version, to_version, notes FROM migration_history WHERE to_version = '11.0' ORDER BY id DESC LIMIT 1",
-    ).get();
-    assert.equal(baselineMigration.from_version, '10.0');
-    assert.match(baselineMigration.notes, /baseline adoption/i);
-    const adoptionMigration = upgraded.db.prepare(
-      "SELECT from_version, to_version, notes FROM migration_history WHERE to_version = '12.0' ORDER BY id DESC LIMIT 1",
-    ).get();
-    assert.equal(adoptionMigration.from_version, '11.0');
-    assert.match(adoptionMigration.notes, /gap ledger|re-adoption/i);
-    const migrated = upgraded.db.prepare(
-      "SELECT gaps_json, worktree_state FROM baselines WHERE id = 'migrated-baseline'",
-    ).get();
-    assert.equal(migrated.worktree_state, 'unavailable');
-    assert.equal(JSON.parse(migrated.gaps_json)[0].category, 'baseline_blocker');
-    assert.ok(upgraded.db.prepare(
-      "SELECT 1 FROM migration_history WHERE from_version = '8A.1' AND to_version = '9.1' AND notes LIKE '%Kimi%'",
-    ).get());
-    stateDb.closeStateDb(upgraded.db);
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});