ultra-builder-pro-cli 0.11.0 → 0.13.0

package/mcp-server/server.cjs

@@ -28,6 +28,7 @@ const parser = require('./lib/prd-parser.cjs');
 const expander = require('./lib/task-expander.cjs');
 const planStore = require('./lib/plan-store.cjs');
 const { initProject } = require('./lib/init-project.cjs');
+const baselines = require('./lib/baseline-workflow.cjs');
 const changes = require('./lib/change-workflow.cjs');
 const runtimeState = require('./lib/runtime-state.cjs');
 const doctor = require('./lib/doctor.cjs');
@@ -67,6 +68,13 @@ const PLAN_TOOLS = Object.freeze([
   'plan.get',
 ]);
 
+const BASELINE_TOOLS = Object.freeze([
+  'baseline.start',
+  'baseline.record',
+  'baseline.get',
+  'baseline.converge',
+]);
+
 const CHANGE_TOOLS = Object.freeze([
   'change.create',
   'change.update',
@@ -85,18 +93,20 @@ const SYSTEM_TOOLS = Object.freeze([
 ]);
 
 const REGISTERED_TOOLS = Object.freeze([
-  ...TASK_TOOLS, ...SESSION_TOOLS, ...PLAN_TOOLS, ...CHANGE_TOOLS, ...SYSTEM_TOOLS,
+  ...TASK_TOOLS, ...SESSION_TOOLS, ...PLAN_TOOLS, ...BASELINE_TOOLS, ...CHANGE_TOOLS,
+  ...SYSTEM_TOOLS,
 ]);
 
 const STATELESS_TOOLS = new Set(['task.init_project']);
 
-// init_project mutates the filesystem of an unrelated project, not state.db —
-// do NOT run the projector (it would overwrite the freshly-copied template).
+// init_project owns its target project's schema, baseline seed, and first
+// projection internally. Do not enqueue a second projection on the caller DB.
 const MUTATING_TOOLS = new Set([
   'task.create', 'task.update', 'task.delete', 'task.append_event', 'task.switch_tag',
   'task.parse_prd', 'task.expand',
   'session.spawn', 'session.close', 'session.heartbeat',
   'plan.export',
+  'baseline.start', 'baseline.record', 'baseline.converge',
   'change.create', 'change.update', 'change.context', 'change.converge', 'change.archive',
   'change.learning_propose', 'change.learning_resolve',
 ]);
@@ -138,7 +148,10 @@ async function dispatchTool(name, input, db, ctx = {}) {
     case 'task.create': {
       const { randomUUID } = require('node:crypto');
       const id = input.id || `task-${randomUUID()}`;
-      const task = ops.createTask(db, { ...input, id });
+      const changeId = ops.resolveTaskCreationChangeId(db, input);
+      const authorizedInput = { ...input, change_id: changeId };
+      changes.assertTaskCreationAllowed(db, authorizedInput, { rootDir: ctx.rootDir || process.cwd() });
+      const task = ops.createTask(db, { ...authorizedInput, id });
       return { id: task.id, status: task.status, created_at: task.created_at };
     }
     case 'task.update': {
@@ -276,20 +289,25 @@ async function dispatchTool(name, input, db, ctx = {}) {
         err.code = 'NO_INPUT';
         throw err;
       }
+      const dryRun = input.dry_run === true;
+      const rootDir = ctx.rootDir || process.cwd();
+      const creationAuthority = { change_id: input.change_id };
+      if (!dryRun) changes.assertTaskCreationAllowed(db, creationAuthority, { rootDir });
       const client = buildLlmClient(ctx);
       const parsed = await parser.parsePrd(prdText, { llmClient: client, tag: input.tag });
       const shaped = parsed.tasks.map((t) => ({
         id: t.id, title: t.title, type: t.type, priority: t.priority,
         complexity: t.complexity, deps: t.deps, files_modified: t.files_modified,
-        tag: t.tag,
+        tag: t.tag, change_id: input.change_id,
       }));
-      const dryRun = input.dry_run === true;
       if (!dryRun) {
         try {
           ops.tx(db, () => {
+            changes.assertTaskCreationAllowed(db, creationAuthority, { rootDir });
             for (const t of shaped) ops.createTask(db, t);
           });
         } catch (err) {
+          if (['BASELINE_NOT_READY', 'CHANGE_NOT_FOUND', 'CHANGE_NOT_MUTABLE'].includes(err.code)) throw err;
           const wrap = new Error(`failed to persist parsed tasks: ${err.message}`);
           wrap.code = 'PARSE_FAILED';
           wrap.cause = err;
@@ -314,12 +332,15 @@ async function dispatchTool(name, input, db, ctx = {}) {
         err.code = 'ALREADY_EXPANDED';
         throw err;
       }
+      const rootDir = ctx.rootDir || process.cwd();
+      changes.assertTaskCreationAllowed(db, { change_id: parent.change_id }, { rootDir });
       const client = buildLlmClient(ctx);
       const result = await expander.expandTask(db, {
         id: input.id,
         sub_count: input.sub_count,
         strategy: input.strategy,
         llmClient: client,
+        rootDir,
       });
       return { parent_id: result.parent_id, children: result.children };
     }
@@ -352,6 +373,39 @@ async function dispatchTool(name, input, db, ctx = {}) {
       }
       return { plan: planStore.selectSection(loaded, input.section) };
     }
+    case 'baseline.start': {
+      return {
+        baseline: baselines.startBaseline(
+          db, input, { rootDir: ctx.rootDir || process.cwd() },
+        ),
+      };
+    }
+    case 'baseline.record': {
+      return {
+        baseline: baselines.recordBaseline(
+          db, input, { rootDir: ctx.rootDir || process.cwd() },
+        ),
+      };
+    }
+    case 'baseline.get': {
+      const baseline = baselines.readBaseline(db, input.id);
+      if (!baseline) {
+        const err = new Error(input.id ? `baseline ${input.id} not found` : 'current baseline not found');
+        err.code = 'BASELINE_NOT_FOUND';
+        throw err;
+      }
+      return {
+        baseline,
+        health: baselines.inspectBaseline(db, {
+          rootDir: ctx.rootDir || process.cwd(), id: input.id,
+        }),
+      };
+    }
+    case 'baseline.converge': {
+      return baselines.convergeBaseline(
+        db, input, { rootDir: ctx.rootDir || process.cwd() },
+      );
+    }
     case 'change.create': {
       const { randomUUID } = require('node:crypto');
       const id = input.id || `chg-${randomUUID().slice(0, 12)}`;
@@ -598,6 +652,8 @@ module.exports = {
   dispatchTool,
   TASK_TOOLS,
   SESSION_TOOLS,
+  PLAN_TOOLS,
+  BASELINE_TOOLS,
   CHANGE_TOOLS,
   SYSTEM_TOOLS,
   REGISTERED_TOOLS,

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

@@ -5,9 +5,13 @@ 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 } = require('../lib/init-project.cjs');
+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));
@@ -27,6 +31,7 @@ test('initProject copies bundled template into .ultra/', () => {
       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'));
@@ -36,9 +41,11 @@ test('initProject copies bundled template into .ultra/', () => {
     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 = '9.1'").get();
-      assert.equal(version.version, '9.1');
+      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();
     }
@@ -46,7 +53,121 @@ test('initProject copies bundled template into .ultra/', () => {
   } finally { cleanup(target); }
 });
 
-test('initProject injects project metadata into tasks.json', () => {
+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({
@@ -56,14 +177,39 @@ test('initProject injects project metadata into tasks.json', () => {
       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);
+    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 {
@@ -75,6 +221,67 @@ test('initProject refuses when .ultra/ already exists and overwrite=false', () =
   } 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 {

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

@@ -122,6 +122,39 @@ test('migrate forward inserts tasks + events, records migration_history, creates
   }
 });
 
+test('migrate imports a v4.5 projection into schema 12 authority and requires evidence-backed re-adoption', () => {
+  const dir = tmpProject();
+  try {
+    const tasksPath = path.join(dir, '.ultra', 'tasks', 'tasks.json');
+    const projection = JSON.parse(fs.readFileSync(tasksPath, 'utf8'));
+    delete projection.version;
+    projection.schema_version = '4.5';
+    projection.source = '.ultra/state.db';
+    fs.writeFileSync(tasksPath, `${JSON.stringify(projection, null, 2)}\n`);
+
+    const r = runCli(['migrate', '--from=4.5', '--to=12.0', '--source-dir', dir]);
+    assert.equal(r.code, 0);
+    assert.equal(r.envelope.data.from, '4.5');
+    assert.equal(r.envelope.data.to, '12.0');
+    assert.match(path.basename(r.envelope.data.backup_dir), /^backup-v4\.5-/);
+
+    const db = openStateDb(path.join(dir, '.ultra', 'state.db'));
+    try {
+      assert.equal(db.prepare('SELECT COUNT(*) AS count FROM tasks').get().count, 3);
+      const baseline = db.prepare(
+        "SELECT mode, status, gaps_json FROM baselines WHERE id = 'migrated-baseline'",
+      ).get();
+      assert.deepEqual(
+        { mode: baseline.mode, status: baseline.status },
+        { mode: 'migrated', status: 'adopting' },
+      );
+      assert.equal(JSON.parse(baseline.gaps_json)[0].id, 'legacy-rebaseline-required');
+    } finally { 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 {