nubos-pilot 0.1.0

package/bin/np-tools/code-review.cjs

@@ -0,0 +1,133 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const { NubosPilotError } = require('../../lib/core.cjs');
+const { getPhase } = require('../../lib/roadmap.cjs');
+const { paddedPhase, phaseSlug, findPhaseDir } = require('../../lib/phase.cjs');
+const { detect } = require('../../lib/runtime/index.cjs');
+
+const VALID_DEPTHS = new Set(['quick', 'standard', 'deep']);
+
+function _usage() {
+  return 'Usage: np-tools.cjs init code-review <phase> [--depth=quick|standard|deep]';
+}
+
+function _validatePhaseArg(raw) {
+  if (raw == null || raw === '') {
+    throw new NubosPilotError(
+      'code-review-invalid-arg',
+      'code-review requires a phase number argument',
+      { value: raw == null ? '' : String(raw) },
+    );
+  }
+  const s = String(raw);
+  if (!/^\d+(\.\d+)?$/.test(s)) {
+    throw new NubosPilotError(
+      'code-review-invalid-arg',
+      'Invalid phase number: ' + s,
+      { value: s },
+    );
+  }
+  return s;
+}
+
+function _parseDepth(args) {
+  let depth = 'standard';
+  for (let i = 0; i < args.length; i += 1) {
+    const s = String(args[i]);
+    if (s.startsWith('--depth=')) {
+      depth = s.slice('--depth='.length);
+    } else if (s === '--depth' && args[i + 1]) {
+      depth = String(args[i + 1]);
+      i += 1;
+    }
+  }
+  if (!VALID_DEPTHS.has(depth)) {
+    throw new NubosPilotError(
+      'code-review-invalid-depth',
+      'depth must be one of quick|standard|deep, got: ' + depth,
+      { depth },
+    );
+  }
+  return depth;
+}
+
+function _resolvePhaseDir(phaseArg, cwd, slug) {
+  const hit = findPhaseDir(phaseArg, cwd);
+  if (hit) return hit;
+  const padded = paddedPhase(phaseArg);
+  return path.join(path.resolve(cwd), '.nubos-pilot', 'phases', padded + '-' + slug);
+}
+
+function _buildPayload(phaseArg, cwd, depth) {
+  let phase;
+  try {
+    phase = getPhase(phaseArg, cwd);
+  } catch (err) {
+    if (err && err.code === 'phase-not-found') {
+      throw new NubosPilotError(
+        'code-review-not-found',
+        'Phase ' + phaseArg + ' not found in roadmap',
+        { number: phaseArg },
+      );
+    }
+    throw err;
+  }
+  const padded = paddedPhase(phaseArg);
+  const slug = phase.slug || phaseSlug(phase.name);
+  const phase_dir = _resolvePhaseDir(phaseArg, cwd, slug);
+  const review_path = path.join(phase_dir, padded + '-REVIEW.md');
+  const review_fix_path = path.join(phase_dir, padded + '-REVIEW-FIX.md');
+  const summary_path = path.join(phase_dir, padded + '-SUMMARY.md');
+  const summary_present = fs.existsSync(summary_path);
+  const has_review = fs.existsSync(review_path);
+  const { runtime } = detect({ cwd });
+  return {
+    _workflow: 'code-review',
+    phase: phaseArg,
+    padded,
+    phase_dir,
+    review_path,
+    review_fix_path,
+    summary_present,
+    summary_path,
+    has_review,
+    depth,
+    agents: { code_reviewer: 'np-code-reviewer', code_fixer: 'np-code-fixer' },
+    runtime,
+  };
+}
+
+function _emitError(err, stderr) {
+  const code = err && err.name === 'NubosPilotError' ? err.code : 'code-review-internal-error';
+  const message = (err && err.message) || String(err);
+  const details = (err && err.details) || null;
+  stderr.write(JSON.stringify({ code, message, details }) + '\n');
+}
+
+function run(args, ctx) {
+  const context = ctx || {};
+  const cwd = context.cwd || process.cwd();
+  const stdout = context.stdout || process.stdout;
+  const stderr = context.stderr || process.stderr;
+  const list = Array.isArray(args) ? args : [];
+  if (list[0] == null || list[0] === '') {
+    stderr.write(_usage() + '\n');
+    return 1;
+  }
+  try {
+    const phaseArg = _validatePhaseArg(list[0]);
+    const depth = _parseDepth(list.slice(1));
+    const payload = _buildPayload(phaseArg, cwd, depth);
+    stdout.write(JSON.stringify(payload, null, 2));
+    return 0;
+  } catch (err) {
+    _emitError(err, stderr);
+    return 1;
+  }
+}
+
+module.exports = { run, _buildPayload, _parseDepth };
+
+if (require.main === module) {
+  process.exit(run(process.argv.slice(2)));
+}

package/bin/np-tools/code-review.test.cjs

@@ -0,0 +1,96 @@
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const { Writable } = require('node:stream');
+
+const codeReviewCli = require('./code-review.cjs');
+
+const _sandboxes = [];
+
+function makeSink() {
+  const chunks = [];
+  const w = new Writable({
+    write(chunk, _enc, cb) { chunks.push(chunk); cb(); },
+  });
+  w.toString = () => Buffer.concat(chunks.map((c) => Buffer.isBuffer(c) ? c : Buffer.from(String(c)))).toString('utf-8');
+  return w;
+}
+
+function makeSandbox(yaml) {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'np-code-review-'));
+  fs.mkdirSync(path.join(root, '.nubos-pilot'), { recursive: true });
+  fs.writeFileSync(path.join(root, '.nubos-pilot', 'roadmap.yaml'), yaml);
+  _sandboxes.push(root);
+  return root;
+}
+
+test.afterEach(() => {
+  while (_sandboxes.length) {
+    try { fs.rmSync(_sandboxes.pop(), { recursive: true, force: true }); } catch {  }
+  }
+});
+
+const DEMO_YAML = [
+  'milestones:',
+  '  - id: v1.0',
+  '    name: v1',
+  '    phases:',
+  '      - number: 10',
+  '        name: Review Utility',
+  '        slug: review-utility',
+  '        status: in-progress',
+].join('\n') + '\n';
+
+test('CR-1: happy path emits code-review payload with default depth standard', () => {
+  const sb = makeSandbox(DEMO_YAML);
+  const stdout = makeSink();
+  const stderr = makeSink();
+  const code = codeReviewCli.run(['10'], { cwd: sb, stdout, stderr });
+  assert.equal(code, 0, 'stderr=' + stderr.toString());
+  const parsed = JSON.parse(stdout.toString());
+  assert.equal(parsed._workflow, 'code-review');
+  assert.equal(parsed.phase, '10');
+  assert.equal(parsed.padded, '10');
+  assert.equal(parsed.depth, 'standard');
+  assert.ok(parsed.review_path.endsWith('10-REVIEW.md'));
+  assert.ok(parsed.agents && parsed.agents.code_reviewer === 'np-code-reviewer');
+});
+
+test('CR-2: --depth=deep overrides default', () => {
+  const sb = makeSandbox(DEMO_YAML);
+  const stdout = makeSink();
+  const stderr = makeSink();
+  const code = codeReviewCli.run(['10', '--depth=deep'], { cwd: sb, stdout, stderr });
+  assert.equal(code, 0);
+  const parsed = JSON.parse(stdout.toString());
+  assert.equal(parsed.depth, 'deep');
+});
+
+test('CR-3: invalid depth rejected with code-review-invalid-depth', () => {
+  const sb = makeSandbox(DEMO_YAML);
+  const stdout = makeSink();
+  const stderr = makeSink();
+  const code = codeReviewCli.run(['10', '--depth=sloppy'], { cwd: sb, stdout, stderr });
+  assert.equal(code, 1);
+  assert.match(stderr.toString(), /"code":\s*"code-review-invalid-depth"/);
+});
+
+test('CR-4: unknown phase rejected with code-review-not-found', () => {
+  const sb = makeSandbox(DEMO_YAML);
+  const stdout = makeSink();
+  const stderr = makeSink();
+  const code = codeReviewCli.run(['999'], { cwd: sb, stdout, stderr });
+  assert.equal(code, 1);
+  assert.match(stderr.toString(), /"code":\s*"code-review-not-found"/);
+});
+
+test('CR-5: missing phase arg prints usage', () => {
+  const sb = makeSandbox(DEMO_YAML);
+  const stdout = makeSink();
+  const stderr = makeSink();
+  const code = codeReviewCli.run([], { cwd: sb, stdout, stderr });
+  assert.equal(code, 1);
+  assert.match(stderr.toString(), /Usage:/);
+});

package/bin/np-tools/commit-task.cjs

@@ -0,0 +1,120 @@
+const fs = require('node:fs');
+const path = require('node:path');
+
+const { NubosPilotError, findProjectRoot } = require('../../lib/core.cjs');
+const { extractFrontmatter } = require('../../lib/frontmatter.cjs');
+const { TASK_ID_RE, setTaskStatus } = require('../../lib/tasks.cjs');
+const git = require('../../lib/git.cjs');
+const { commitTask, findCommitByTaskId } = git;
+const { deleteCheckpoint } = require('../../lib/checkpoint.cjs');
+
+function _resolveTaskFile(taskId, cwd) {
+
+  const root = findProjectRoot(cwd);
+  const phasesRoot = path.join(root, '.nubos-pilot', 'phases');
+  let entries;
+  try {
+    entries = fs.readdirSync(phasesRoot, { withFileTypes: true });
+  } catch (err) {
+    if (err && err.code === 'ENOENT') {
+      throw new NubosPilotError(
+        'commit-task-not-found',
+        'No .nubos-pilot/phases directory found',
+        { taskId, cwd },
+      );
+    }
+    throw err;
+  }
+  const padded = taskId.slice(0, 2);
+  for (const e of entries) {
+    if (!e.isDirectory()) continue;
+    if (!(e.name === padded || e.name.startsWith(padded + '-'))) continue;
+    const candidate = path.join(phasesRoot, e.name, 'tasks', taskId + '.md');
+    if (fs.existsSync(candidate)) return { filePath: candidate, planDir: path.join(phasesRoot, e.name) };
+  }
+  throw new NubosPilotError(
+    'commit-task-not-found',
+    'No task file found for id ' + taskId,
+    { taskId },
+  );
+}
+
+function _resolveSafe(root, p) {
+
+  
+  const abs = path.resolve(root, p);
+  const rel = path.relative(root, abs);
+  if (rel.startsWith('..') || path.isAbsolute(rel)) {
+    throw new NubosPilotError(
+      'path-not-in-project',
+      'files_modified entry escapes project root: ' + p,
+      { path: p, root },
+    );
+  }
+  return p;
+}
+
+function _extractName(frontmatter, body) {
+  if (typeof frontmatter.name === 'string' && frontmatter.name.length > 0) return frontmatter.name;
+
+  const m = String(body || '').match(/^#\s+(?:Task:\s*)?(.+?)\s*$/m);
+  if (m) return m[1].trim();
+  return frontmatter.id || 'task';
+}
+
+function run(args, ctx) {
+  const context = ctx || {};
+  const cwd = context.cwd || process.cwd();
+  const stdout = context.stdout || process.stdout;
+  const list = Array.isArray(args) ? args : [];
+  const taskId = list[0];
+
+  if (!taskId) {
+    throw new NubosPilotError(
+      'commit-task-missing-id',
+      'commit-task requires a task id (e.g. 06-01-T01)',
+      {},
+    );
+  }
+  if (!TASK_ID_RE.test(taskId)) {
+    throw new NubosPilotError(
+      'commit-task-invalid-id',
+      'Invalid task id format: ' + taskId + ' (expected <NN-NN-TNN>)',
+      { taskId },
+    );
+  }
+
+  const { filePath, planDir } = _resolveTaskFile(taskId, cwd);
+  const raw = fs.readFileSync(filePath, 'utf-8');
+  const { frontmatter, body } = extractFrontmatter(raw);
+  const files = Array.isArray(frontmatter.files_modified) ? frontmatter.files_modified : [];
+  if (files.length === 0) {
+    throw new NubosPilotError(
+      'commit-task-no-files',
+      'Task ' + taskId + ' has empty files_modified',
+      { taskId },
+    );
+  }
+  const root = findProjectRoot(cwd);
+  const safeFiles = files.map((p) => _resolveSafe(root, p));
+  const name = _extractName(frontmatter, body);
+  const message = 'task(' + taskId + '): ' + name;
+
+  
+
+  commitTask(taskId, safeFiles, message);
+  const sha = findCommitByTaskId(taskId);
+
+  try { deleteCheckpoint(taskId, cwd); } catch {  }
+  try { setTaskStatus(taskId, 'done', planDir); } catch (err) {
+
+    
+    process.stderr.write('[nubos-pilot warn] setTaskStatus failed for ' + taskId + ': ' + (err && err.message) + '\n');
+  }
+
+  const payload = { ok: true, task_id: taskId, sha, files: safeFiles };
+  stdout.write(JSON.stringify(payload));
+  return payload;
+}
+
+module.exports = { run };

package/bin/np-tools/commit-task.test.cjs

@@ -0,0 +1,160 @@
+const { test, after } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const { execFileSync } = require('node:child_process');
+
+const subcmd = require('./commit-task.cjs');
+
+const _repos = [];
+
+function makeRepo() {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'np-ct-'));
+  execFileSync('git', ['init', '-q', '-b', 'main', root], { stdio: 'pipe' });
+  execFileSync('git', ['-C', root, 'config', 'user.email', 'test@nubos.local']);
+  execFileSync('git', ['-C', root, 'config', 'user.name', 'nubos-test']);
+  execFileSync('git', ['-C', root, 'commit', '--allow-empty', '-q', '-m', 'chore: init'], { stdio: 'pipe' });
+  fs.mkdirSync(path.join(root, '.nubos-pilot'), { recursive: true });
+
+  fs.writeFileSync(path.join(root, '.nubos-pilot', 'STATE.md'), `---
+schema_version: 2
+milestone: m1
+milestone_name: m1
+current_phase: null
+current_plan: null
+current_task: null
+last_updated: "2026-04-15T00:00:00Z"
+progress:
+  total_phases: 0
+  completed_phases: 0
+  total_plans: 0
+  completed_plans: 0
+  percent: 0
+session:
+  stopped_at: null
+  resume_file: null
+  last_activity: null
+---
+
+# State
+`, 'utf-8');
+  _repos.push(root);
+  return root;
+}
+
+function seedPlanAndTask(root, planId, taskId, filesModified) {
+  const phase = planId.slice(0, 2);
+  const phaseDir = path.join(root, '.nubos-pilot', 'phases', phase + '-demo');
+  const planDir = phaseDir;
+  const tasksDir = path.join(planDir, 'tasks');
+  fs.mkdirSync(tasksDir, { recursive: true });
+
+  const fm = [
+    '---',
+    `id: ${taskId}`,
+    `phase: ${Number(phase)}`,
+    `plan: "${planId}"`,
+    'type: auto',
+    'status: in-progress',
+    'tier: sonnet',
+    'owner: np-executor',
+    'wave: 1',
+    'depends_on: []',
+    'files_modified:',
+    ...filesModified.map((f) => `  - ${f}`),
+    'autonomous: true',
+    'must_haves:',
+    '  truths: []',
+    '---',
+    '',
+    '# Task: demo',
+  ].join('\n');
+  fs.writeFileSync(path.join(tasksDir, taskId + '.md'), fm, 'utf-8');
+
+  fs.writeFileSync(path.join(phaseDir, `${planId}-PLAN.md`), '---\nphase: '+Number(phase)+'\nplan: '+planId.slice(3)+'\n---\n', 'utf-8');
+  return { phaseDir, planDir, taskPath: path.join(tasksDir, taskId + '.md') };
+}
+
+function _capture() {
+  let buf = '';
+  const stub = { write: (s) => { buf += s; return true; } };
+  return { stub, get: () => buf };
+}
+
+after(() => {
+  while (_repos.length) {
+    const r = _repos.pop();
+    try { fs.rmSync(r, { recursive: true, force: true }); } catch {}
+  }
+});
+
+test('CT-1: commit-task requires a task id', () => {
+  const root = makeRepo();
+  const cap = _capture();
+  assert.throws(
+    () => subcmd.run([], { cwd: root, stdout: cap.stub }),
+    (err) => err && err.code === 'commit-task-missing-id',
+  );
+});
+
+test('CT-2: commit-task rejects invalid TASK_ID format (defense-in-depth)', () => {
+  const root = makeRepo();
+  const cap = _capture();
+  assert.throws(
+    () => subcmd.run(['bad/id'], { cwd: root, stdout: cap.stub }),
+    (err) => err && err.code === 'commit-task-invalid-id',
+  );
+});
+
+test('CT-3: commit-task emits JSON with sha + files on success', () => {
+  const root = makeRepo();
+  seedPlanAndTask(root, '06-01', '06-01-T01', ['src/a.ts']);
+
+  fs.mkdirSync(path.join(root, 'src'), { recursive: true });
+  fs.writeFileSync(path.join(root, 'src', 'a.ts'), 'export const a = 1;\n', 'utf-8');
+  const prev = process.cwd();
+  process.chdir(root);
+  const cap = _capture();
+  try {
+    subcmd.run(['06-01-T01'], { cwd: root, stdout: cap.stub });
+  } finally {
+    process.chdir(prev);
+  }
+  const payload = JSON.parse(cap.get());
+  assert.equal(payload.ok, true);
+  assert.equal(payload.task_id, '06-01-T01');
+  assert.ok(/^[0-9a-f]{40}$/.test(payload.sha));
+  assert.deepEqual(payload.files, ['src/a.ts']);
+
+  const subject = execFileSync('git', ['-C', root, 'log', '-n', '1', '--format=%s'], { encoding: 'utf-8' }).trim();
+  assert.ok(subject.startsWith('task(06-01-T01):'), 'subject: ' + subject);
+});
+
+test('CT-4: commit-task LOUD-FAILS when every files_modified entry is gitignored (D-25)', () => {
+  const root = makeRepo();
+  seedPlanAndTask(root, '06-01', '06-01-T02', ['build/out.js']);
+  fs.writeFileSync(path.join(root, '.gitignore'), 'build/\n', 'utf-8');
+  fs.mkdirSync(path.join(root, 'build'), { recursive: true });
+  fs.writeFileSync(path.join(root, 'build', 'out.js'), 'noise', 'utf-8');
+  const prev = process.cwd();
+  process.chdir(root);
+  const cap = _capture();
+  try {
+    assert.throws(
+      () => subcmd.run(['06-01-T02'], { cwd: root, stdout: cap.stub }),
+      (err) => err && err.code === 'commit-all-paths-gitignored',
+    );
+  } finally {
+    process.chdir(prev);
+  }
+});
+
+test('CT-5: commit-task unknown task id → task-not-found', () => {
+  const root = makeRepo();
+  const cap = _capture();
+  assert.throws(
+    () => subcmd.run(['06-99-T99'], { cwd: root, stdout: cap.stub }),
+    (err) => err && err.code === 'commit-task-not-found',
+  );
+});

package/bin/np-tools/commit.cjs

@@ -0,0 +1,103 @@
+const { execFileSync } = require('node:child_process');
+const path = require('node:path');
+const { NubosPilotError } = require('../../lib/core.cjs');
+const { assertCommittablePaths } = require('../../lib/git.cjs');
+
+const MAX_MSG = 2000;
+
+function _usage() {
+  return 'Usage:\n  np-tools.cjs commit "message" --files f1 f2 ...';
+}
+
+function _emitError(err, stderr) {
+  const code = err && err.name === 'NubosPilotError' ? err.code : 'commit-internal-error';
+  const message = (err && err.message) || String(err);
+  const details = (err && err.details) || null;
+  stderr.write(JSON.stringify({ code, message, details }) + '\n');
+}
+
+function _parseArgs(argv) {
+  const args = Array.isArray(argv) ? argv.slice() : [];
+  let msg = null;
+  const files = [];
+  let i = 0;
+  while (i < args.length) {
+    const a = args[i];
+    if (a === '--files') {
+      i += 1;
+      while (i < args.length && !String(args[i]).startsWith('--')) {
+        files.push(args[i]);
+        i += 1;
+      }
+      continue;
+    }
+    if (a === '-m' || a === '--message') {
+      msg = args[i + 1];
+      i += 2;
+      continue;
+    }
+    if (msg == null && !String(a).startsWith('--')) {
+      msg = a;
+      i += 1;
+      continue;
+    }
+    i += 1;
+  }
+  return { msg, files };
+}
+
+function _validateFiles(files) {
+  for (const f of files) {
+    if (typeof f !== 'string' || f.length === 0) {
+      throw new NubosPilotError('commit-invalid-path', 'commit path must be non-empty string', { path: f });
+    }
+    const segments = String(f).split(/[/\\]/);
+    for (const seg of segments) {
+      if (seg === '..') {
+        throw new NubosPilotError('commit-path-traversal', 'commit path must not contain ".." segments', { path: f });
+      }
+    }
+    if (path.isAbsolute(f)) {
+      throw new NubosPilotError('commit-path-absolute', 'commit path must be relative', { path: f });
+    }
+  }
+}
+
+function run(argv, ctx) {
+  const context = ctx || {};
+  const stdout = context.stdout || process.stdout;
+  const stderr = context.stderr || process.stderr;
+  try {
+    const { msg, files } = _parseArgs(argv);
+    if (!msg || typeof msg !== 'string' || msg.trim() === '') {
+      stderr.write(_usage() + '\n');
+      return 1;
+    }
+    if (msg.length > MAX_MSG) {
+      throw new NubosPilotError('commit-message-too-long', 'commit message exceeds ' + MAX_MSG + ' chars', { length: msg.length });
+    }
+    if (!Array.isArray(files) || files.length === 0) {
+      stderr.write(_usage() + '\n');
+      return 1;
+    }
+    _validateFiles(files);
+    const committable = assertCommittablePaths(files);
+    if (committable.length === 0) {
+      throw new NubosPilotError('commit-no-paths', 'commit invoked with no committable paths', { files });
+    }
+    execFileSync('git', ['add', '--', ...committable], { stdio: 'pipe' });
+    execFileSync('git', ['commit', '-m', msg, '--', ...committable], { stdio: 'pipe' });
+    const sha = execFileSync('git', ['rev-parse', '--short', 'HEAD'], { encoding: 'utf-8' }).trim();
+    stdout.write(JSON.stringify({ committed: true, sha, files: committable }) + '\n');
+    return 0;
+  } catch (err) {
+    _emitError(err, stderr);
+    return 1;
+  }
+}
+
+module.exports = { run, _parseArgs, _validateFiles };
+
+if (require.main === module) {
+  process.exit(run(process.argv.slice(2)));
+}