nubos-pilot 0.7.0 → 0.7.2

package/lib/todo.test.cjs

@@ -0,0 +1,179 @@
+'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 { renderTodoMd, todoPath, STATUS_CHECKBOX } = require('./todo.cjs');
+const { setTaskStatus } = require('./tasks.cjs');
+
+function _writeTask(root, mNum, sNum, tNum, status, name) {
+  const mId = 'M' + String(mNum).padStart(3, '0');
+  const sId = 'S' + String(sNum).padStart(3, '0');
+  const tId = 'T' + String(tNum).padStart(4, '0');
+  const fullId = mId + '-' + sId + '-' + tId;
+  const dir = path.join(root, '.nubos-pilot', 'milestones', mId, 'slices', sId, 'tasks', tId);
+  fs.mkdirSync(dir, { recursive: true });
+  const fm = [
+    '---',
+    'id: "' + fullId + '"',
+    'slice: "' + mId + '-' + sId + '"',
+    'milestone: "' + mId + '"',
+    'type: execute',
+    'status: ' + status,
+    'tier: sonnet',
+    'owner: np-executor',
+    'wave: 1',
+    'depends_on: []',
+    'files_modified: []',
+    'autonomous: true',
+    'must_haves: {}',
+    '---',
+    '',
+    '# ' + fullId + ' — ' + name,
+    '',
+  ].join('\n');
+  const file = path.join(dir, tId + '-PLAN.md');
+  fs.writeFileSync(file, fm, 'utf-8');
+  return { fullId, sliceFullId: mId + '-' + sId, file };
+}
+
+function _sandbox() {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'np-todo-'));
+  fs.mkdirSync(path.join(root, '.nubos-pilot'), { recursive: true });
+  return root;
+}
+
+test('TD-1: renderTodoMd writes TODO.md under slice dir', () => {
+  const root = _sandbox();
+  try {
+    const { sliceFullId } = _writeTask(root, 1, 1, 1, 'pending', 'First task');
+    const target = renderTodoMd(sliceFullId, root);
+    assert.equal(target, path.join(root, '.nubos-pilot', 'milestones', 'M001', 'slices', 'S001', 'TODO.md'));
+    assert.ok(fs.existsSync(target), 'TODO.md must exist');
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('TD-2: frontmatter contains correct counts', () => {
+  const root = _sandbox();
+  try {
+    _writeTask(root, 1, 1, 1, 'pending', 'A');
+    _writeTask(root, 1, 1, 2, 'in-progress', 'B');
+    _writeTask(root, 1, 1, 3, 'done', 'C');
+    _writeTask(root, 1, 1, 4, 'done', 'D');
+    _writeTask(root, 1, 1, 5, 'skipped', 'E');
+    _writeTask(root, 1, 1, 6, 'parked', 'F');
+    renderTodoMd('M001-S001', root);
+    const raw = fs.readFileSync(todoPath('M001-S001', root), 'utf-8');
+    assert.match(raw, /total:\s*6/);
+    assert.match(raw, /pending:\s*1/);
+    assert.match(raw, /in_progress:\s*1/);
+    assert.match(raw, /done:\s*2/);
+    assert.match(raw, /skipped:\s*1/);
+    assert.match(raw, /parked:\s*1/);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('TD-3: each status renders its correct checkbox', () => {
+  const root = _sandbox();
+  try {
+    _writeTask(root, 2, 1, 1, 'pending', 'P');
+    _writeTask(root, 2, 1, 2, 'in-progress', 'IP');
+    _writeTask(root, 2, 1, 3, 'done', 'D');
+    _writeTask(root, 2, 1, 4, 'skipped', 'S');
+    _writeTask(root, 2, 1, 5, 'parked', 'K');
+    renderTodoMd('M002-S001', root);
+    const raw = fs.readFileSync(todoPath('M002-S001', root), 'utf-8');
+    assert.match(raw, /- \[ \] \*\*M002-S001-T0001\*\* — P/);
+    assert.match(raw, /- \[~\] \*\*M002-S001-T0002\*\* — IP/);
+    assert.match(raw, /- \[x\] \*\*M002-S001-T0003\*\* — D/);
+    assert.match(raw, /- \[-\] \*\*M002-S001-T0004\*\* — S/);
+    assert.match(raw, /- \[!\] \*\*M002-S001-T0005\*\* — K/);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('TD-4: empty slice renders "No tasks yet." placeholder', () => {
+  const root = _sandbox();
+  try {
+    fs.mkdirSync(path.join(root, '.nubos-pilot', 'milestones', 'M003', 'slices', 'S001', 'tasks'), { recursive: true });
+    renderTodoMd('M003-S001', root);
+    const raw = fs.readFileSync(todoPath('M003-S001', root), 'utf-8');
+    assert.match(raw, /_No tasks yet\._/);
+    assert.match(raw, /total:\s*0/);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('TD-5: task name extracted from H1 after em-dash', () => {
+  const root = _sandbox();
+  try {
+    _writeTask(root, 4, 1, 1, 'pending', 'Implement feature X');
+    renderTodoMd('M004-S001', root);
+    const raw = fs.readFileSync(todoPath('M004-S001', root), 'utf-8');
+    assert.match(raw, /\*\*M004-S001-T0001\*\* — Implement feature X/);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('TD-6: setTaskStatus triggers auto-render of TODO.md', () => {
+  const root = _sandbox();
+  try {
+    const { fullId, sliceFullId } = _writeTask(root, 5, 1, 1, 'pending', 'Task one');
+    setTaskStatus(fullId, 'in-progress', root);
+    const raw = fs.readFileSync(todoPath(sliceFullId, root), 'utf-8');
+    assert.match(raw, /- \[~\] \*\*M005-S001-T0001\*\* — Task one/);
+    assert.match(raw, /in_progress:\s*1/);
+    assert.match(raw, /pending:\s*0/);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('TD-7: renderTodoMd rejects malformed slice full-id', () => {
+  assert.throws(
+    () => renderTodoMd('not-a-slice-id', '/tmp'),
+    (err) => err.name === 'NubosPilotError' && err.code === 'layout-invalid-id',
+  );
+});
+
+test('TD-8: renderTodoMd rejects missing sliceFullId', () => {
+  assert.throws(
+    () => renderTodoMd(null, '/tmp'),
+    (err) => err.name === 'NubosPilotError' && err.code === 'todo-missing-slice-id',
+  );
+});
+
+test('TD-9: STATUS_CHECKBOX covers all task status enum values', () => {
+  const expected = ['pending', 'in-progress', 'done', 'skipped', 'parked'];
+  for (const s of expected) {
+    assert.ok(STATUS_CHECKBOX[s], 'missing checkbox mapping for status: ' + s);
+  }
+});
+
+test('TD-10: re-rendering overwrites stale counts', () => {
+  const root = _sandbox();
+  try {
+    const { fullId } = _writeTask(root, 6, 1, 1, 'pending', 'Alpha');
+    renderTodoMd('M006-S001', root);
+    let raw = fs.readFileSync(todoPath('M006-S001', root), 'utf-8');
+    assert.match(raw, /pending:\s*1/);
+    assert.match(raw, /done:\s*0/);
+    setTaskStatus(fullId, 'done', root);
+    raw = fs.readFileSync(todoPath('M006-S001', root), 'utf-8');
+    assert.match(raw, /pending:\s*0/);
+    assert.match(raw, /done:\s*1/);
+    assert.match(raw, /- \[x\] \*\*M006-S001-T0001\*\* — Alpha/);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});

package/lib/worktree.cjs

@@ -0,0 +1,304 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const { NubosPilotError, projectStateDir } = require('./core.cjs');
+const { parseSliceFullId, mId, sId, sliceFullId: buildSliceFullId } = require('./layout.cjs');
+const { runGit: _spawnGit } = require('./git.cjs');
+
+const BRANCH_PREFIX = 'np/';
+const WORKTREES_DIRNAME = 'worktrees';
+const CONFIG_FLAG = 'worktree_isolation';
+
+function _assertGitRepo(cwd) {
+  const r = _spawnGit(['rev-parse', '--git-dir'], { cwd });
+  if (!r.ok) {
+    throw new NubosPilotError(
+      'worktree-not-git-repo',
+      'not inside a git repository: ' + cwd,
+      { cwd, stderr: r.stderr },
+    );
+  }
+}
+
+function sliceBranchName(sliceFullIdStr) {
+  parseSliceFullId(sliceFullIdStr);
+  return BRANCH_PREFIX + sliceFullIdStr;
+}
+
+function parseSliceBranchName(branch) {
+  if (typeof branch !== 'string' || !branch.startsWith(BRANCH_PREFIX)) return null;
+  const rest = branch.slice(BRANCH_PREFIX.length);
+  try {
+    const { milestone, slice } = parseSliceFullId(rest);
+    return { sliceFullId: rest, milestone, slice };
+  } catch { return null; }
+}
+
+function sliceWorktreePath(sliceFullIdStr, cwd) {
+  const { milestone, slice } = parseSliceFullId(sliceFullIdStr);
+  const base = projectStateDir(cwd || process.cwd());
+  return path.join(base, WORKTREES_DIRNAME, mId(milestone), sId(slice));
+}
+
+function worktreeIsolationEnabled(cwd) {
+  const cfgPath = path.join(projectStateDir(cwd || process.cwd()), 'config.json');
+  if (!fs.existsSync(cfgPath)) return false;
+  try {
+    const cfg = JSON.parse(fs.readFileSync(cfgPath, 'utf-8'));
+    const wf = cfg && cfg.workflow;
+    if (!wf || typeof wf !== 'object') return false;
+    return Boolean(wf[CONFIG_FLAG]);
+  } catch { return false; }
+}
+
+function _currentHeadSha(cwd) {
+  const r = _spawnGit(['rev-parse', 'HEAD'], { cwd });
+  if (!r.ok) {
+    throw new NubosPilotError(
+      'worktree-rev-parse-failed',
+      'git rev-parse HEAD failed: ' + (r.stderr || '').trim(),
+      { cwd, stderr: r.stderr },
+    );
+  }
+  return r.stdout.trim();
+}
+
+function _currentBranchName(cwd) {
+  const r = _spawnGit(['rev-parse', '--abbrev-ref', 'HEAD'], { cwd });
+  if (!r.ok) return null;
+  const name = r.stdout.trim();
+  return name === 'HEAD' ? null : name;
+}
+
+function _listRawWorktrees(cwd) {
+  const r = _spawnGit(['worktree', 'list', '--porcelain'], { cwd });
+  if (!r.ok) {
+    throw new NubosPilotError(
+      'worktree-list-failed',
+      'git worktree list failed: ' + (r.stderr || '').trim(),
+      { cwd, stderr: r.stderr },
+    );
+  }
+  const entries = [];
+  let current = null;
+  const lines = r.stdout.split(/\r?\n/);
+  for (const line of lines) {
+    if (line === '') {
+      if (current) { entries.push(current); current = null; }
+      continue;
+    }
+    if (!current) current = {};
+    if (line.startsWith('worktree ')) current.worktree = line.slice(9);
+    else if (line.startsWith('HEAD ')) current.head = line.slice(5);
+    else if (line.startsWith('branch ')) current.branch = line.slice(7);
+    else if (line === 'bare') current.bare = true;
+    else if (line === 'detached') current.detached = true;
+  }
+  if (current) entries.push(current);
+  return entries;
+}
+
+function listSliceWorktrees(cwd) {
+  _assertGitRepo(cwd);
+  const raw = _listRawWorktrees(cwd);
+  const out = [];
+  for (const w of raw) {
+    if (!w.branch) continue;
+    const short = w.branch.startsWith('refs/heads/') ? w.branch.slice(11) : w.branch;
+    const parsed = parseSliceBranchName(short);
+    if (!parsed) continue;
+    out.push({
+      slice_full_id: parsed.sliceFullId,
+      milestone: parsed.milestone,
+      slice: parsed.slice,
+      branch: short,
+      path: w.worktree,
+      head: w.head || null,
+    });
+  }
+  out.sort((a, b) => a.slice_full_id.localeCompare(b.slice_full_id));
+  return out;
+}
+
+function hasSliceWorktree(sliceFullIdStr, cwd) {
+  const target = sliceWorktreePath(sliceFullIdStr, cwd);
+  for (const w of listSliceWorktrees(cwd)) {
+    if (path.resolve(w.path) === path.resolve(target)) return true;
+    if (w.slice_full_id === sliceFullIdStr) return true;
+  }
+  return false;
+}
+
+function _assertWorktreesGitignored(cwd) {
+  const stateDir = projectStateDir(cwd || process.cwd());
+  const worktreesDir = path.join(stateDir, WORKTREES_DIRNAME);
+  const rel = path.relative(cwd || process.cwd(), worktreesDir) + path.sep + '.placeholder';
+  const r = _spawnGit(['check-ignore', '--quiet', '--', rel], { cwd });
+  if (r.ok) return true;
+  if (r.status === 1) {
+    throw new NubosPilotError(
+      'worktree-not-gitignored',
+      'safety: ' + rel + ' must be gitignored before worktrees can be created. Add `.nubos-pilot/worktrees/` to your .gitignore.',
+      { path: rel },
+    );
+  }
+  throw new NubosPilotError(
+    'worktree-gitignore-check-failed',
+    'git check-ignore failed: ' + (r.stderr || '').trim(),
+    { stderr: r.stderr },
+  );
+}
+
+function createSliceWorktree(sliceFullIdStr, cwd) {
+  _assertGitRepo(cwd);
+  parseSliceFullId(sliceFullIdStr);
+  _assertWorktreesGitignored(cwd);
+
+  const branch = sliceBranchName(sliceFullIdStr);
+  const targetPath = sliceWorktreePath(sliceFullIdStr, cwd);
+
+  if (fs.existsSync(targetPath)) {
+    throw new NubosPilotError(
+      'worktree-already-exists',
+      'worktree path already exists: ' + targetPath,
+      { slice_full_id: sliceFullIdStr, path: targetPath },
+    );
+  }
+
+  const branchCheck = _spawnGit(['rev-parse', '--verify', '--quiet', 'refs/heads/' + branch], { cwd });
+  if (branchCheck.ok) {
+    throw new NubosPilotError(
+      'worktree-branch-conflict',
+      'branch already exists: ' + branch,
+      { slice_full_id: sliceFullIdStr, branch },
+    );
+  }
+
+  const baseSha = _currentHeadSha(cwd);
+  fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+
+  const add = _spawnGit(
+    ['worktree', 'add', '-b', branch, targetPath, baseSha],
+    { cwd },
+  );
+  if (!add.ok) {
+    throw new NubosPilotError(
+      'worktree-add-failed',
+      'git worktree add failed: ' + (add.stderr || '').trim(),
+      { slice_full_id: sliceFullIdStr, branch, path: targetPath, stderr: add.stderr },
+    );
+  }
+
+  return { slice_full_id: sliceFullIdStr, branch, path: targetPath, base_sha: baseSha };
+}
+
+function removeSliceWorktree(sliceFullIdStr, cwd, opts) {
+  _assertGitRepo(cwd);
+  const o = opts || {};
+  const force = Boolean(o.force);
+  const deleteBranch = o.deleteBranch !== false;
+
+  const targetPath = sliceWorktreePath(sliceFullIdStr, cwd);
+  const branch = sliceBranchName(sliceFullIdStr);
+
+  const removeArgs = ['worktree', 'remove'];
+  if (force) removeArgs.push('--force');
+  removeArgs.push(targetPath);
+
+  const r = _spawnGit(removeArgs, { cwd });
+  if (!r.ok) {
+    if (fs.existsSync(targetPath)) {
+      throw new NubosPilotError(
+        'worktree-remove-failed',
+        'git worktree remove failed: ' + (r.stderr || '').trim(),
+        { slice_full_id: sliceFullIdStr, path: targetPath, stderr: r.stderr, force },
+      );
+    }
+  }
+
+  if (deleteBranch) {
+    const exists = _spawnGit(['rev-parse', '--verify', '--quiet', 'refs/heads/' + branch], { cwd });
+    if (exists.ok) {
+      const del = _spawnGit(['branch', '-D', branch], { cwd });
+      if (!del.ok) {
+        throw new NubosPilotError(
+          'worktree-branch-delete-failed',
+          'git branch -D ' + branch + ' failed: ' + (del.stderr || '').trim(),
+          { slice_full_id: sliceFullIdStr, branch, stderr: del.stderr },
+        );
+      }
+    }
+  }
+
+  _spawnGit(['worktree', 'prune'], { cwd });
+
+  return { slice_full_id: sliceFullIdStr, removed: true, path: targetPath, branch };
+}
+
+function ffMergeSliceWorktree(sliceFullIdStr, targetBranch, cwd) {
+  _assertGitRepo(cwd);
+  parseSliceFullId(sliceFullIdStr);
+
+  const branch = sliceBranchName(sliceFullIdStr);
+
+  const existCheck = _spawnGit(['rev-parse', '--verify', '--quiet', 'refs/heads/' + branch], { cwd });
+  if (!existCheck.ok) {
+    throw new NubosPilotError(
+      'worktree-branch-missing',
+      'slice branch not found: ' + branch,
+      { slice_full_id: sliceFullIdStr, branch },
+    );
+  }
+
+  const currentBranch = _currentBranchName(cwd);
+  if (targetBranch && currentBranch && currentBranch !== targetBranch) {
+    throw new NubosPilotError(
+      'worktree-ff-wrong-branch',
+      'ff-merge requires HEAD on ' + targetBranch + ' but is on ' + currentBranch,
+      { slice_full_id: sliceFullIdStr, expected: targetBranch, actual: currentBranch },
+    );
+  }
+
+  const merge = _spawnGit(['merge', '--ff-only', branch], { cwd });
+  if (!merge.ok) {
+    throw new NubosPilotError(
+      'worktree-ff-not-possible',
+      'git merge --ff-only failed for ' + branch + ': ' + (merge.stderr || '').trim(),
+      { slice_full_id: sliceFullIdStr, branch, target_branch: targetBranch || currentBranch, stderr: merge.stderr },
+    );
+  }
+
+  const mergedSha = _currentHeadSha(cwd);
+  return { slice_full_id: sliceFullIdStr, branch, target_branch: targetBranch || currentBranch, merged_sha: mergedSha };
+}
+
+function pruneSliceWorktrees(cwd) {
+  _assertGitRepo(cwd);
+  const r = _spawnGit(['worktree', 'prune'], { cwd });
+  if (!r.ok) {
+    throw new NubosPilotError(
+      'worktree-prune-failed',
+      'git worktree prune failed: ' + (r.stderr || '').trim(),
+      { cwd, stderr: r.stderr },
+    );
+  }
+  return { pruned: true };
+}
+
+module.exports = {
+  BRANCH_PREFIX,
+  WORKTREES_DIRNAME,
+  CONFIG_FLAG,
+  sliceBranchName,
+  parseSliceBranchName,
+  sliceWorktreePath,
+  worktreeIsolationEnabled,
+  listSliceWorktrees,
+  hasSliceWorktree,
+  createSliceWorktree,
+  removeSliceWorktree,
+  ffMergeSliceWorktree,
+  pruneSliceWorktrees,
+};