ultra-builder-pro-cli 0.5.0

package/mcp-server/tests/init-project.test.cjs

@@ -0,0 +1,141 @@
+'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 { initProject, InitProjectError, DEFAULT_TEMPLATE } = require('../lib/init-project.cjs');
+
+function mkTempDir(prefix = 'ubp-init-test-') {
+  return fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+}
+
+function cleanup(dir) {
+  try { fs.rmSync(dir, { recursive: true, force: true }); } catch (_) { /* best effort */ }
+}
+
+test('initProject copies bundled template into .ultra/', () => {
+  const target = mkTempDir();
+  try {
+    const r = initProject({
+      target_dir: target,
+      project_name: 'demo',
+      project_type: 'cli',
+      stack: 'node',
+    });
+    assert.equal(r.status, 'created');
+    assert.equal(r.created_path, path.join(target, '.ultra'));
+    assert.ok(r.copied_files.includes('tasks/tasks.json'));
+    assert.ok(r.copied_files.includes('specs/product.md'));
+    assert.ok(!r.copied_files.some((f) => f.endsWith('.DS_Store')));
+  } finally { cleanup(target); }
+});
+
+test('initProject injects project metadata into tasks.json', () => {
+  const target = mkTempDir();
+  try {
+    initProject({
+      target_dir: target,
+      project_name: 'meta-demo',
+      project_type: 'web',
+      stack: 'next',
+    });
+    const tasksJson = JSON.parse(fs.readFileSync(path.join(target, '.ultra', 'tasks', 'tasks.json'), 'utf8'));
+    assert.equal(tasksJson.project.name, 'meta-demo');
+    assert.equal(tasksJson.project.type, 'web');
+    assert.equal(tasksJson.project.stack, 'next');
+    assert.ok(tasksJson.created.length > 0);
+    assert.ok(tasksJson.updated.length > 0);
+  } finally { cleanup(target); }
+});
+
+test('initProject refuses when .ultra/ already exists and overwrite=false', () => {
+  const target = mkTempDir();
+  try {
+    initProject({ target_dir: target, project_name: 'first' });
+    assert.throws(
+      () => initProject({ target_dir: target, project_name: 'again' }),
+      (err) => err instanceof InitProjectError && err.code === 'ULTRA_DIR_EXISTS',
+    );
+  } finally { cleanup(target); }
+});
+
+test('initProject with overwrite=true backs up existing .ultra/', () => {
+  const target = mkTempDir();
+  try {
+    initProject({ target_dir: target, project_name: 'first' });
+    const sentinel = path.join(target, '.ultra', 'sentinel.txt');
+    fs.writeFileSync(sentinel, 'before-backup');
+
+    const r = initProject({ target_dir: target, project_name: 'second', overwrite: true });
+    assert.equal(r.status, 'overwritten');
+    assert.ok(r.backup_path);
+    assert.ok(fs.existsSync(path.join(r.backup_path, 'sentinel.txt')));
+    assert.equal(
+      fs.readFileSync(path.join(r.backup_path, 'sentinel.txt'), 'utf8'),
+      'before-backup',
+    );
+    assert.ok(!fs.existsSync(sentinel));
+  } finally { cleanup(target); }
+});
+
+test('initProject rejects empty project_name', () => {
+  const target = mkTempDir();
+  try {
+    assert.throws(
+      () => initProject({ target_dir: target, project_name: '' }),
+      (err) => err instanceof InitProjectError && err.code === 'VALIDATION_ERROR',
+    );
+  } finally { cleanup(target); }
+});
+
+test('initProject rejects missing source_template', () => {
+  const target = mkTempDir();
+  try {
+    assert.throws(
+      () => initProject({
+        target_dir: target,
+        project_name: 'demo',
+        source_template: '/tmp/does-not-exist-ubp-init',
+      }),
+      (err) => err instanceof InitProjectError && err.code === 'TEMPLATE_MISSING',
+    );
+  } finally { cleanup(target); }
+});
+
+test('initProject surface TARGET_NOT_DIR when target_dir is a file', () => {
+  const parent = mkTempDir();
+  const filePath = path.join(parent, 'not-a-dir.txt');
+  fs.writeFileSync(filePath, 'x');
+  try {
+    assert.throws(
+      () => initProject({ target_dir: filePath, project_name: 'demo' }),
+      (err) => err instanceof InitProjectError && err.code === 'TARGET_NOT_DIR',
+    );
+  } finally { cleanup(parent); }
+});
+
+test('copied tree matches bundled templates/.ultra/ (diff-equal excluding .DS_Store)', () => {
+  const target = mkTempDir();
+  try {
+    const r = initProject({ target_dir: target, project_name: 'diff-equal' });
+    const templateFiles = [];
+    (function walk(dir, prefix = '') {
+      for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+        if (e.name === '.DS_Store') continue;
+        const rel = prefix ? path.join(prefix, e.name) : e.name;
+        if (e.isDirectory()) walk(path.join(dir, e.name), rel);
+        else if (e.isFile()) templateFiles.push(rel);
+      }
+    })(DEFAULT_TEMPLATE);
+    assert.deepEqual(r.copied_files.sort(), templateFiles.sort());
+    for (const rel of templateFiles) {
+      if (rel === 'tasks/tasks.json') continue; // metadata injected by design
+      const src = fs.readFileSync(path.join(DEFAULT_TEMPLATE, rel));
+      const dst = fs.readFileSync(path.join(r.created_path, rel));
+      assert.deepEqual(dst, src, `content diff in ${rel}`);
+    }
+  } finally { cleanup(target); }
+});

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

@@ -0,0 +1,144 @@
+'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 REPO_ROOT = path.resolve(__dirname, '..', '..');
+const CLI = path.join(REPO_ROOT, 'ultra-tools', 'cli.cjs');
+const FIXTURE = path.join(REPO_ROOT, 'spec', 'fixtures', 'v4.4-project');
+
+const { openStateDb, closeStateDb } = require('../lib/state-db.cjs');
+
+function tmpProject() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-mig-'));
+  copyRecursive(FIXTURE, dir);
+  return dir;
+}
+
+function copyRecursive(src, dst) {
+  fs.mkdirSync(dst, { recursive: true });
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    const s = path.join(src, entry.name);
+    const d = path.join(dst, entry.name);
+    if (entry.isDirectory()) copyRecursive(s, d);
+    else fs.copyFileSync(s, d);
+  }
+}
+
+function runCli(args, opts = {}) {
+  const r = spawnSync(process.execPath, [CLI, ...args], { encoding: 'utf8', ...opts });
+  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('migrate --dry prints the plan without writing state.db or backups', () => {
+  const dir = tmpProject();
+  try {
+    const dbPath = path.join(dir, '.ultra', 'state.db');
+    const r = runCli(['migrate', '--from=4.4', '--to=4.5', '--dry', '--source-dir', dir]);
+    assert.equal(r.code, 0);
+    assert.equal(r.envelope.ok, true);
+    assert.equal(r.envelope.data.mode, 'dry');
+    assert.equal(r.envelope.data.tasks_to_insert, 3);
+    assert.equal(r.envelope.data.events_to_insert, 6);
+    assert.equal(r.envelope.data.warnings.length, 1, 'task-3 status mismatch must be flagged');
+    assert.equal(r.envelope.data.warnings[0].task_id, 'task-3');
+    assert.equal(fs.existsSync(dbPath), false, 'dry must not create state.db');
+    const ultraEntries = fs.readdirSync(path.join(dir, '.ultra'));
+    assert.equal(ultraEntries.some((n) => n.startsWith('backup-v4.4-')), false, 'dry must not create a backup');
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('migrate forward inserts tasks + events, records migration_history, creates backup', () => {
+  const dir = tmpProject();
+  try {
+    const dbPath = path.join(dir, '.ultra', 'state.db');
+    const r = runCli(['migrate', '--from=4.4', '--to=4.5', '--source-dir', dir]);
+    assert.equal(r.code, 0);
+    assert.equal(r.envelope.ok, true);
+    assert.equal(r.envelope.data.mode, 'apply');
+    assert.equal(r.envelope.data.tasks_inserted, 3);
+    assert.equal(r.envelope.data.events_inserted, 6);
+    assert.ok(fs.existsSync(r.envelope.data.backup_dir), 'backup dir must exist');
+    assert.ok(fs.existsSync(dbPath), 'state.db must be written');
+
+    const db = openStateDb(dbPath);
+    const taskIds = db.prepare('SELECT id FROM tasks ORDER BY id').all().map((r) => r.id);
+    assert.deepEqual(taskIds, ['task-1', 'task-2', 'task-3']);
+
+    // Status comes from tasks.json (task-3 = pending), not the context md (blocked)
+    const t3 = db.prepare("SELECT status FROM tasks WHERE id = 'task-3'").get();
+    assert.equal(t3.status, 'pending');
+
+    const eventCount = db.prepare('SELECT COUNT(*) AS n FROM events').get().n;
+    assert.equal(eventCount, 6);
+
+    const mig = db.prepare("SELECT direction, status FROM migration_history ORDER BY id").all();
+    assert.equal(mig.length, 1);
+    assert.equal(mig[0].direction, 'forward');
+    assert.equal(mig[0].status, 'success');
+    closeStateDb(db);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('migrate --rollback restores .ultra contents and writes a rollback row', () => {
+  const dir = tmpProject();
+  try {
+    const dbPath = path.join(dir, '.ultra', 'state.db');
+    const fwd = runCli(['migrate', '--from=4.4', '--to=4.5', '--source-dir', dir]);
+    assert.equal(fwd.code, 0);
+
+    // Capture rollback audit BEFORE the db file is removed by reading from the
+    // backup snapshot we'll restore from.
+    const backupDir = fwd.envelope.data.backup_dir;
+
+    const back = runCli(['migrate', '--from=4.4', '--to=4.5', '--rollback', '--source-dir', dir]);
+    assert.equal(back.code, 0);
+    assert.equal(back.envelope.ok, true);
+    assert.equal(back.envelope.data.mode, 'rollback');
+    assert.equal(back.envelope.data.backup_dir, backupDir);
+
+    // state.db is gone
+    assert.equal(fs.existsSync(dbPath), false);
+
+    // .ultra/tasks/tasks.json restored to original v4.4 content
+    const tasksJson = JSON.parse(fs.readFileSync(path.join(dir, '.ultra', 'tasks', 'tasks.json'), 'utf8'));
+    assert.equal(tasksJson.schema_version, '4.4');
+    assert.equal(tasksJson.tasks.length, 3);
+    closeStateDb(undefined);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('migrate rejects unsupported --from / --to versions', () => {
+  const r1 = runCli(['migrate', '--from=3.0', '--to=4.5', '--dry', '--source-dir', FIXTURE]);
+  assert.equal(r1.code, 1);
+  assert.equal(r1.envelope.error.code, 'UNSUPPORTED_VERSION');
+
+  const r2 = runCli(['migrate', '--from=4.4', '--to=5.0', '--dry', '--source-dir', FIXTURE]);
+  assert.equal(r2.code, 1);
+  assert.equal(r2.envelope.error.code, 'UNSUPPORTED_VERSION');
+});
+
+test('migrate forward fails cleanly when tasks.json is missing', () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-mig-empty-'));
+  fs.mkdirSync(path.join(dir, '.ultra'), { recursive: true });
+  try {
+    const r = runCli(['migrate', '--from=4.4', '--to=4.5', '--source-dir', dir]);
+    assert.equal(r.code, 2);
+    assert.equal(r.envelope.error.code, 'MIGRATE_FAILED');
+    assert.match(r.envelope.error.message, /tasks\.json missing/);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});

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

@@ -0,0 +1,130 @@
+'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 Ajv = require('ajv/dist/2020');
+const addFormats = require('ajv-formats');
+
+const REPO_ROOT = path.resolve(__dirname, '..', '..');
+const TASKS_SCHEMA = path.join(REPO_ROOT, 'spec', 'schemas', 'tasks.v4.5.schema.json');
+
+const { initStateDb, closeStateDb } = require('../lib/state-db.cjs');
+const ops = require('../lib/state-ops.cjs');
+const projector = require('../lib/projector.cjs');
+
+const ajv = new Ajv({ allErrors: true, strict: false });
+addFormats(ajv);
+const validateTasksJson = ajv.compile(JSON.parse(fs.readFileSync(TASKS_SCHEMA, 'utf8')));
+
+function tmpProject() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-proj-'));
+  const dbPath = path.join(dir, '.ultra', 'state.db');
+  const init = initStateDb(dbPath);
+  return { dir, dbPath, db: init.db };
+}
+
+function readJson(p) {
+  return JSON.parse(fs.readFileSync(p, 'utf8'));
+}
+
+test('projectTasks emits a v4.5-conformant tasks.json', () => {
+  const { dir, db } = tmpProject();
+  try {
+    ops.createTask(db, { id: 'p-1', title: 'first', type: 'feature', priority: 'P1', tag: 'main' });
+    ops.createTask(db, { id: 'p-2', title: 'second', type: 'bugfix', priority: 'P2' });
+    ops.updateTaskStatus(db, 'p-1', 'in_progress');
+
+    const out = projector.projectTasks(db, {}, { rootDir: dir });
+    assert.equal(out.count, 2);
+
+    const projection = readJson(out.path);
+    assert.equal(projection.schema_version, '4.5');
+    assert.equal(projection.source, '.ultra/state.db');
+    assert.equal(projection.tasks.length, 2);
+    assert.ok(validateTasksJson(projection), `ajv failed: ${ajv.errorsText(validateTasksJson.errors)}`);
+
+    const p1 = projection.tasks.find((t) => t.id === 'p-1');
+    assert.equal(p1.status, 'in_progress');
+    closeStateDb(db);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('projectContext rebuilds header but preserves the body', () => {
+  const { dir, db } = tmpProject();
+  try {
+    ops.createTask(db, { id: 'cx-1', title: 'context test', type: 'feature', priority: 'P1' });
+    const ctxFile = path.join(dir, '.ultra', 'tasks', 'contexts', 'task-cx-1.md');
+    fs.mkdirSync(path.dirname(ctxFile), { recursive: true });
+    fs.writeFileSync(ctxFile, '---\nstale: header\n---\n\n# body that must survive\n\nUser notes go here.\n');
+
+    ops.updateTaskStatus(db, 'cx-1', 'in_progress');
+    projector.projectContext(db, 'cx-1', {}, { rootDir: dir });
+
+    const text = fs.readFileSync(ctxFile, 'utf8');
+    assert.match(text, /^---\n/, 'must start with frontmatter');
+    assert.match(text, /status: in_progress/);
+    assert.match(text, /schema_version: 4\.5/);
+    assert.match(text, /# body that must survive/);
+    assert.match(text, /User notes go here\./);
+    closeStateDb(db);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('manual edits to tasks.json are overwritten on the next projectAll', () => {
+  const { dir, db } = tmpProject();
+  try {
+    ops.createTask(db, { id: 'ow-1', title: 'overwrite', type: 'feature', priority: 'P0' });
+    projector.projectAll(db, { rootDir: dir });
+
+    const tasksJson = path.join(dir, '.ultra', 'tasks', 'tasks.json');
+    fs.writeFileSync(tasksJson, JSON.stringify({ tampered: true }));
+    assert.deepEqual(readJson(tasksJson), { tampered: true });
+
+    ops.patchTask(db, 'ow-1', { tag: 'main' });
+    projector.projectAll(db, { rootDir: dir });
+
+    const restored = readJson(tasksJson);
+    assert.equal(restored.schema_version, '4.5');
+    assert.equal(restored.tasks[0].id, 'ow-1');
+    closeStateDb(db);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('projectAll completes within 1s after a state.db write (PLAN AC)', () => {
+  const { dir, db } = tmpProject();
+  try {
+    for (let i = 0; i < 30; i++) {
+      ops.createTask(db, { id: `s-${i}`, title: `s${i}`, type: 'feature', priority: 'P3' });
+    }
+    const start = Date.now();
+    const out = projector.projectAll(db, { rootDir: dir });
+    const elapsed = Date.now() - start;
+    assert.ok(elapsed <= 1000, `projectAll took ${elapsed}ms, must be <= 1000ms`);
+    assert.equal(out.tasks_json.count, 30);
+    assert.equal(out.contexts.length, 30);
+    closeStateDb(db);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('projectContext is a no-op for unknown task ids', () => {
+  const { dir, db } = tmpProject();
+  try {
+    const r = projector.projectContext(db, 'no-such-task', {}, { rootDir: dir });
+    assert.equal(r, null);
+    closeStateDb(db);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});