nubos-pilot 0.2.2 → 0.4.0

package/bin/np-tools/doctor.cjs

@@ -8,6 +8,8 @@ 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 codebaseManifest = require('../../lib/codebase-manifest.cjs');
+const { scan: workspaceScan } = require('../../lib/workspace-scan.cjs');
 
 const PAYLOAD_SUBPATH = path.join('.claude', 'nubos-pilot');
 const CODEX_CONFIG_PATH = path.join(os.homedir(), '.codex', 'config.toml');
@@ -147,6 +149,100 @@ function _checkAskUserBroken() {
   }
 }
 
+function _checkCodebaseDocs(projectRoot) {
+  const issues = [];
+  const stateDir = path.join(projectRoot, '.nubos-pilot');
+  if (!fs.existsSync(stateDir)) return issues;
+  const codebaseDir = path.join(stateDir, 'codebase');
+  const indexPath = path.join(codebaseDir, 'INDEX.md');
+  const modulesDir = path.join(codebaseDir, 'modules');
+
+  if (!fs.existsSync(indexPath)) {
+    issues.push({
+      id: 'codebase-not-scanned',
+      severity: 'warn',
+      fixable: 'run-workflow',
+      details: { hint: 'run `np:scan-codebase`' },
+    });
+    return issues;
+  }
+
+  let prevManifest;
+  try {
+    prevManifest = codebaseManifest.readManifest(projectRoot);
+  } catch (err) {
+    issues.push({
+      id: 'codebase-manifest-unreadable',
+      severity: 'warn',
+      fixable: 'run-workflow',
+      details: { cause: err && err.code, hint: 'run `np:scan-codebase`' },
+    });
+    return issues;
+  }
+
+  let scanResult;
+  try {
+    scanResult = workspaceScan({ cwd: projectRoot, batchSize: 1000 });
+  } catch (err) {
+    issues.push({
+      id: 'codebase-scan-failed',
+      severity: 'warn',
+      fixable: 'run-workflow',
+      details: { cause: err && err.code, hint: 'inspect workspace and re-run `np:scan-codebase`' },
+    });
+    return issues;
+  }
+
+  const nextManifest = codebaseManifest.manifestFromScanFiles(scanResult.files);
+  const diff = codebaseManifest.diffManifest(prevManifest, nextManifest);
+  const touched = diff.summary.added + diff.summary.changed + diff.summary.removed;
+  if (touched > 0) {
+    issues.push({
+      id: 'codebase-manifest-stale',
+      severity: 'warn',
+      fixable: 'run-workflow',
+      details: {
+        added: diff.summary.added,
+        changed: diff.summary.changed,
+        removed: diff.summary.removed,
+        hint: 'run `np:update-docs`',
+      },
+    });
+  }
+
+  if (fs.existsSync(modulesDir)) {
+    let entries = [];
+    try {
+      entries = fs.readdirSync(modulesDir).filter((f) => f.endsWith('.md'));
+    } catch {}
+    const tbdDocs = [];
+    for (const f of entries) {
+      try {
+        const raw = fs.readFileSync(path.join(modulesDir, f), 'utf-8');
+        const purposeIdx = raw.indexOf('## Purpose');
+        if (purposeIdx >= 0) {
+          const chunk = raw.slice(purposeIdx, purposeIdx + 400);
+          if (chunk.includes('_TBD')) tbdDocs.push(f);
+        }
+      } catch {}
+    }
+    if (tbdDocs.length > 0) {
+      issues.push({
+        id: 'codebase-tbd-docs',
+        severity: 'info',
+        fixable: 'run-workflow',
+        details: {
+          count: tbdDocs.length,
+          sample: tbdDocs.slice(0, 5),
+          hint: 'run `np:scan-codebase` and dispatch the documenter agent for each module',
+        },
+      });
+    }
+  }
+
+  return issues;
+}
+
 function _audit(projectRoot) {
   const payloadDir = _payloadDirFor(projectRoot);
   const issues = [];
@@ -157,6 +253,7 @@ function _audit(projectRoot) {
   const codex = _checkCodexTrappedFeatures();
   issues.push(...codex.issues);
   issues.push(..._checkAskUserBroken());
+  issues.push(..._checkCodebaseDocs(projectRoot));
   return { issues, _codexContent: codex.content };
 }
 
@@ -203,6 +300,12 @@ async function _applyFixes(issues, codexContent, askUser, stderr) {
       skipped.push({ id: issue.id, reason: 'requires-reinstall' });
       continue;
     }
+    if (issue.fixable === 'run-workflow') {
+      const hint = (issue.details && issue.details.hint) || 'run the suggested np workflow';
+      try { stderr.write(`[doctor] ${issue.id}: ${hint}.\n`); } catch {}
+      skipped.push({ id: issue.id, reason: 'requires-workflow' });
+      continue;
+    }
     skipped.push({ id: issue.id, reason: 'not-fixable' });
   }
   return { applied, skipped };

package/bin/np-tools/doctor.test.cjs

@@ -0,0 +1,112 @@
+const { test, afterEach } = 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 doctor = require('./doctor.cjs');
+const scanCodebase = require('./scan-codebase.cjs');
+
+const _sandboxes = [];
+
+function makeSandbox() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'np-doc-'));
+  fs.mkdirSync(path.join(dir, '.nubos-pilot'), { recursive: true });
+  _sandboxes.push(dir);
+  return dir;
+}
+
+function captureStdout() {
+  const chunks = [];
+  return {
+    stub: { write: (s) => chunks.push(String(s)), end: () => {} },
+    json: () => JSON.parse(chunks.join('')),
+  };
+}
+
+afterEach(() => {
+  while (_sandboxes.length) {
+    const dir = _sandboxes.pop();
+    try { fs.rmSync(dir, { recursive: true, force: true }); } catch {}
+  }
+});
+
+test('DOC-1: flags codebase-not-scanned when INDEX.md missing', async () => {
+  const root = makeSandbox();
+  fs.writeFileSync(path.join(root, 'src.js'), 'export {};');
+  const cap = captureStdout();
+  await doctor.run([], { cwd: root, stdout: cap.stub, stderr: cap.stub, askUser: async () => ({ value: false }) });
+  const out = cap.json();
+  const ids = out.issues.map((i) => i.id);
+  assert.ok(ids.includes('codebase-not-scanned'));
+});
+
+test('DOC-2: no codebase issue when scanned and source unchanged', async () => {
+  const root = makeSandbox();
+  fs.writeFileSync(path.join(root, 'src.js'), 'export function a(){}');
+  scanCodebase.run([], { cwd: root, stdout: captureStdout().stub });
+
+  const cap = captureStdout();
+  await doctor.run([], { cwd: root, stdout: cap.stub, stderr: cap.stub, askUser: async () => ({ value: false }) });
+  const out = cap.json();
+  const ids = out.issues.map((i) => i.id);
+  assert.ok(!ids.includes('codebase-not-scanned'));
+  assert.ok(!ids.includes('codebase-manifest-stale'));
+});
+
+test('DOC-3: flags codebase-manifest-stale after source changes', async () => {
+  const root = makeSandbox();
+  fs.writeFileSync(path.join(root, 'src.js'), 'export function a(){}');
+  scanCodebase.run([], { cwd: root, stdout: captureStdout().stub });
+
+  fs.writeFileSync(path.join(root, 'src.js'), 'export function a(){ /* v2 */ }');
+  fs.writeFileSync(path.join(root, 'new.js'), 'export function b(){}');
+
+  const cap = captureStdout();
+  await doctor.run([], { cwd: root, stdout: cap.stub, stderr: cap.stub, askUser: async () => ({ value: false }) });
+  const out = cap.json();
+  const stale = out.issues.find((i) => i.id === 'codebase-manifest-stale');
+  assert.ok(stale, 'expected codebase-manifest-stale');
+  assert.ok(stale.details.changed >= 1);
+  assert.ok(stale.details.added >= 1);
+});
+
+test('DOC-4: flags codebase-tbd-docs for modules with _TBD Purpose', async () => {
+  const root = makeSandbox();
+  fs.mkdirSync(path.join(root, 'src'), { recursive: true });
+  fs.writeFileSync(path.join(root, 'src', 'a.js'), 'export function a(){}');
+  scanCodebase.run([], { cwd: root, stdout: captureStdout().stub });
+
+  const cap = captureStdout();
+  await doctor.run([], { cwd: root, stdout: cap.stub, stderr: cap.stub, askUser: async () => ({ value: false }) });
+  const out = cap.json();
+  const tbd = out.issues.find((i) => i.id === 'codebase-tbd-docs');
+  assert.ok(tbd, 'expected codebase-tbd-docs');
+  assert.ok(tbd.details.count >= 1);
+});
+
+test('DOC-5: no tbd flag after prose applied', async () => {
+  const root = makeSandbox();
+  fs.mkdirSync(path.join(root, 'src'), { recursive: true });
+  fs.writeFileSync(path.join(root, 'src', 'a.js'), 'export function a(){}');
+  scanCodebase.run([], { cwd: root, stdout: captureStdout().stub });
+
+  const proseFile = path.join(root, 'p.json');
+  fs.writeFileSync(proseFile, JSON.stringify({
+    description: 'A module',
+    purpose: 'Provides function a.',
+    key_concepts: ['just one thing'],
+    public_api: '`a()`',
+    invariants: [],
+    gotchas: [],
+  }));
+  scanCodebase.run(['--apply-prose', '--module', 'src', '--prose-file', proseFile], {
+    cwd: root, stdout: captureStdout().stub,
+  });
+
+  const cap = captureStdout();
+  await doctor.run([], { cwd: root, stdout: cap.stub, stderr: cap.stub, askUser: async () => ({ value: false }) });
+  const out = cap.json();
+  const tbd = out.issues.find((i) => i.id === 'codebase-tbd-docs');
+  assert.ok(!tbd, 'expected no codebase-tbd-docs');
+});

package/bin/np-tools/new-project.cjs

@@ -153,6 +153,12 @@ function _apply(answersPath, cwd, stdout) {
     first_milestone_name: answers.first_milestone_name,
     first_phase_name: answers.first_phase_name,
     created_date: createdDate,
+    project_description: '_TBD — filled by `/np:discuss-project`._',
+    domain_text: '_TBD — filled by `/np:discuss-project`._',
+    target_users_text: '_TBD — filled by `/np:discuss-project`._',
+    non_goals_text: '_TBD — filled by `/np:discuss-project`._',
+    success_criteria_text: '_TBD — filled by `/np:discuss-project`._',
+    strategic_decisions_text: '_TBD — filled by `/np:discuss-project`._',
   };
   atomicWriteFileSync(projectMd, _render(_loadTemplate('PROJECT'), projectVars, 'PROJECT'));
 

package/bin/np-tools/scan-codebase.cjs

@@ -0,0 +1,204 @@
+const fs = require('node:fs');
+const path = require('node:path');
+
+const { NubosPilotError, atomicWriteFileSync } = require('../../lib/core.cjs');
+const { scan } = require('../../lib/workspace-scan.cjs');
+const { workspaceGitInfo } = require('../../lib/git.cjs');
+const {
+  manifestFromScanFiles,
+  writeManifest,
+  readManifest,
+} = require('../../lib/codebase-manifest.cjs');
+const {
+  groupFilesIntoModules,
+  buildModuleFacts,
+  renderModuleDoc,
+  buildIndexDoc,
+  buildDocIndexMap,
+  moduleDocPath,
+  indexDocPath,
+} = require('../../lib/codebase-docs.cjs');
+
+function _parseArgs(args) {
+  const flags = {
+    cwd: null,
+    batchSize: 500,
+    maxFiles: 0,
+    applyProse: false,
+    moduleId: null,
+    proseFile: null,
+    emitPlan: true,
+    projectName: null,
+  };
+  for (let i = 0; i < (args || []).length; i++) {
+    const a = args[i];
+    if (a === '--cwd') flags.cwd = args[++i];
+    else if (a === '--batch-size') flags.batchSize = parseInt(args[++i], 10);
+    else if (a === '--max-files') flags.maxFiles = parseInt(args[++i], 10);
+    else if (a === '--apply-prose') { flags.applyProse = true; flags.emitPlan = false; }
+    else if (a === '--module') flags.moduleId = args[++i];
+    else if (a === '--prose-file') flags.proseFile = args[++i];
+    else if (a === '--project-name') flags.projectName = args[++i];
+  }
+  return flags;
+}
+
+function _hashesLookupFromManifest(manifest) {
+  const lookup = {};
+  for (const [p, meta] of Object.entries(manifest.files || {})) {
+    lookup[p] = meta.sha256;
+  }
+  return lookup;
+}
+
+function _emitPlan(projectRoot, flags, stdout) {
+  const modulesResult = _scanAndBuild(projectRoot, flags);
+  stdout.write(JSON.stringify({
+    mode: 'plan',
+    cwd: projectRoot,
+    stats: modulesResult.scan.stats,
+    git: modulesResult.scan.git,
+    language_distribution: modulesResult.scan.language_distribution,
+    manifests: Object.keys(modulesResult.scan.manifests).sort(),
+    docs: Object.keys(modulesResult.scan.docs).sort(),
+    modules: modulesResult.modules.map((m) => ({
+      id: m.id,
+      directory: m.directory,
+      primary_language: m.primary_language,
+      file_count: m.file_count,
+      facts: m.facts,
+    })),
+    index_path: path.relative(projectRoot, indexDocPath(projectRoot)),
+    manifest_path: path.relative(
+      projectRoot,
+      path.join(projectRoot, '.nubos-pilot', 'codebase', '.hashes.json'),
+    ),
+  }, null, 2));
+}
+
+function _scanAndBuild(projectRoot, flags) {
+  const scanResult = scan({
+    cwd: projectRoot,
+    batchSize: flags.batchSize,
+    maxFiles: flags.maxFiles > 0 ? flags.maxFiles : undefined,
+    gitInfo: workspaceGitInfo,
+  });
+
+  const groups = groupFilesIntoModules(scanResult.files);
+  const modules = groups.map((g) => {
+    const facts = buildModuleFacts(g, projectRoot);
+    return Object.assign({}, g, { facts });
+  });
+
+  const manifest = manifestFromScanFiles(scanResult.files);
+  writeManifest(projectRoot, manifest);
+
+  const indexMapPath = path.join(
+    projectRoot,
+    '.nubos-pilot',
+    'codebase',
+    '.doc-index.json',
+  );
+  const docIndex = buildDocIndexMap(modules);
+  fs.mkdirSync(path.dirname(indexMapPath), { recursive: true });
+  atomicWriteFileSync(indexMapPath, JSON.stringify(docIndex, null, 2) + '\n');
+
+  const indexPath = indexDocPath(projectRoot);
+  fs.mkdirSync(path.dirname(indexPath), { recursive: true });
+  atomicWriteFileSync(indexPath, buildIndexDoc(modules, { project_name: flags.projectName || null }));
+
+  const hashLookup = _hashesLookupFromManifest(manifest);
+  for (const mod of modules) {
+    const docPath = moduleDocPath(projectRoot, mod.id);
+    if (fs.existsSync(docPath)) continue;
+    fs.mkdirSync(path.dirname(docPath), { recursive: true });
+    atomicWriteFileSync(docPath, renderModuleDoc(mod.facts, null, hashLookup));
+  }
+
+  return { scan: scanResult, modules, manifest, hashLookup };
+}
+
+function _applyProse(projectRoot, flags, stdout) {
+  if (!flags.moduleId) {
+    throw new NubosPilotError(
+      'scan-codebase-missing-module',
+      '--apply-prose requires --module <id>',
+      {},
+    );
+  }
+  if (!flags.proseFile) {
+    throw new NubosPilotError(
+      'scan-codebase-missing-prose',
+      '--apply-prose requires --prose-file <path>',
+      {},
+    );
+  }
+  let prose;
+  try {
+    prose = JSON.parse(fs.readFileSync(flags.proseFile, 'utf-8'));
+  } catch (err) {
+    throw new NubosPilotError(
+      'scan-codebase-prose-unreadable',
+      'prose file not readable or not valid JSON: ' + flags.proseFile,
+      { path: flags.proseFile, cause: err && err.message },
+    );
+  }
+
+  const scanResult = scan({
+    cwd: projectRoot,
+    batchSize: flags.batchSize,
+    maxFiles: flags.maxFiles > 0 ? flags.maxFiles : undefined,
+    gitInfo: workspaceGitInfo,
+  });
+  const groups = groupFilesIntoModules(scanResult.files);
+  const target = groups.find((g) => g.id === flags.moduleId);
+  if (!target) {
+    throw new NubosPilotError(
+      'scan-codebase-module-not-found',
+      `module not found: ${flags.moduleId}`,
+      { moduleId: flags.moduleId },
+    );
+  }
+
+  const facts = buildModuleFacts(target, projectRoot);
+  const manifest = manifestFromScanFiles(scanResult.files);
+  const hashLookup = _hashesLookupFromManifest(manifest);
+
+  const docPath = moduleDocPath(projectRoot, target.id);
+  fs.mkdirSync(path.dirname(docPath), { recursive: true });
+  const rendered = renderModuleDoc(facts, prose, hashLookup);
+  atomicWriteFileSync(docPath, rendered);
+
+  writeManifest(projectRoot, manifest);
+
+  stdout.write(JSON.stringify({
+    mode: 'apply-prose',
+    module_id: target.id,
+    doc_path: path.relative(projectRoot, docPath),
+    symbol_count: facts.symbols.length,
+  }, null, 2));
+}
+
+function run(args, ctx) {
+  const context = ctx || {};
+  const stdout = context.stdout || process.stdout;
+  const flags = _parseArgs(args);
+  const projectRoot = path.resolve(flags.cwd || context.cwd || process.cwd());
+
+  const stateDir = path.join(projectRoot, '.nubos-pilot');
+  if (!fs.existsSync(stateDir)) {
+    throw new NubosPilotError(
+      'scan-codebase-not-initialized',
+      '.nubos-pilot/ not found — run np:new-project first',
+      { cwd: projectRoot },
+    );
+  }
+
+  if (flags.applyProse) {
+    _applyProse(projectRoot, flags, stdout);
+  } else {
+    _emitPlan(projectRoot, flags, stdout);
+  }
+}
+
+module.exports = { run, _parseArgs };

package/bin/np-tools/scan-codebase.test.cjs

@@ -0,0 +1,165 @@
+const { test, afterEach } = 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 subcmd = require('./scan-codebase.cjs');
+
+const _sandboxes = [];
+
+function makeSandbox() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'np-sc-'));
+  fs.mkdirSync(path.join(dir, '.nubos-pilot'), { recursive: true });
+  _sandboxes.push(dir);
+  return dir;
+}
+
+function write(root, rel, content) {
+  const abs = path.join(root, rel);
+  fs.mkdirSync(path.dirname(abs), { recursive: true });
+  fs.writeFileSync(abs, content);
+}
+
+function captureStdout() {
+  const chunks = [];
+  return {
+    stub: { write: (s) => chunks.push(String(s)) },
+    text: () => chunks.join(''),
+    json: () => JSON.parse(chunks.join('')),
+  };
+}
+
+afterEach(() => {
+  while (_sandboxes.length) {
+    const dir = _sandboxes.pop();
+    try { fs.rmSync(dir, { recursive: true, force: true }); } catch {}
+  }
+});
+
+test('SC-1: throws when .nubos-pilot missing', () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'np-sc-bare-'));
+  _sandboxes.push(dir);
+  assert.throws(
+    () => subcmd.run([], { cwd: dir, stdout: captureStdout().stub }),
+    (err) => err.code === 'scan-codebase-not-initialized',
+  );
+});
+
+test('SC-2: emits plan with modules, stats, and writes INDEX.md + stubs + manifest', () => {
+  const root = makeSandbox();
+  write(root, 'src/auth/login.js', 'export function login(){}');
+  write(root, 'src/auth/session.js', 'export class Session{}');
+  write(root, 'src/billing/invoice.js', 'export function invoice(){}');
+
+  const cap = captureStdout();
+  subcmd.run(['--project-name', 'Demo'], { cwd: root, stdout: cap.stub });
+  const out = cap.json();
+
+  assert.equal(out.mode, 'plan');
+  assert.ok(out.stats.file_count >= 3);
+  assert.ok(Array.isArray(out.modules));
+  const ids = out.modules.map((m) => m.id).sort();
+  assert.ok(ids.includes('src-auth'));
+  assert.ok(ids.includes('src-billing'));
+
+  assert.ok(fs.existsSync(path.join(root, '.nubos-pilot', 'codebase', 'INDEX.md')));
+  assert.ok(fs.existsSync(path.join(root, '.nubos-pilot', 'codebase', '.hashes.json')));
+  assert.ok(fs.existsSync(path.join(root, '.nubos-pilot', 'codebase', 'modules', 'src-auth.md')));
+
+  const indexMd = fs.readFileSync(path.join(root, '.nubos-pilot', 'codebase', 'INDEX.md'), 'utf-8');
+  assert.ok(indexMd.includes('Demo'));
+});
+
+test('SC-3: module stub contains facts in frontmatter even before prose', () => {
+  const root = makeSandbox();
+  write(root, 'src/auth/login.js', [
+    'import bcrypt from "bcrypt";',
+    'export function login(){}',
+    'export class Session {}',
+  ].join('\n'));
+
+  const cap = captureStdout();
+  subcmd.run([], { cwd: root, stdout: cap.stub });
+  const stub = fs.readFileSync(
+    path.join(root, '.nubos-pilot', 'codebase', 'modules', 'src-auth.md'),
+    'utf-8',
+  );
+  assert.ok(stub.startsWith('---\n'));
+  assert.ok(stub.includes('module_id: src-auth'));
+  assert.ok(stub.includes('symbols:'));
+  assert.ok(stub.includes('- login'));
+  assert.ok(stub.includes('- Session'));
+  assert.ok(stub.includes('external_deps:'));
+  assert.ok(stub.includes('- bcrypt'));
+  assert.ok(stub.includes('_TBD'));
+});
+
+test('SC-4: apply-prose merges prose sections into existing stub', () => {
+  const root = makeSandbox();
+  write(root, 'src/auth/login.js', 'export function login(){}');
+
+  const initialCap = captureStdout();
+  subcmd.run([], { cwd: root, stdout: initialCap.stub });
+
+  const proseFile = path.join(root, '.nubos-pilot', 'prose-auth.json');
+  fs.writeFileSync(proseFile, JSON.stringify({
+    description: 'Login flow',
+    purpose: 'Authenticates the user.',
+    key_concepts: ['Session token issued on success'],
+    public_api: '`login(user)` returns a Session',
+    invariants: ['No plaintext passwords'],
+    gotchas: ['bcrypt cost from env'],
+  }));
+
+  const cap = captureStdout();
+  subcmd.run(['--apply-prose', '--module', 'src-auth', '--prose-file', proseFile], {
+    cwd: root,
+    stdout: cap.stub,
+  });
+  const out = cap.json();
+  assert.equal(out.mode, 'apply-prose');
+  assert.equal(out.module_id, 'src-auth');
+
+  const doc = fs.readFileSync(
+    path.join(root, '.nubos-pilot', 'codebase', 'modules', 'src-auth.md'),
+    'utf-8',
+  );
+  assert.ok(doc.includes('description: Login flow'));
+  assert.ok(doc.includes('Authenticates the user.'));
+  assert.ok(doc.includes('Session token issued on success'));
+  assert.ok(doc.includes('bcrypt cost from env'));
+});
+
+test('SC-5: apply-prose requires --module and --prose-file', () => {
+  const root = makeSandbox();
+  write(root, 'src/a.js', 'x');
+  subcmd.run([], { cwd: root, stdout: captureStdout().stub });
+
+  assert.throws(
+    () => subcmd.run(['--apply-prose'], { cwd: root, stdout: captureStdout().stub }),
+    (err) => err.code === 'scan-codebase-missing-module',
+  );
+  assert.throws(
+    () => subcmd.run(['--apply-prose', '--module', 'src'], {
+      cwd: root, stdout: captureStdout().stub,
+    }),
+    (err) => err.code === 'scan-codebase-missing-prose',
+  );
+});
+
+test('SC-6: apply-prose with unknown module throws', () => {
+  const root = makeSandbox();
+  write(root, 'src/a.js', 'x');
+  subcmd.run([], { cwd: root, stdout: captureStdout().stub });
+
+  const proseFile = path.join(root, 'p.json');
+  fs.writeFileSync(proseFile, JSON.stringify({ description: 'x' }));
+  assert.throws(
+    () => subcmd.run(
+      ['--apply-prose', '--module', 'does-not-exist', '--prose-file', proseFile],
+      { cwd: root, stdout: captureStdout().stub },
+    ),
+    (err) => err.code === 'scan-codebase-module-not-found',
+  );
+});