ultra-builder-pro-cli 0.12.1 → 0.13.0

package/mcp-server/server.cjs

@@ -148,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': {
@@ -286,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;
@@ -324,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 };
     }

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

@@ -8,7 +8,9 @@ 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-') {
@@ -71,6 +73,85 @@ test('initProject auto-detects existing source as brownfield and starts adoption
   } 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 {
@@ -110,6 +191,25 @@ test('initProject keeps project metadata in authoritative baseline state and tas
   } 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 {
@@ -121,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 {