@mcptoolshop/style-dataset-lab 3.0.0 → 3.1.0

package/scripts/generate.js

@@ -10,11 +10,36 @@
  * downloads the output PNG, and writes a provenance record to records/.
  */
 
-import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { writeFile, mkdir } from "node:fs/promises";
+import { existsSync } from "node:fs";
 import { join } from "node:path";
-import { getProjectName } from "../lib/args.js";
-import { REPO_ROOT } from "../lib/paths.js";
+import { parseArgs, getProjectName } from "../lib/args.js";
+import { REPO_ROOT, resolveSafeProjectPath } from "../lib/paths.js";
+import { readJsonFile } from "../lib/config.js";
+import { runtimeError, handleCliError } from "../lib/errors.js";
 import { comfyHealth, submitAndWait, downloadImage } from "../lib/comfyui.js";
+import { pickOutputImage } from "../lib/comfyui-output.js";
+import { info, result } from "../lib/log.js";
+
+/**
+ * Format milliseconds as a human ETA string like "6m 12s" or "42s".
+ */
+function formatEta(ms) {
+  if (!Number.isFinite(ms) || ms < 0) return '—';
+  const totalSec = Math.round(ms / 1000);
+  if (totalSec < 60) return `${totalSec}s`;
+  const m = Math.floor(totalSec / 60);
+  const s = totalSec % 60;
+  return `${m}m ${s}s`;
+}
+
+/**
+ * COMFY_URL precedence:
+ *   1. process.env.COMFY_URL (explicit user env)
+ *   2. project defaults.comfy_url (set by `sdlab project doctor`)
+ *   3. built-in default http://127.0.0.1:8188
+ * The adapter (lib/adapters/comfyui-runner.js) applies the same precedence.
+ */
 
 function buildWorkflow(prompt, negativePrompt, checkpoint, loras, seed, steps, cfg, sampler, scheduler, width, height, ipAdapterConfig) {
   const nodes = {};
@@ -157,11 +182,21 @@ export async function run(argv = process.argv.slice(2)) {
   const GAME_ROOT = join(REPO_ROOT, 'projects', projectName);
   const COMFY_URL = process.env.COMFY_URL || "http://127.0.0.1:8188";
 
-  const packPath = argv.find((a) => !a.startsWith("--")) || "inputs/prompts/rpg-icons-lane1.json";
-  const dryRun = argv.includes("--dry-run");
+  const parsed = parseArgs(argv, {
+    flags: {
+      project: { type: 'string' },
+      game: { type: 'string' },
+      'dry-run': { type: 'boolean' },
+      resume: { type: 'boolean' },
+    },
+    deprecated: { game: 'project' },
+  });
+  const packPath = parsed.positionals[0] || "inputs/prompts/rpg-icons-lane1.json";
+  const dryRun = parsed.flags['dry-run'] === true;
+  const resume = parsed.flags['resume'] === true;
 
-  const fullPackPath = join(GAME_ROOT, packPath);
-  const pack = JSON.parse(await readFile(fullPackPath, "utf-8"));
+  const fullPackPath = resolveSafeProjectPath(GAME_ROOT, packPath, { flagName: 'pack-path' });
+  const pack = await readJsonFile(fullPackPath, { requiredFields: ['lane', 'subjects', 'variations', 'defaults'] });
 
   console.log(`\x1b[1mstyle-dataset-lab\x1b[0m generate`);
   console.log(`  Lane: ${pack.lane}`);
@@ -173,7 +208,7 @@ export async function run(argv = process.argv.slice(2)) {
   if (!dryRun) {
     const online = await comfyHealth(COMFY_URL);
     if (!online) {
-      throw new Error("ComfyUI not reachable at " + COMFY_URL);
+      throw runtimeError('RUNTIME_COMFY_UNREACHABLE', "ComfyUI not reachable at " + COMFY_URL, 'Start ComfyUI or set COMFY_URL to the right host.');
     }
     console.log("\x1b[32m✓\x1b[0m ComfyUI online");
   }
@@ -183,7 +218,10 @@ export async function run(argv = process.argv.slice(2)) {
 
   const d = pack.defaults;
   let generated = 0;
+  let errors = 0;
+  let skipped = 0;
   const totalExpected = pack.subjects.length * pack.variations.length;
+  const runStartMs = Date.now();
 
   for (const subject of pack.subjects) {
     for (const variation of pack.variations) {
@@ -192,6 +230,20 @@ export async function run(argv = process.argv.slice(2)) {
       const fullPrompt = `${pack.style_prefix}, ${subject.prompt}`;
       const loras = variation.loras || [];
 
+      // --resume: skip subjects whose record + image are both already on disk.
+      // Seeds are deterministic per (base_seed, generated, variation), so
+      // increment `generated` for skipped slots to keep downstream seeds stable.
+      if (resume && !dryRun) {
+        const recordPath = join(GAME_ROOT, `records/${assetId}.json`);
+        const imagePath = join(GAME_ROOT, `outputs/candidates/${assetId}.png`);
+        if (existsSync(recordPath) && existsSync(imagePath)) {
+          console.log(`  [${generated + 1}/${totalExpected}] ${assetId} \x1b[2m(resumed — skipped)\x1b[0m`);
+          generated++;
+          skipped++;
+          continue;
+        }
+      }
+
       console.log(`  [${generated + 1}/${totalExpected}] ${assetId} (seed: ${seed}, loras: ${loras.length})`);
 
       if (dryRun) {
@@ -200,7 +252,7 @@ export async function run(argv = process.argv.slice(2)) {
       }
 
       const startMs = Date.now();
-      const { nodes } = buildWorkflow(
+      const { nodes, saveNodeId } = buildWorkflow(
         fullPrompt, pack.negative,
         d.checkpoint, loras, seed,
         d.steps, d.cfg, d.sampler, d.scheduler,
@@ -208,29 +260,20 @@ export async function run(argv = process.argv.slice(2)) {
       );
 
       try {
-        const result = await submitAndWait(nodes, COMFY_URL);
+        const submitResult = await submitAndWait(nodes, COMFY_URL);
         const elapsed = Date.now() - startMs;
 
-        // Find output image
-        const outputs = result.outputs || {};
-        let imageFile = null;
-        let imageSubfolder = "";
-        for (const nodeOut of Object.values(outputs)) {
-          if (nodeOut.images && nodeOut.images.length > 0) {
-            imageFile = nodeOut.images[0].filename;
-            imageSubfolder = nodeOut.images[0].subfolder || "";
-            break;
-          }
-        }
-
-        if (!imageFile) {
+        // Prefer the explicit SaveImage node from buildWorkflow; fall back
+        // to highest numeric node id (see lib/comfyui-output.js).
+        const picked = pickOutputImage(submitResult.outputs, { preferNodeId: saveNodeId });
+        if (!picked) {
           console.log(`    \x1b[33m⚠\x1b[0m No output image found`);
           generated++;
           continue;
         }
 
         // Download and save
-        const imgData = await downloadImage(imageFile, imageSubfolder, COMFY_URL);
+        const imgData = await downloadImage(picked.filename, picked.subfolder, COMFY_URL);
         const destPath = `outputs/candidates/${assetId}.png`;
         await writeFile(join(GAME_ROOT, destPath), imgData);
 
@@ -272,21 +315,45 @@ export async function run(argv = process.argv.slice(2)) {
         console.log(`    \x1b[32m✓\x1b[0m ${destPath} (${elapsed}ms, ${imgData.length} bytes)`);
       } catch (err) {
         console.log(`    \x1b[31m✗\x1b[0m ${err.message}`);
+        errors++;
       }
 
       generated++;
+
+      // ETA every 5 items (not every item — too noisy for long runs).
+      if (!dryRun && generated > 0 && generated % 5 === 0 && generated < totalExpected) {
+        const elapsedTotal = Date.now() - runStartMs;
+        const avgMs = elapsedTotal / generated;
+        const remaining = totalExpected - generated;
+        const etaMs = avgMs * remaining;
+        info('generate', `progress ${generated}/${totalExpected} — avg ${formatEta(avgMs)}/item, ETA ~${formatEta(etaMs)}`);
+      }
     }
   }
 
   console.log("");
-  console.log(`\x1b[32m✓\x1b[0m Generated ${generated} candidates`);
+  const succeeded = generated - errors - skipped;
+  const totalElapsedMs = Date.now() - runStartMs;
+  const skippedSuffix = skipped > 0 ? `, ${skipped} resumed` : '';
+  console.log(`\x1b[32m✓\x1b[0m Generated ${succeeded} candidates (${errors} errors${skippedSuffix})`);
+  if (!dryRun && generated > skipped) {
+    const ran = generated - skipped;
+    const avgMs = totalElapsedMs / ran;
+    console.log(`  Total: ${formatEta(totalElapsedMs)} — avg ${formatEta(avgMs)}/item over ${ran} new`);
+  }
   if (dryRun) console.log("  (dry run — no images produced)");
+  // Always print the output directory so scripted pipelines can parse it,
+  // even under --quiet.
+  if (!dryRun && succeeded > 0) {
+    result(`Candidates: ${join(GAME_ROOT, 'outputs/candidates')}`);
+    result(`Records: ${join(GAME_ROOT, 'records')}`);
+  }
+  if (!dryRun && errors > 0 && succeeded === 0) {
+    throw runtimeError('RUNTIME_ALL_FAILED', `All ${totalExpected} generation attempts failed.`);
+  }
 }
 
 // Direct execution guard
 if (process.argv[1] && (process.argv[1].endsWith('generate.js') || process.argv[1].endsWith('generate'))) {
-  run().catch((err) => {
-    console.error(err.message || err);
-    process.exit(1);
-  });
+  run().catch(handleCliError);
 }

package/scripts/implementation-pack.js

@@ -10,25 +10,30 @@
  */
 
 import { join } from 'node:path';
-import { getProjectName } from '../lib/args.js';
+import { parseArgs, getProjectName } from '../lib/args.js';
 import { REPO_ROOT } from '../lib/paths.js';
+import { inputError, handleCliError } from '../lib/errors.js';
 import { listTrainingManifests } from '../lib/training-manifests.js';
 import { buildImplementationPack, listImplementationPacks, loadImplementationPack } from '../lib/implementation-packs.js';
 
 export async function run(argv = process.argv.slice(2)) {
-  const projectName = getProjectName(argv);
+  const { flags, positionals } = parseArgs(argv, {
+    flags: {
+      project: { type: 'string' },
+      manifest: { type: 'string' },
+    },
+    deprecated: { game: 'project' },
+  });
+
+  const projectName = flags.project || getProjectName(argv);
   const projectRoot = join(REPO_ROOT, 'projects', projectName);
-  const subcommand = argv.find(a => !a.startsWith('--') && !a.startsWith('impl-') && !a.startsWith('tm-')) || 'list';
-  const args = argv.filter(a => a !== subcommand);
+  const subcommand = positionals.find(a => !a.startsWith('impl-') && !a.startsWith('tm-')) || 'list';
 
   if (subcommand === 'build') {
-    let manifestId;
-    const manifestIdx = args.indexOf('--manifest');
-    if (manifestIdx >= 0) {
-      manifestId = args[manifestIdx + 1];
-    } else {
+    let manifestId = flags.manifest;
+    if (!manifestId) {
       const manifests = await listTrainingManifests(projectRoot);
-      if (manifests.length === 0) throw new Error('No training manifests. Run: sdlab training-manifest create');
+      if (manifests.length === 0) throw inputError('INPUT_NO_MANIFEST', 'No training manifests. Run: sdlab training-manifest create');
       manifestId = manifests[manifests.length - 1].id;
     }
 
@@ -44,8 +49,8 @@ export async function run(argv = process.argv.slice(2)) {
     console.log(`  Subject continuity:   ${result.subjects}`);
 
   } else if (subcommand === 'show') {
-    const implId = args.find(a => a.startsWith('impl-'));
-    if (!implId) throw new Error('Usage: sdlab implementation-pack show <impl-id>');
+    const implId = positionals.find(a => a.startsWith('impl-'));
+    if (!implId) throw inputError('INPUT_MISSING_ARGS', 'Usage: sdlab implementation-pack show <impl-id>');
 
     const pack = await loadImplementationPack(projectRoot, implId);
     console.log(`\x1b[1mImplementation pack\x1b[0m — ${implId}\n`);
@@ -69,10 +74,10 @@ export async function run(argv = process.argv.slice(2)) {
     }
 
   } else {
-    throw new Error(`Unknown subcommand: ${subcommand}. Use: build, show, list`);
+    throw inputError('INPUT_BAD_SUBCOMMAND', `Unknown subcommand: ${subcommand}. Use: build, show, list`);
   }
 }
 
 if (process.argv[1] && (process.argv[1].endsWith('implementation-pack.js') || process.argv[1].endsWith('implementation-pack'))) {
-  run().catch((err) => { console.error(err.message || err); process.exit(1); });
+  run().catch(handleCliError);
 }

package/scripts/init.js

@@ -13,6 +13,7 @@ import { mkdir, readdir, readFile, writeFile, copyFile } from 'node:fs/promises'
 import { join, basename } from 'node:path';
 import { existsSync } from 'node:fs';
 import { REPO_ROOT } from '../lib/paths.js';
+import { inputError, handleCliError } from '../lib/errors.js';
 
 const TEMPLATES_DIR = join(REPO_ROOT, 'templates');
 const PROJECTS_DIR = join(REPO_ROOT, 'projects');
@@ -82,15 +83,28 @@ export async function run(argv = process.argv.slice(2)) {
   }
 
   if (!isValidName(projectName)) {
-    throw new Error(
-      `Invalid project name "${projectName}".\n` +
+    throw inputError(
+      'INPUT_BAD_NAME',
+      `Invalid project name "${projectName}".`,
       `Use lowercase letters, numbers, and hyphens (e.g. "my-project").`
     );
   }
 
+  // Validate --domain to prevent path traversal via template lookup.
+  if (!isValidName(domain)) {
+    throw inputError(
+      'INPUT_BAD_DOMAIN',
+      `Invalid --domain "${domain}".`,
+      `Use lowercase letters, numbers, and hyphens (e.g. "character-design").`
+    );
+  }
+
   const projectDir = join(PROJECTS_DIR, projectName);
   if (existsSync(projectDir)) {
-    throw new Error(`Project "${projectName}" already exists at ${projectDir}`);
+    throw inputError(
+      'INPUT_PROJECT_EXISTS',
+      `Project "${projectName}" already exists at ${projectDir}`
+    );
   }
 
   // Resolve domain template source
@@ -99,8 +113,9 @@ export async function run(argv = process.argv.slice(2)) {
     domainDir = join(TEMPLATES_DIR, 'domains', domain);
     if (!existsSync(domainDir)) {
       const domains = await listDomains();
-      throw new Error(
-        `Domain "${domain}" not found.\n` +
+      throw inputError(
+        'INPUT_UNKNOWN_DOMAIN',
+        `Domain "${domain}" not found.`,
         `Available: generic, ${domains.join(', ')}`
       );
     }
@@ -206,18 +221,30 @@ export async function run(argv = process.argv.slice(2)) {
 
   // Copy canon markdown templates
   const canonTemplates = ['constitution.md', 'review-rubric.md'];
+  const wroteCanon = {};
   for (const file of canonTemplates) {
     const src = join(TEMPLATES_DIR, 'canon', file);
     if (existsSync(src)) {
       await copyFile(src, join(projectDir, 'canon', file));
+      wroteCanon[file] = true;
       console.log(`  \x1b[32m✓\x1b[0m canon/${file}`);
     }
   }
 
-  // Copy example prompt pack
-  const examplePack = join(TEMPLATES_DIR, 'inputs', 'prompts', 'example-wave.json');
-  if (existsSync(examplePack)) {
+  // Copy example prompt pack — prefer per-domain example (subjects match domain lane id_patterns),
+  // fall back to legacy global template if it exists (pre-v3.0.1 installs may still ship it).
+  let wroteExamplePack = false;
+  const domainExamplePack = domainDir
+    ? join(domainDir, 'inputs', 'prompts', 'example-wave.json')
+    : null;
+  const globalExamplePack = join(TEMPLATES_DIR, 'inputs', 'prompts', 'example-wave.json');
+  const examplePack =
+    domainExamplePack && existsSync(domainExamplePack) ? domainExamplePack
+    : existsSync(globalExamplePack) ? globalExamplePack
+    : null;
+  if (examplePack) {
     await copyFile(examplePack, join(projectDir, 'inputs', 'prompts', 'example-wave.json'));
+    wroteExamplePack = true;
     console.log(`  \x1b[32m✓\x1b[0m inputs/prompts/example-wave.json`);
   }
 
@@ -236,21 +263,92 @@ export async function run(argv = process.argv.slice(2)) {
     }
   }
 
+  // Write a starter README.md inside the project so users have a home base
+  // with copy-pasteable next commands and a place for their notes.
+  const readmeLines = [
+    `# ${projectName}`,
+    '',
+    `A \`style-dataset-lab\` project — domain: **${domain}**.`,
+    '',
+    '## Quick commands',
+    '',
+    '```bash',
+    `# Validate that the scaffold is healthy`,
+    `sdlab project doctor --project ${projectName}`,
+    '',
+  ];
+  if (wroteExamplePack) {
+    readmeLines.push(
+      `# Generate candidates from the example prompt pack`,
+      `sdlab generate inputs/prompts/example-wave.json --project ${projectName}`,
+      ''
+    );
+  } else {
+    readmeLines.push(
+      `# Generate candidates (add a prompt pack under inputs/prompts/ first)`,
+      `sdlab generate <pack-path> --project ${projectName}`,
+      ''
+    );
+  }
+  readmeLines.push(
+    `# Curate a candidate (approved | rejected | borderline)`,
+    `sdlab curate <asset_id> approved "reads clean" --project ${projectName}`,
+    '',
+    `# Bind approved records to constitution rules`,
+    `sdlab canon-bind --project ${projectName}`,
+    '',
+    `# Create a frozen dataset snapshot`,
+    `sdlab snapshot create --project ${projectName}`,
+    '```',
+    '',
+    '## Project layout',
+    '',
+    '- `project.json` — defaults (checkpoint, width, height, sampler)',
+    '- `constitution.json` — machine-readable style rules',
+    '- `canon/` — human-authored style reference (constitution.md, review-rubric.md)',
+    '- `inputs/prompts/` — generation prompt packs',
+    '- `outputs/candidates/` — raw generated PNGs',
+    '- `outputs/approved/` · `outputs/rejected/` · `outputs/borderline/` — curated outputs',
+    '- `records/` — provenance + judgment records (one JSON per candidate)',
+    '- `snapshots/` · `splits/` · `exports/` — frozen dataset artifacts',
+    '',
+    '## Docs',
+    '',
+    '- Handbook: https://mcp-tool-shop-org.github.io/style-dataset-lab/',
+    '- CLI reference: `sdlab --help` (or `sdlab <cmd> --help` for any command)',
+    '',
+    '## TODO',
+    '',
+    '- [ ] Fill in `canon/constitution.md` with your style rules',
+    '- [ ] Encode those rules in `constitution.json` for canon-bind',
+    '- [ ] Add at least one prompt pack under `inputs/prompts/`',
+    '- [ ] Run `sdlab project doctor` and fix any warnings',
+    ''
+  );
+  await writeFile(join(projectDir, 'README.md'), readmeLines.join('\n'));
+  console.log(`  \x1b[32m✓\x1b[0m README.md`);
+
   console.log('');
   console.log(`\x1b[32m✓\x1b[0m Project "${projectName}" initialized`);
   console.log('');
   console.log('Next steps:');
-  console.log(`  1. Edit ${projectName}/canon/constitution.md — define your visual rules`);
-  console.log(`  2. Edit ${projectName}/constitution.json — encode rules for canon-bind`);
-  console.log(`  3. Create prompt packs in ${projectName}/inputs/prompts/`);
-  console.log(`  4. Run: sdlab generate <pack> --project ${projectName}`);
-  console.log(`  5. Run: sdlab project doctor --project ${projectName}`);
+  let step = 1;
+  if (wroteCanon['constitution.md']) {
+    console.log(`  ${step++}. Edit ${projectName}/canon/constitution.md — define your visual rules`);
+  }
+  console.log(`  ${step++}. Edit ${projectName}/constitution.json — encode rules for canon-bind`);
+  if (wroteExamplePack) {
+    console.log(`  ${step++}. Run: sdlab generate inputs/prompts/example-wave.json --project ${projectName}`);
+  } else {
+    console.log(`  ${step++}. Create prompt packs under ${projectName}/inputs/prompts/`);
+    console.log(`  ${step++}. Run: sdlab generate <pack> --project ${projectName}`);
+  }
+  console.log(`  ${step++}. Run: sdlab project doctor --project ${projectName}`);
+  console.log('');
+  console.log(`See ${projectName}/README.md for the full quick-start.`);
 }
 
 // Direct execution guard
 if (process.argv[1] && (process.argv[1].endsWith('init.js') || process.argv[1].endsWith('init'))) {
-  run().catch((err) => {
-    console.error(err.message || err);
-    process.exit(1);
-  });
+  run().catch(handleCliError);
 }

package/scripts/painterly.js

@@ -18,8 +18,9 @@
 import { writeFile, mkdir, readdir } from "node:fs/promises";
 import { join } from "node:path";
 import { existsSync } from "node:fs";
-import { getProjectName } from "../lib/args.js";
-import { REPO_ROOT } from "../lib/paths.js";
+import { getProjectName, parseNumberFlag } from "../lib/args.js";
+import { REPO_ROOT, resolveSafeProjectPath } from "../lib/paths.js";
+import { runtimeError, handleCliError } from "../lib/errors.js";
 import { comfyHealth, submitAndWait, downloadImage, uploadImage } from "../lib/comfyui.js";
 
 // ── Config ──
@@ -156,11 +157,11 @@ export async function run(argv = process.argv.slice(2)) {
 
   for (let i = 0; i < argv.length; i++) {
     if (argv[i] === "--source" && argv[i + 1]) sourceDir = argv[++i];
-    if (argv[i] === "--limit" && argv[i + 1]) limit = parseInt(argv[++i]);
-    if (argv[i] === "--offset" && argv[i + 1]) offset = parseInt(argv[++i]);
+    else if (argv[i] === "--limit" && argv[i + 1]) limit = parseNumberFlag('limit', argv[++i], { int: true, min: 1 });
+    else if (argv[i] === "--offset" && argv[i + 1]) offset = parseNumberFlag('offset', argv[++i], { int: true, min: 0 });
   }
 
-  const fullSourceDir = join(GAME_ROOT, sourceDir);
+  const fullSourceDir = resolveSafeProjectPath(GAME_ROOT, sourceDir, { flagName: 'source' });
   const outDir = join(GAME_ROOT, "outputs/painterly");
   await mkdir(outDir, { recursive: true });
 
@@ -195,7 +196,7 @@ export async function run(argv = process.argv.slice(2)) {
   if (!dryRun) {
     const online = await comfyHealth(COMFY_URL);
     if (!online) {
-      throw new Error("ComfyUI not reachable at " + COMFY_URL);
+      throw runtimeError('RUNTIME_COMFY_UNREACHABLE', "ComfyUI not reachable at " + COMFY_URL);
     }
     console.log("\x1b[32m✓\x1b[0m ComfyUI online");
   }
@@ -263,8 +264,5 @@ export async function run(argv = process.argv.slice(2)) {
 
 // Direct execution guard
 if (process.argv[1] && (process.argv[1].endsWith('painterly.js') || process.argv[1].endsWith('painterly'))) {
-  run().catch((err) => {
-    console.error(err.message || err);
-    process.exit(1);
-  });
+  run().catch(handleCliError);
 }

package/scripts/refine.js

@@ -11,7 +11,7 @@
 
 import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
-import { parseArgs } from '../lib/args.js';
+import { parseArgs, getProjectName } from '../lib/args.js';
 import { getProjectRoot, getRunsDir } from '../lib/paths.js';
 import { loadCritique } from '../lib/critique-engine.js';
 import {
@@ -25,7 +25,7 @@ import { info } from '../lib/log.js';
 export async function run(argv = process.argv.slice(2)) {
   const { flags } = parseArgs(argv, {
     flags: {
-      project: { type: 'string', default: 'star-freight' },
+      project: { type: 'string' },
       run: { type: 'string' },
       pick: { type: 'string' },
       preserve: { type: 'string' },
@@ -49,7 +49,7 @@ export async function run(argv = process.argv.slice(2)) {
     return;
   }
 
-  const projectName = flags.project;
+  const projectName = flags.project || getProjectName(argv);
   const projectRoot = getProjectRoot(projectName);
   const runId = flags.run;
   const pickedFilename = flags.pick;

package/scripts/reingest-selected.js

@@ -8,7 +8,7 @@
  *   sdlab reingest selected --selection selection_2026-04-16_001 --dry-run
  */
 
-import { parseArgs } from '../lib/args.js';
+import { parseArgs, getProjectName } from '../lib/args.js';
 import { getProjectRoot } from '../lib/paths.js';
 import { reingestSelection } from '../lib/reingest-selected.js';
 import { info } from '../lib/log.js';
@@ -16,7 +16,7 @@ import { info } from '../lib/log.js';
 export async function run(argv = process.argv.slice(2)) {
   const { flags } = parseArgs(argv, {
     flags: {
-      project: { type: 'string', default: 'star-freight' },
+      project: { type: 'string' },
       selection: { type: 'string' },
       'dry-run': { type: 'boolean' },
       json: { type: 'boolean' },
@@ -34,7 +34,7 @@ export async function run(argv = process.argv.slice(2)) {
     return;
   }
 
-  const projectName = flags.project;
+  const projectName = flags.project || getProjectName(argv);
   const projectRoot = getProjectRoot(projectName);
   const dryRun = flags['dry-run'] || false;
 

package/scripts/reingest.js

@@ -5,38 +5,51 @@
  *
  * Usage:
  *   sdlab reingest generated --source <dir> --manifest <id> [--dry-run] [--project <name>]
+ *   sdlab reingest selected --selection <id> [--project <name>]
  *   sdlab reingest audit [--project <name>]
  */
 
 import { join } from 'node:path';
-import { getProjectName } from '../lib/args.js';
-import { REPO_ROOT } from '../lib/paths.js';
+import { parseArgs, getProjectName } from '../lib/args.js';
+import { REPO_ROOT, resolveSafeProjectPath } from '../lib/paths.js';
+import { inputError, handleCliError } from '../lib/errors.js';
 import { reingestGenerated, auditReingest } from '../lib/reingest.js';
 
 export async function run(argv = process.argv.slice(2)) {
-  const projectName = getProjectName(argv);
+  const { flags, positionals } = parseArgs(argv, {
+    flags: {
+      project: { type: 'string' },
+      source: { type: 'string' },
+      manifest: { type: 'string' },
+      selection: { type: 'string' },
+      'dry-run': { type: 'boolean', default: false },
+    },
+    deprecated: { game: 'project' },
+    allowUnknown: true, // forward unknowns to delegated 'selected' path
+  });
+
+  const projectName = flags.project || getProjectName(argv);
   const projectRoot = join(REPO_ROOT, 'projects', projectName);
-  const subcommand = argv.find(a => !a.startsWith('--')) || 'audit';
-  const args = argv.filter(a => a !== subcommand);
+  const subcommand = positionals[0] || 'audit';
 
   if (subcommand === 'generated') {
-    const sourceIdx = args.indexOf('--source');
-    if (sourceIdx < 0) throw new Error('--source <dir> is required (directory of generated images)');
-    const sourcePath = args[sourceIdx + 1];
-
-    const manifestIdx = args.indexOf('--manifest');
-    if (manifestIdx < 0) throw new Error('--manifest <id> is required (training manifest that produced the outputs)');
-    const manifestId = args[manifestIdx + 1];
+    if (!flags.source) {
+      throw inputError('INPUT_MISSING_FLAG', '--source <dir> is required (directory of generated images)');
+    }
+    if (!flags.manifest) {
+      throw inputError('INPUT_MISSING_FLAG', '--manifest <id> is required (training manifest that produced the outputs)');
+    }
 
-    const dryRun = args.includes('--dry-run');
+    const safeSource = resolveSafeProjectPath(projectRoot, flags.source, { baseRoot: REPO_ROOT, flagName: 'source' });
+    const dryRun = flags['dry-run'] || flags.dryRun;
 
     console.log(`\x1b[1msdlab reingest generated\x1b[0m — ${projectName}`);
-    console.log(`  Source:   ${sourcePath}`);
-    console.log(`  Manifest: ${manifestId}`);
+    console.log(`  Source:   ${flags.source}`);
+    console.log(`  Manifest: ${flags.manifest}`);
     if (dryRun) console.log(`  Mode:     DRY RUN (no records written)`);
     console.log('');
 
-    const result = await reingestGenerated(projectRoot, sourcePath, manifestId, { dryRun });
+    const result = await reingestGenerated(projectRoot, safeSource, flags.manifest, { dryRun });
 
     console.log(`  \x1b[32m✓\x1b[0m Created: ${result.created} records`);
     if (result.skipped > 0) {
@@ -51,9 +64,9 @@ export async function run(argv = process.argv.slice(2)) {
     }
 
   } else if (subcommand === 'selected') {
-    // Delegate to reingest-selected.js
+    // Delegate to reingest-selected.js — pass the full argv so it can re-parse
     const { run: runSelected } = await import('./reingest-selected.js');
-    await runSelected(args);
+    await runSelected(argv.slice(argv.indexOf(subcommand) + 1));
     return;
 
   } else if (subcommand === 'audit') {
@@ -83,10 +96,10 @@ export async function run(argv = process.argv.slice(2)) {
     }
 
   } else {
-    throw new Error(`Unknown subcommand: ${subcommand}. Use: generated, selected, audit`);
+    throw inputError('INPUT_BAD_SUBCOMMAND', `Unknown subcommand: ${subcommand}. Use: generated, selected, audit`);
   }
 }
 
 if (process.argv[1] && (process.argv[1].endsWith('reingest.js') || process.argv[1].endsWith('reingest'))) {
-  run().catch((err) => { console.error(err.message || err); process.exit(1); });
+  run().catch(handleCliError);
 }