ultra-builder-pro-cli 0.14.0 → 0.15.0

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 });
-  }
-});

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

@@ -1,393 +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 { execFileSync } = require('node:child_process');
-const Database = require('better-sqlite3');
-
-const {
-  initProject, InitProjectError, DEFAULT_TEMPLATE, classifyRepository,
-} = require('../lib/init-project.cjs');
-const { EXPECTED_VERSION } = require('../lib/state-db.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.mode, 'greenfield');
-    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.includes('changes/active/.gitkeep'));
-    assert.ok(r.copied_files.includes('changes/archive/.gitkeep'));
-    assert.equal(r.state_db_path, path.join(target, '.ultra', 'state.db'));
-    assert.ok(fs.existsSync(r.state_db_path));
-    const db = new Database(r.state_db_path, { readonly: true });
-    try {
-      const version = db.prepare('SELECT version FROM schema_version WHERE version = ?').get(EXPECTED_VERSION);
-      assert.equal(version.version, EXPECTED_VERSION);
-      assert.ok(db.prepare("SELECT name FROM sqlite_master WHERE name = 'changes'").get());
-      const baseline = db.prepare('SELECT mode, status, project_name FROM baselines').get();
-      assert.deepEqual(baseline, { mode: 'greenfield', status: 'draft', project_name: 'demo' });
-    } finally {
-      db.close();
-    }
-    assert.ok(!r.copied_files.some((f) => f.endsWith('.DS_Store')));
-  } finally { cleanup(target); }
-});
-
-test('initProject auto-detects existing source as brownfield and starts adoption', () => {
-  const target = mkTempDir();
-  try {
-    fs.mkdirSync(path.join(target, 'src'));
-    fs.writeFileSync(path.join(target, 'package.json'), '{"name":"legacy-app"}\n');
-    fs.writeFileSync(path.join(target, 'src', 'index.js'), 'module.exports = true;\n');
-    const result = initProject({ target_dir: target, project_name: 'legacy-app' });
-    assert.equal(result.mode, 'brownfield');
-    const db = new Database(result.state_db_path, { readonly: true });
-    try {
-      const baseline = db.prepare('SELECT mode, status, scope_json FROM baselines').get();
-      assert.equal(baseline.mode, 'brownfield');
-      assert.equal(baseline.status, 'adopting');
-      assert.deepEqual(JSON.parse(baseline.scope_json), ['.']);
-    } finally {
-      db.close();
-    }
-  } finally { cleanup(target); }
-});
-
-test('auto classification keeps a documentation-and-manifest-only skeleton greenfield', () => {
-  const target = mkTempDir();
-  try {
-    fs.writeFileSync(path.join(target, 'README.md'), '# New service skeleton\n');
-    fs.writeFileSync(path.join(target, 'package.json'), JSON.stringify({
-      name: 'new-service', private: true, scripts: { test: 'node --test' },
-    }));
-    const profile = classifyRepository(target);
-    assert.equal(profile.mode, 'greenfield');
-    assert.equal(profile.repository_kind, 'single');
-    assert.deepEqual(profile.source_signals, []);
-
-    const result = initProject({ target_dir: target, project_name: 'new-service' });
-    assert.equal(result.mode, 'greenfield');
-    assert.deepEqual(result.repository_profile.verification_commands, ['npm test']);
-  } finally { cleanup(target); }
-});
-
-test('auto classification records bounded monorepo evidence for brownfield adoption', () => {
-  const target = mkTempDir();
-  try {
-    fs.mkdirSync(path.join(target, 'packages', 'api', 'src'), { recursive: true });
-    fs.writeFileSync(path.join(target, 'package.json'), JSON.stringify({
-      name: 'legacy-suite', private: true, workspaces: ['packages/*'],
-      scripts: { build: 'turbo build', test: 'turbo test', lint: 'turbo lint' },
-    }));
-    fs.writeFileSync(path.join(target, 'packages', 'api', 'package.json'), '{"name":"api"}\n');
-    fs.writeFileSync(path.join(target, 'packages', 'api', 'src', 'index.js'), 'module.exports = true;\n');
-    fs.writeFileSync(path.join(target, 'Dockerfile'), 'FROM node:22\n');
-
-    const result = initProject({ target_dir: target, project_name: 'legacy-suite' });
-    assert.equal(result.mode, 'brownfield');
-    assert.equal(result.repository_profile.repository_kind, 'monorepo');
-    assert.deepEqual(result.repository_profile.workspace_roots, ['packages/api']);
-    assert.ok(result.repository_profile.source_signals.includes('packages/api/src/index.js'));
-    assert.ok(result.repository_profile.deployment_signals.includes('Dockerfile'));
-    assert.deepEqual(
-      result.repository_profile.verification_commands,
-      ['npm run build', 'npm test', 'npm run lint'],
-    );
-
-    const db = new Database(result.state_db_path, { readonly: true });
-    try {
-      const row = db.prepare(
-        'SELECT repository_branch, worktree_state, classification_json FROM baselines',
-      ).get();
-      assert.equal(row.repository_branch, null);
-      assert.equal(row.worktree_state, 'unavailable');
-      assert.equal(JSON.parse(row.classification_json).repository_kind, 'monorepo');
-    } finally { db.close(); }
-  } finally { cleanup(target); }
-});
-
-test('brownfield initialization persists an explicitly selected monorepo scope', () => {
-  const target = mkTempDir();
-  try {
-    fs.mkdirSync(path.join(target, 'packages', 'api', 'src'), { recursive: true });
-    fs.mkdirSync(path.join(target, 'packages', 'web', 'src'), { recursive: true });
-    fs.writeFileSync(path.join(target, 'package.json'), JSON.stringify({
-      name: 'legacy-suite', private: true, workspaces: ['packages/*'],
-    }));
-    fs.writeFileSync(path.join(target, 'packages', 'api', 'src', 'index.js'), 'module.exports = true;\n');
-    fs.writeFileSync(path.join(target, 'packages', 'web', 'src', 'index.js'), 'module.exports = true;\n');
-
-    const result = initProject({
-      target_dir: target,
-      project_name: 'legacy-suite',
-      scope: ['packages/api'],
-    });
-
-    const db = new Database(result.state_db_path, { readonly: true });
-    try {
-      const baseline = db.prepare('SELECT scope_json FROM baselines').get();
-      assert.deepEqual(JSON.parse(baseline.scope_json), ['packages/api']);
-      assert.deepEqual(result.baseline.scope, ['packages/api']);
-    } finally { db.close(); }
-  } finally { cleanup(target); }
-});
-
-test('maintenance CLI forwards an explicit initialization mode', () => {
-  const target = mkTempDir();
-  try {
-    fs.writeFileSync(path.join(target, 'README.md'), '# Intentional greenfield notes\n');
-    const output = execFileSync(process.execPath, [
-      path.resolve(__dirname, '..', '..', 'ultra-tools', 'cli.cjs'),
-      'task', 'init-project', '--target-dir', target, '--project-name', 'explicit-mode',
-      '--mode', 'greenfield',
-    ], { encoding: 'utf8' });
-    const envelope = JSON.parse(output);
-    assert.equal(envelope.ok, true);
-    assert.equal(envelope.data.mode, 'greenfield');
-  } finally { cleanup(target); }
-});
-
-test('initProject keeps project metadata in authoritative baseline state and tasks.json as a projection', () => {
-  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.schema_version, '4.5');
-    assert.equal(tasksJson.source, '.ultra/state.db');
-    assert.deepEqual(tasksJson.tasks, []);
-    assert.equal('project' in tasksJson, false);
-    const db = new Database(path.join(target, '.ultra', 'state.db'), { readonly: true });
-    try {
-      const baseline = db.prepare('SELECT project_name, project_type, stack FROM baselines').get();
-      assert.deepEqual(baseline, { project_name: 'meta-demo', project_type: 'web', stack: 'next' });
-    } finally {
-      db.close();
-    }
-  } finally { cleanup(target); }
-});
-
-test('initProject records the declared project_initialized lifecycle event', () => {
-  const rootDir = mkTempDir();
-  try {
-    const result = initProject({ target_dir: rootDir, project_name: 'events-fixture' });
-    const db = new Database(result.state_db_path, { readonly: true });
-    try {
-      const events = db.prepare('SELECT type, payload_json FROM events ORDER BY id').all();
-      assert.deepEqual(events.map((row) => row.type), ['baseline_started', 'project_initialized']);
-      assert.deepEqual(JSON.parse(events[1].payload_json), {
-        project_name: 'events-fixture', mode: 'greenfield', baseline_id: 'project-baseline',
-      });
-    } finally {
-      db.close();
-    }
-  } finally {
-    fs.rmSync(rootDir, { recursive: true, force: true });
-  }
-});
-
-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 resume preserves existing artifacts and installs only missing current scaffold files', () => {
-  const target = mkTempDir();
-  try {
-    fs.mkdirSync(path.join(target, '.ultra', 'specs'), { recursive: true });
-    fs.writeFileSync(path.join(target, '.ultra', 'specs', 'product.md'), '# Existing product contract\n');
-
-    const result = initProject({
-      target_dir: target, project_name: 'existing-project', mode: 'brownfield', resume: true,
-    });
-    assert.equal(result.status, 'resumed');
-    assert.equal(
-      fs.readFileSync(path.join(target, '.ultra', 'specs', 'product.md'), 'utf8'),
-      '# Existing product contract\n',
-    );
-    assert.ok(fs.existsSync(path.join(target, '.ultra', 'specs', 'architecture.md')));
-    assert.ok(result.copied_files.includes('specs/architecture.md'));
-    assert.equal(result.copied_files.includes('specs/product.md'), false);
-
-    const second = initProject({
-      target_dir: target, project_name: 'existing-project', resume: true,
-    });
-    assert.equal(second.status, 'resumed');
-    assert.deepEqual(second.copied_files, []);
-    const db = new Database(result.state_db_path, { readonly: true });
-    try {
-      assert.equal(db.prepare('SELECT COUNT(*) AS count FROM baselines').get().count, 1);
-    } finally { db.close(); }
-  } finally { cleanup(target); }
-});
-
-test('initProject resume refuses projection-only tasks until the supported import runs', () => {
-  const target = mkTempDir();
-  try {
-    fs.mkdirSync(path.join(target, '.ultra', 'tasks'), { recursive: true });
-    fs.writeFileSync(path.join(target, '.ultra', 'tasks', 'tasks.json'), JSON.stringify({
-      schema_version: '4.5', source: '.ultra/state.db',
-      tasks: [{ id: 'legacy', title: 'Legacy task', type: 'feature', priority: 'P1', status: 'pending' }],
-    }));
-    assert.throws(
-      () => initProject({ target_dir: target, project_name: 'legacy', resume: true }),
-      (error) => error.code === 'LEGACY_STATE_MIGRATION_REQUIRED'
-        && /--from=4\.5 --to=12\.0/.test(error.message),
-    );
-    assert.equal(fs.existsSync(path.join(target, '.ultra', 'state.db')), false);
-    assert.equal(fs.existsSync(path.join(target, '.ultra', 'specs', 'product.md')), false);
-  } finally { cleanup(target); }
-});
-
-test('initProject rejects conflicting resume and overwrite modes', () => {
-  const target = mkTempDir();
-  try {
-    fs.mkdirSync(path.join(target, '.ultra'));
-    assert.throws(
-      () => initProject({
-        target_dir: target, project_name: 'conflict', resume: true, overwrite: true,
-      }),
-      (error) => error.code === 'VALIDATION_ERROR' && /resume.*overwrite/i.test(error.message),
-    );
-  } 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 restores the prior .ultra when overwrite initialization fails', () => {
-  const target = mkTempDir();
-  const badTemplate = mkTempDir('ubp-bad-template-');
-  try {
-    initProject({ target_dir: target, project_name: 'first' });
-    fs.writeFileSync(path.join(target, '.ultra', 'sentinel.txt'), 'restore-me');
-    fs.cpSync(DEFAULT_TEMPLATE, badTemplate, { recursive: true });
-    fs.writeFileSync(path.join(badTemplate, 'tasks', 'tasks.json'), '{not-json\n');
-
-    assert.throws(
-      () => initProject({
-        target_dir: target,
-        project_name: 'broken-overwrite',
-        overwrite: true,
-        source_template: badTemplate,
-      }),
-      (error) => error instanceof InitProjectError && error.code === 'IO_ERROR',
-    );
-    assert.equal(
-      fs.readFileSync(path.join(target, '.ultra', 'sentinel.txt'), 'utf8'),
-      'restore-me',
-    );
-    assert.equal(
-      fs.readdirSync(target).some((name) => name.startsWith('.ultra.backup.')),
-      false,
-    );
-  } finally {
-    cleanup(target);
-    cleanup(badTemplate);
-  }
-});
-
-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); }
-});