nubos-pilot 0.1.0

package/bin/np-tools/doctor.cjs

@@ -0,0 +1,242 @@
+'use strict';
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const { NubosPilotError, atomicWriteFileSync } = require('../../lib/core.cjs');
+const manifestMod = require('../../lib/install/manifest.cjs');
+const codexTomlMod = require('../../lib/install/codex-toml.cjs');
+const askuserMod = require('../../lib/askuser.cjs');
+
+const PAYLOAD_SUBPATH = path.join('.claude', 'nubos-pilot');
+const CODEX_CONFIG_PATH = path.join(os.homedir(), '.codex', 'config.toml');
+
+function _payloadDirFor(projectRoot) {
+  return path.join(projectRoot, PAYLOAD_SUBPATH);
+}
+
+function _pkgVersion() {
+  try {
+    return require('../../package.json').version || '0.0.0';
+  } catch {
+    return '0.0.0';
+  }
+}
+
+function _checkManifestIntegrity(payloadDir) {
+  const issues = [];
+  let manifest = null;
+  try {
+    manifest = manifestMod.readManifest(payloadDir);
+  } catch (err) {
+    issues.push({
+      id: 'missing-manifest',
+      severity: 'error',
+      fixable: 'reinstall',
+      details: { reason: 'parse-failed', cause: err && err.message },
+    });
+    return { manifest: null, issues };
+  }
+  if (!manifest) {
+    issues.push({
+      id: 'missing-manifest',
+      severity: 'error',
+      fixable: 'reinstall',
+      details: { payloadDir },
+    });
+    return { manifest: null, issues };
+  }
+  const files = (manifest.files && typeof manifest.files === 'object') ? manifest.files : {};
+  for (const rel of Object.keys(files)) {
+    const full = path.join(payloadDir, rel);
+    if (!fs.existsSync(full)) {
+      issues.push({
+        id: 'payload-missing',
+        file: rel,
+        severity: 'error',
+        fixable: 'reinstall',
+      });
+      continue;
+    }
+    let hash;
+    try { hash = manifestMod.fileHashSync(full); } catch { hash = null; }
+    if (hash && hash !== files[rel]) {
+      issues.push({
+        id: 'payload-modified',
+        file: rel,
+        severity: 'warn',
+        fixable: 'reinstall',
+      });
+    }
+  }
+  return { manifest, issues };
+}
+
+function _checkVersionMismatch(manifest) {
+  if (!manifest) return [];
+  const installed = String(manifest.version == null ? '' : manifest.version);
+  const pkg = String(_pkgVersion());
+  if (installed && installed !== pkg) {
+    return [{
+      id: 'version-mismatch',
+      severity: 'warn',
+      fixable: 'reinstall',
+      details: { installed, expected: pkg },
+    }];
+  }
+  return [];
+}
+
+function _checkHooksMissing(manifest, payloadDir) {
+  if (!manifest) return [];
+  const files = (manifest.files && typeof manifest.files === 'object') ? manifest.files : {};
+  const hasHooksEntries = Object.keys(files).some((rel) => rel.startsWith('hooks/'));
+  if (!hasHooksEntries) return [];
+  const hooksDir = path.join(payloadDir, 'hooks');
+  if (fs.existsSync(hooksDir)) return [];
+  return [{
+    id: 'hooks-missing',
+    severity: 'error',
+    fixable: 'reinstall',
+    details: { hooksDir },
+  }];
+}
+
+function _checkCodexTrappedFeatures() {
+  if (!fs.existsSync(CODEX_CONFIG_PATH)) return { issues: [], content: null };
+  let content;
+  try {
+    content = fs.readFileSync(CODEX_CONFIG_PATH, 'utf-8');
+  } catch (err) {
+    return {
+      issues: [{
+        id: 'codex-trapped-features',
+        severity: 'warn',
+        fixable: 'reinstall',
+        details: { reason: 'read-failed', cause: err && err.message },
+      }],
+      content: null,
+    };
+  }
+  if (codexTomlMod.hasTrappedFeatures(content)) {
+    return {
+      issues: [{
+        id: 'codex-trapped-features',
+        severity: 'warn',
+        fixable: 'auto',
+        details: { path: CODEX_CONFIG_PATH },
+      }],
+      content,
+    };
+  }
+  return { issues: [], content };
+}
+
+function _checkAskUserBroken() {
+  try {
+    askuserMod.getRuntime();
+    return [];
+  } catch (err) {
+    return [{
+      id: 'askuser-broken',
+      severity: 'warn',
+      fixable: 'prompt',
+      details: { cause: err && err.message },
+    }];
+  }
+}
+
+function _audit(projectRoot) {
+  const payloadDir = _payloadDirFor(projectRoot);
+  const issues = [];
+  const { manifest, issues: manifestIssues } = _checkManifestIntegrity(payloadDir);
+  issues.push(...manifestIssues);
+  issues.push(..._checkVersionMismatch(manifest));
+  issues.push(..._checkHooksMissing(manifest, payloadDir));
+  const codex = _checkCodexTrappedFeatures();
+  issues.push(...codex.issues);
+  issues.push(..._checkAskUserBroken());
+  return { issues, _codexContent: codex.content };
+}
+
+function _fixCodexTrappedFeatures(content) {
+  const repaired = codexTomlMod.repairTrappedFeatures(content);
+  if (repaired === content) return false;
+  atomicWriteFileSync(CODEX_CONFIG_PATH, repaired);
+  return true;
+}
+
+async function _applyFixes(issues, codexContent, askUser, stderr) {
+  const applied = [];
+  const skipped = [];
+  for (const issue of issues) {
+    if (issue.fixable === 'auto') {
+      if (issue.id === 'codex-trapped-features' && codexContent != null) {
+        try {
+          const ok = _fixCodexTrappedFeatures(codexContent);
+          if (ok) applied.push({ id: issue.id, fix: 'codex-trapped-features-repaired' });
+          else skipped.push({ id: issue.id, reason: 'no-change' });
+        } catch (err) {
+          skipped.push({ id: issue.id, reason: 'fix-failed', cause: err && err.message });
+        }
+      } else {
+        skipped.push({ id: issue.id, reason: 'no-auto-handler' });
+      }
+      continue;
+    }
+    if (issue.fixable === 'prompt') {
+      const answer = await askUser({
+        type: 'confirm',
+        question: `Issue ${issue.id} gefunden — reparieren?`,
+        default: true,
+      });
+      if (answer && answer.value) {
+        applied.push({ id: issue.id, fix: 'user-confirmed' });
+      } else {
+        skipped.push({ id: issue.id, reason: 'user-declined' });
+      }
+      continue;
+    }
+    if (issue.fixable === 'reinstall') {
+      try { stderr.write(`[doctor] ${issue.id}: Run \`npx nubos-pilot\` to reinstall.\n`); } catch {}
+      skipped.push({ id: issue.id, reason: 'requires-reinstall' });
+      continue;
+    }
+    skipped.push({ id: issue.id, reason: 'not-fixable' });
+  }
+  return { applied, skipped };
+}
+
+async 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 askUser = typeof context.askUser === 'function'
+    ? context.askUser
+    : askuserMod.askUser;
+  const list = Array.isArray(args) ? args : [];
+  const doFix = list.includes('--fix');
+
+  const audit = _audit(cwd);
+  const payload = { issues: audit.issues };
+
+  if (doFix && audit.issues.length > 0) {
+    const { applied, skipped } = await _applyFixes(
+      audit.issues,
+      audit._codexContent,
+      askUser,
+      stderr,
+    );
+    payload.applied = applied;
+    payload.skipped = skipped;
+  }
+
+  try { stdout.write(JSON.stringify(payload)); } catch (err) {
+    throw new NubosPilotError('doctor-emit-failed', err && err.message, {});
+  }
+  return payload;
+}
+
+module.exports = { run };

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

@@ -0,0 +1,116 @@
+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');
+
+function _validatePhaseArg(raw) {
+  if (raw == null || raw === '') {
+    throw new NubosPilotError(
+      'eval-review-invalid-arg',
+      'eval-review requires a phase number argument',
+      { value: raw == null ? '' : String(raw) },
+    );
+  }
+  const s = String(raw);
+  if (!/^\d+(\.\d+)?$/.test(s)) {
+    throw new NubosPilotError(
+      'eval-review-invalid-arg',
+      'Invalid phase number: ' + s,
+      { value: s },
+    );
+  }
+  return s;
+}
+
+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 _computeState(hasAiSpec, summaryPresent) {
+  if (hasAiSpec && summaryPresent) return 'A';
+  if (summaryPresent) return 'B';
+  return 'C';
+}
+
+function _buildPayload(phaseArg, cwd) {
+  let phase;
+  try {
+    phase = getPhase(phaseArg, cwd);
+  } catch (err) {
+    if (err && err.code === 'phase-not-found') {
+      throw new NubosPilotError(
+        'eval-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 eval_review_path = path.join(phase_dir, padded + '-EVAL-REVIEW.md');
+  const summary_path = path.join(phase_dir, padded + '-SUMMARY.md');
+  const ai_spec_path = path.join(phase_dir, padded + '-AI-SPEC.md');
+  const summary_present = fs.existsSync(summary_path);
+  const has_ai_spec = fs.existsSync(ai_spec_path);
+  const state = _computeState(has_ai_spec, summary_present);
+  const { runtime } = detect({ cwd });
+
+  return {
+    _workflow: 'eval-review',
+    phase: phaseArg,
+    padded,
+    phase_dir,
+    eval_review_path,
+    summary_present,
+    summary_path,
+    ai_spec_path,
+    has_ai_spec,
+    state,
+    agents: { eval_auditor: 'np-eval-auditor' },
+    runtime,
+  };
+}
+
+function _emitError(err, stderr) {
+  if (err && err.name === 'NubosPilotError') {
+    stderr.write(
+      JSON.stringify({ code: err.code, message: err.message, details: err.details }) + '\n',
+    );
+  } else {
+    stderr.write(String((err && err.stack) || err) + '\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: np-tools.cjs init eval-review <phase>\n');
+    return 1;
+  }
+
+  try {
+    const phaseArg = _validatePhaseArg(list[0]);
+    const payload = _buildPayload(phaseArg, cwd);
+    stdout.write(JSON.stringify(payload, null, 2));
+    return 0;
+  } catch (err) {
+    _emitError(err, stderr);
+    return 1;
+  }
+}
+
+module.exports = { run, _buildPayload, _computeState };

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

@@ -0,0 +1,123 @@
+const { test, afterEach } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const { makeSandbox, seedRoadmapYaml, seedPhaseDir, cleanupAll } =
+  require('../../tests/helpers/fixture.cjs');
+const subcmd = require('./eval-review.cjs');
+
+function _baseRoadmap() {
+  return {
+    schema_version: 1,
+    milestones: [
+      {
+        id: 'v1.0',
+        name: 'first',
+        phases: [
+          {
+            number: 9,
+            name: 'Feature Set',
+            slug: 'feature-set',
+            goal: 'Ship advanced workflows',
+            depends_on: [],
+            requirements: ['R-04'],
+            success_criteria: ['Eval review produced'],
+            status: 'pending',
+            plans: [],
+          },
+        ],
+      },
+    ],
+  };
+}
+
+function _capture() {
+  let buf = '';
+  return { stub: { write: (s) => { buf += s; return true; } }, get: () => buf };
+}
+
+afterEach(cleanupAll);
+
+test('EVR-1: State A — both AI-SPEC and SUMMARY present', () => {
+  const sandbox = makeSandbox();
+  seedRoadmapYaml(sandbox, _baseRoadmap());
+  seedPhaseDir(sandbox, 9, 'feature-set', {
+    '09-AI-SPEC.md': '# ai\n',
+    '09-SUMMARY.md': '# sum\n',
+  });
+  const cap = _capture();
+  subcmd.run(['9'], { cwd: sandbox, stdout: cap.stub });
+  const payload = JSON.parse(cap.get().trim());
+  assert.equal(payload.state, 'A');
+  assert.equal(payload.has_ai_spec, true);
+  assert.equal(payload.summary_present, true);
+});
+
+test('EVR-2: State B — only SUMMARY present', () => {
+  const sandbox = makeSandbox();
+  seedRoadmapYaml(sandbox, _baseRoadmap());
+  seedPhaseDir(sandbox, 9, 'feature-set', {
+    '09-SUMMARY.md': '# sum\n',
+  });
+  const cap = _capture();
+  subcmd.run(['9'], { cwd: sandbox, stdout: cap.stub });
+  const payload = JSON.parse(cap.get().trim());
+  assert.equal(payload.state, 'B');
+  assert.equal(payload.has_ai_spec, false);
+  assert.equal(payload.summary_present, true);
+});
+
+test('EVR-3: State C — neither file present', () => {
+  const sandbox = makeSandbox();
+  seedRoadmapYaml(sandbox, _baseRoadmap());
+  seedPhaseDir(sandbox, 9, 'feature-set', {});
+  const cap = _capture();
+  subcmd.run(['9'], { cwd: sandbox, stdout: cap.stub });
+  const payload = JSON.parse(cap.get().trim());
+  assert.equal(payload.state, 'C');
+  assert.equal(payload.has_ai_spec, false);
+  assert.equal(payload.summary_present, false);
+});
+
+test('EVR-4: payload declares eval_auditor agent + standard fields', () => {
+  const sandbox = makeSandbox();
+  seedRoadmapYaml(sandbox, _baseRoadmap());
+  const dir = seedPhaseDir(sandbox, 9, 'feature-set', {});
+  const cap = _capture();
+  subcmd.run(['9'], { cwd: sandbox, stdout: cap.stub });
+  const payload = JSON.parse(cap.get().trim());
+  assert.deepEqual(payload.agents, { eval_auditor: 'np-eval-auditor' });
+  assert.equal(payload.eval_review_path, path.join(dir, '09-EVAL-REVIEW.md'));
+  assert.equal(payload.summary_path, path.join(dir, '09-SUMMARY.md'));
+  assert.equal(payload.ai_spec_path, path.join(dir, '09-AI-SPEC.md'));
+});
+
+test('EVR-5: runtime populated via detect()', () => {
+  const sandbox = makeSandbox();
+  seedRoadmapYaml(sandbox, _baseRoadmap());
+  seedPhaseDir(sandbox, 9, 'feature-set', {});
+  fs.writeFileSync(
+    path.join(sandbox, '.nubos-pilot', 'config.json'),
+    JSON.stringify({ runtime: 'claude' }),
+    'utf-8',
+  );
+  const cap = _capture();
+  subcmd.run(['9'], { cwd: sandbox, stdout: cap.stub });
+  const payload = JSON.parse(cap.get().trim());
+  assert.equal(payload.runtime, 'claude');
+});
+
+test('EVR-6: unknown phase → eval-review-not-found', () => {
+  const sandbox = makeSandbox();
+  seedRoadmapYaml(sandbox, _baseRoadmap());
+  const cap = _capture();
+  let errBuf = '';
+  const code = subcmd.run(['99'], {
+    cwd: sandbox, stdout: cap.stub,
+    stderr: { write: (s) => { errBuf += s; return true; } },
+  });
+  assert.equal(code, 1);
+  const parsed = JSON.parse(errBuf.trim());
+  assert.equal(parsed.code, 'eval-review-not-found');
+});

package/bin/np-tools/execute-phase.cjs

@@ -0,0 +1,182 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const crypto = require('node:crypto');
+
+const {
+  NubosPilotError,
+  projectStateDir,
+} = require('../../lib/core.cjs');
+const { getPhase } = require('../../lib/roadmap.cjs');
+const { paddedPhase, phaseSlug, findPhaseDir } = require('../../lib/phase.cjs');
+const { listPlans, parsePlan } = require('../../lib/plan.cjs');
+const { loadTaskGraph, TASK_ID_RE } = require('../../lib/tasks.cjs');
+const { extractFrontmatter } = require('../../lib/frontmatter.cjs');
+const { getAgentSkills } = require('../../lib/agents.cjs');
+
+const INLINE_THRESHOLD_BYTES = 16 * 1024;
+
+function _validatePhaseArg(raw) {
+  if (raw == null || raw === '') {
+    throw new NubosPilotError(
+      'execute-phase-invalid-phase-arg',
+      'execute-phase requires a phase number',
+      { value: raw == null ? '' : String(raw) },
+    );
+  }
+  const s = String(raw);
+  if (!/^\d+(\.\d+)?$/.test(s)) {
+    throw new NubosPilotError(
+      'execute-phase-invalid-phase-arg',
+      'Invalid phase number: ' + s,
+      { value: s },
+    );
+  }
+  return s;
+}
+
+function _resolvePhaseDir(n, cwd, slug) {
+  const hit = findPhaseDir(n, cwd);
+  if (hit) return hit;
+  const padded = paddedPhase(n);
+  let stateDir;
+  try { stateDir = projectStateDir(cwd); } catch { stateDir = path.join(path.resolve(cwd), '.nubos-pilot'); }
+  return path.join(stateDir, 'phases', padded + '-' + slug);
+}
+
+function _safeSkills(name, cwd) {
+  try { return getAgentSkills(name, cwd); } catch { return []; }
+}
+
+function _emit(payload, stdout, cwd) {
+  const json = JSON.stringify(payload, null, 2);
+  if (Buffer.byteLength(json, 'utf-8') <= INLINE_THRESHOLD_BYTES) {
+    stdout.write(json);
+    return;
+  }
+  let tmpDir;
+  try {
+    tmpDir = path.join(projectStateDir(cwd), '.tmp');
+    fs.mkdirSync(tmpDir, { recursive: true });
+  } catch { tmpDir = os.tmpdir(); }
+  const suffix = process.pid + '-' + crypto.randomBytes(4).toString('hex');
+  const tmpPath = path.join(tmpDir, 'init-execute-phase-' + suffix + '.json');
+  fs.writeFileSync(tmpPath, json, 'utf-8');
+  stdout.write('@file:' + tmpPath);
+}
+
+function _initPayload(phaseArg, cwd) {
+  const phase = getPhase(phaseArg, cwd);
+  const padded = paddedPhase(phaseArg);
+  const slug = phase.slug || phaseSlug(phase.name);
+  const phase_dir = _resolvePhaseDir(phaseArg, cwd, slug);
+  const plans = [];
+  let planPaths = [];
+  try { planPaths = listPlans(phase_dir); } catch { planPaths = []; }
+  for (const planPath of planPaths) {
+    const parsed = parsePlan(planPath);
+    const planDir = path.dirname(planPath);
+    const tg = loadTaskGraph(planDir);
+    plans.push({
+      plan_path: planPath,
+      plan_frontmatter: parsed.frontmatter,
+      tasks_dir: path.join(planDir, 'tasks'),
+      task_count: tg.tasks.length,
+      waves: tg.waves,
+      warnings: tg.warnings,
+    });
+  }
+  return {
+    _workflow: 'execute-phase',
+    phase: phaseArg,
+    padded,
+    phase_dir,
+    phase_name: phase.name,
+    phase_slug: slug,
+    goal: phase.goal || '',
+    requirements: Array.isArray(phase.requirements) ? phase.requirements : [],
+    success_criteria: Array.isArray(phase.success_criteria) ? phase.success_criteria : [],
+    plans,
+    executor_tier: 'sonnet',
+    agent_skills: { executor: _safeSkills('np-executor', cwd) },
+  };
+}
+
+function _findTaskPayload(phaseArg, taskId, cwd) {
+  if (!TASK_ID_RE.test(taskId)) {
+    throw new NubosPilotError(
+      'execute-phase-invalid-task-id',
+      'Invalid task id: ' + taskId,
+      { taskId },
+    );
+  }
+  const phase = getPhase(phaseArg, cwd);
+  const slug = phase.slug || phaseSlug(phase.name);
+  const phase_dir = _resolvePhaseDir(phaseArg, cwd, slug);
+  const planPaths = listPlans(phase_dir);
+  for (const planPath of planPaths) {
+    const planDir = path.dirname(planPath);
+    const taskFile = path.join(planDir, 'tasks', taskId + '.md');
+    if (!fs.existsSync(taskFile)) continue;
+    const { frontmatter, body } = extractFrontmatter(fs.readFileSync(taskFile, 'utf-8'));
+    return {
+      _workflow: 'execute-phase',
+      verb: 'execute-task',
+      phase: phaseArg,
+      task_id: taskId,
+      task_file: taskFile,
+      plan_path: planPath,
+      files_modified: Array.isArray(frontmatter.files_modified) ? frontmatter.files_modified : [],
+      task_name: frontmatter.name || (String(body || '').match(/^#\s+(?:Task:\s*)?(.+?)\s*$/m) || [null, taskId])[1],
+      wave: frontmatter.wave,
+      tier: frontmatter.tier || 'sonnet',
+      depends_on: Array.isArray(frontmatter.depends_on) ? frontmatter.depends_on : [],
+      executor_tier: 'sonnet',
+      agent_skills: { executor: _safeSkills('np-executor', cwd) },
+    };
+  }
+  throw new NubosPilotError(
+    'execute-phase-task-not-found',
+    'Task ' + taskId + ' not found under phase ' + phaseArg,
+    { taskId, phase: phaseArg },
+  );
+}
+
+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 verb = list[0];
+
+  switch (verb) {
+    case 'init': {
+      const phaseArg = _validatePhaseArg(list[1]);
+      const payload = _initPayload(phaseArg, cwd);
+      _emit(payload, stdout, cwd);
+      return payload;
+    }
+    case 'execute-task': {
+      const phaseArg = _validatePhaseArg(list[1]);
+      const taskId = list[2];
+      if (!taskId) {
+        throw new NubosPilotError(
+          'execute-phase-missing-task-id',
+          'execute-task requires <task-id>',
+          {},
+        );
+      }
+      const payload = _findTaskPayload(phaseArg, taskId, cwd);
+      _emit(payload, stdout, cwd);
+      return payload;
+    }
+    default:
+      throw new NubosPilotError(
+        'execute-phase-unknown-verb',
+        'execute-phase: unknown verb: ' + String(verb),
+        { verb },
+      );
+  }
+}
+
+module.exports = { run, INLINE_THRESHOLD_BYTES };