@mcptoolshop/style-dataset-lab 2.2.1 → 3.0.0

package/scripts/doctor.js

@@ -41,6 +41,13 @@ const REQUIRED_DIRS = [
   'training/packages',
   'training/eval-runs',
   'training/implementations',
+  'workflows/profiles',
+  'workflows/batch-modes',
+  'briefs',
+  'runs',
+  'batches',
+  'selections',
+  'inbox/generated',
 ];
 
 function pass(msg) { console.log(`  \x1b[32m✓\x1b[0m ${msg}`); }
@@ -284,7 +291,168 @@ export async function run(argv = process.argv.slice(2)) {
     }
   }
 
-  // ── 9. Records sanity check ──
+  // ── 9. Workflow profile validation ──
+  const workflowDir = join(projectDir, 'workflows', 'profiles');
+  if (existsSync(workflowDir)) {
+    console.log('');
+    const wfFiles = readdirSync(workflowDir).filter(f => f.endsWith('.json'));
+    if (wfFiles.length > 0) {
+      const VALID_SUBJECT_MODES = ['required', 'optional', 'forbidden'];
+      const VALID_OUTPUT_MODES = ['portrait_set', 'expression_sheet', 'variant_pack', 'moodboard', 'silhouette_sheet', 'turnaround'];
+      const laneIds = new Set((lanes?.lanes || []).map(l => l.id));
+
+      let wfErrors = 0;
+      for (const file of wfFiles) {
+        const { data, error } = tryParseJson(join(workflowDir, file));
+        if (error) { fail(`workflows/profiles/${file} — invalid JSON: ${error}`); wfErrors++; continue; }
+
+        const missing = ['workflow_id', 'label', 'lane_id', 'output_mode', 'output_count',
+          'prompt_strategy', 'negative_strategy', 'canon_focus', 'drift_guards', 'runtime_defaults']
+          .filter(f => data[f] === undefined || data[f] === null);
+        if (missing.length > 0) {
+          fail(`workflows/profiles/${file} — missing fields: ${missing.join(', ')}`);
+          wfErrors++;
+          continue;
+        }
+
+        if (data.lane_id && laneIds.size > 0 && !laneIds.has(data.lane_id)) {
+          fail(`workflows/profiles/${file} — lane_id "${data.lane_id}" not found in lanes.json`);
+          wfErrors++;
+        }
+
+        if (data.subject_mode && !VALID_SUBJECT_MODES.includes(data.subject_mode)) {
+          fail(`workflows/profiles/${file} — invalid subject_mode "${data.subject_mode}"`);
+          wfErrors++;
+        }
+
+        if (!VALID_OUTPUT_MODES.includes(data.output_mode)) {
+          fail(`workflows/profiles/${file} — invalid output_mode "${data.output_mode}"`);
+          wfErrors++;
+        }
+
+        const ps = data.prompt_strategy;
+        if (!ps || !Array.isArray(ps.style_prefix) || !ps.structure || !Array.isArray(ps.must_include)) {
+          fail(`workflows/profiles/${file} — prompt_strategy needs style_prefix[], structure, must_include[]`);
+          wfErrors++;
+        }
+
+        const ns = data.negative_strategy;
+        if (!ns || !Array.isArray(ns.must_avoid)) {
+          fail(`workflows/profiles/${file} — negative_strategy needs must_avoid[]`);
+          wfErrors++;
+        }
+
+        if (!data.runtime_defaults?.adapter_target) {
+          fail(`workflows/profiles/${file} — runtime_defaults needs adapter_target`);
+          wfErrors++;
+        }
+      }
+
+      if (wfErrors === 0) {
+        pass(`${wfFiles.length} workflow profiles — all valid`);
+        passes++;
+      } else {
+        failures += wfErrors;
+      }
+    } else {
+      pass('workflows/profiles/ — empty (no workflows yet)');
+      passes++;
+    }
+  }
+
+  // ── 10. Batch mode validation ──
+  const batchModesDir = join(projectDir, 'workflows', 'batch-modes');
+  if (existsSync(batchModesDir)) {
+    console.log('');
+    const bmFiles = readdirSync(batchModesDir).filter(f => f.endsWith('.json'));
+    if (bmFiles.length > 0) {
+      const VALID_BATCH_TYPES = ['expression_sheet', 'environment_board', 'silhouette_pack', 'continuity_variants'];
+      const VALID_SUBJECT_MODES_BM = ['required', 'optional', 'forbidden'];
+      const VALID_LAYOUTS = ['grid', 'moodboard', 'strip', 'freeform'];
+      const wfFiles = existsSync(join(projectDir, 'workflows', 'profiles'))
+        ? readdirSync(join(projectDir, 'workflows', 'profiles')).filter(f => f.endsWith('.json')).map(f => f.replace('.json', ''))
+        : [];
+
+      let bmErrors = 0;
+      for (const file of bmFiles) {
+        const { data, error } = tryParseJson(join(batchModesDir, file));
+        if (error) { fail(`workflows/batch-modes/${file} — invalid JSON: ${error}`); bmErrors++; continue; }
+
+        if (!data.mode_id) { fail(`workflows/batch-modes/${file} — missing mode_id`); bmErrors++; }
+        if (!data.batch_type || !VALID_BATCH_TYPES.includes(data.batch_type)) {
+          fail(`workflows/batch-modes/${file} — invalid batch_type "${data.batch_type}"`);
+          bmErrors++;
+        }
+        if (data.subject_mode && !VALID_SUBJECT_MODES_BM.includes(data.subject_mode)) {
+          fail(`workflows/batch-modes/${file} — invalid subject_mode "${data.subject_mode}"`);
+          bmErrors++;
+        }
+        if (data.base_workflow_id && wfFiles.length > 0 && !wfFiles.includes(data.base_workflow_id)) {
+          fail(`workflows/batch-modes/${file} — base_workflow_id "${data.base_workflow_id}" not found in profiles`);
+          bmErrors++;
+        }
+        if (!Array.isArray(data.variant_plan) || data.variant_plan.length === 0) {
+          fail(`workflows/batch-modes/${file} — variant_plan must be non-empty array`);
+          bmErrors++;
+        } else {
+          const slotIds = data.variant_plan.map(s => s.slot_id);
+          const dupes = slotIds.filter((id, i) => slotIds.indexOf(id) !== i);
+          if (dupes.length > 0) {
+            fail(`workflows/batch-modes/${file} — duplicate slot_ids: ${[...new Set(dupes)].join(', ')}`);
+            bmErrors++;
+          }
+        }
+        if (data.assembly?.layout && !VALID_LAYOUTS.includes(data.assembly.layout)) {
+          fail(`workflows/batch-modes/${file} — invalid assembly.layout "${data.assembly.layout}"`);
+          bmErrors++;
+        }
+      }
+
+      if (bmErrors === 0) {
+        pass(`${bmFiles.length} batch modes — all valid`);
+        passes++;
+      } else {
+        failures += bmErrors;
+      }
+    } else {
+      pass('workflows/batch-modes/ — empty (no batch modes yet)');
+      passes++;
+    }
+  }
+
+  // ── 11. Runtime templates check ──
+  {
+    console.log('');
+    const runtimeDir = join(REPO_ROOT, 'runtime', 'comfyui');
+    if (existsSync(runtimeDir)) {
+      const templateFiles = readdirSync(runtimeDir).filter(f => f.endsWith('.json'));
+      if (templateFiles.length > 0) {
+        let templateErrors = 0;
+        for (const file of templateFiles) {
+          const { data, error } = tryParseJson(join(runtimeDir, file));
+          if (error) { fail(`runtime/comfyui/${file}: invalid JSON — ${error}`); templateErrors++; continue; }
+          if (!data.template_id) { fail(`runtime/comfyui/${file}: missing template_id`); templateErrors++; }
+          if (!data.compatible_modes || !Array.isArray(data.compatible_modes)) {
+            fail(`runtime/comfyui/${file}: missing compatible_modes[]`); templateErrors++;
+          }
+        }
+        if (templateErrors === 0) {
+          pass(`${templateFiles.length} runtime templates — all valid`);
+          passes++;
+        } else {
+          failures += templateErrors;
+        }
+      } else {
+        warn('runtime/comfyui/ — no templates found');
+        warnings++;
+      }
+    } else {
+      warn('runtime/comfyui/ — directory not found');
+      warnings++;
+    }
+  }
+
+  // ── 12. Records sanity check ──
   const recordsDir = join(projectDir, 'records');
   if (existsSync(recordsDir)) {
     console.log('');

package/scripts/init.js

@@ -40,6 +40,13 @@ const PROJECT_DIRS = [
   'training/packages',
   'training/eval-runs',
   'training/implementations',
+  'workflows/profiles',
+  'workflows/batch-modes',
+  'briefs',
+  'runs',
+  'batches',
+  'selections',
+  'inbox/generated',
 ];
 
 function isValidName(name) {
@@ -214,6 +221,21 @@ export async function run(argv = process.argv.slice(2)) {
     console.log(`  \x1b[32m✓\x1b[0m inputs/prompts/example-wave.json`);
   }
 
+  // Copy domain workflow profiles if available
+  if (domainDir) {
+    const domainWorkflowsDir = join(domainDir, 'workflows', 'profiles');
+    if (existsSync(domainWorkflowsDir)) {
+      const wfFiles = (await readdir(domainWorkflowsDir)).filter(f => f.endsWith('.json'));
+      for (const file of wfFiles) {
+        await copyFile(
+          join(domainWorkflowsDir, file),
+          join(projectDir, 'workflows', 'profiles', file)
+        );
+        console.log(`  \x1b[32m✓\x1b[0m workflows/profiles/${file}`);
+      }
+    }
+  }
+
   console.log('');
   console.log(`\x1b[32m✓\x1b[0m Project "${projectName}" initialized`);
   console.log('');

package/scripts/refine.js

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+
+/**
+ * refine.js — Generate a refined next-pass brief from critique.
+ *
+ * Usage:
+ *   sdlab refine --project star-freight --run run_2026-04-15_001 --pick 003.png
+ *   sdlab refine --run run_2026-04-15_001 --pick 003.png --push "stronger faction read" --suppress "extra ornament"
+ *   sdlab refine --run run_2026-04-15_001 --pick 003.png --json
+ */
+
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { parseArgs } from '../lib/args.js';
+import { getProjectRoot, getRunsDir } from '../lib/paths.js';
+import { loadCritique } from '../lib/critique-engine.js';
+import {
+  extractDelta,
+  buildRefinedBrief,
+  saveRefinedBrief,
+  renderRefinedBriefMarkdown,
+} from '../lib/refine-briefs.js';
+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' },
+      run: { type: 'string' },
+      pick: { type: 'string' },
+      preserve: { type: 'string' },
+      push: { type: 'string' },
+      suppress: { type: 'string' },
+      json: { type: 'boolean' },
+    },
+    deprecated: { game: 'project' },
+  });
+
+  if (!flags.run || !flags.pick) {
+    console.log('Usage: sdlab refine --run <id> --pick <filename> [--project <name>]');
+    console.log('');
+    console.log('Options:');
+    console.log('  --run <id>             Run to refine from (required)');
+    console.log('  --pick <filename>      Candidate filename to refine from (required)');
+    console.log('  --preserve <notes>     Comma-separated preserve instructions');
+    console.log('  --push <notes>         Comma-separated push instructions');
+    console.log('  --suppress <notes>     Comma-separated suppress instructions');
+    console.log('  --json                 Output raw JSON');
+    return;
+  }
+
+  const projectName = flags.project;
+  const projectRoot = getProjectRoot(projectName);
+  const runId = flags.run;
+  const pickedFilename = flags.pick;
+
+  console.log(`\x1b[1mstyle-dataset-lab\x1b[0m refine`);
+  console.log(`  Project: ${projectName}`);
+  console.log(`  Run: ${runId}`);
+  console.log(`  Picked: ${pickedFilename}`);
+  console.log('');
+
+  // Load critique
+  const critique = loadCritique(projectRoot, runId);
+
+  // Load parent brief from the run
+  const runDir = join(getRunsDir(projectRoot), runId);
+  const parentBrief = JSON.parse(readFileSync(join(runDir, 'brief.json'), 'utf-8'));
+
+  // Parse CLI delta overrides
+  const cliOverrides = {
+    preserve: flags.preserve ? flags.preserve.split(',').map(s => s.trim()).filter(Boolean) : [],
+    push: flags.push ? flags.push.split(',').map(s => s.trim()).filter(Boolean) : [],
+    suppress: flags.suppress ? flags.suppress.split(',').map(s => s.trim()).filter(Boolean) : [],
+  };
+
+  // Extract delta from critique + overrides
+  const delta = extractDelta(critique, pickedFilename, cliOverrides);
+
+  // Build refined brief
+  const refineDir = join(runDir, 'refine');
+  const refinedBrief = buildRefinedBrief({
+    parentBrief,
+    critique,
+    pickedCandidate: pickedFilename,
+    delta,
+    runId,
+    refineDir,
+  });
+
+  // Save
+  const { jsonPath, mdPath } = await saveRefinedBrief(projectRoot, runId, refinedBrief);
+
+  if (flags.json) {
+    console.log(JSON.stringify(refinedBrief, null, 2));
+  } else {
+    console.log(`Refined brief: ${refinedBrief.brief_id}`);
+    console.log(`Parent: ${refinedBrief.parent_brief_id}`);
+    console.log(`Source: ${runId} → ${pickedFilename}`);
+    console.log('');
+
+    if (delta.preserve.length > 0) {
+      console.log('Preserve:');
+      for (const p of delta.preserve) console.log(`  ✓ ${p}`);
+    }
+    if (delta.push.length > 0) {
+      console.log('Push:');
+      for (const p of delta.push) console.log(`  → ${p}`);
+    }
+    if (delta.suppress.length > 0) {
+      console.log('Suppress:');
+      for (const s of delta.suppress) console.log(`  ✗ ${s}`);
+    }
+
+    console.log('');
+    info(`Saved: runs/${runId}/refine/${refinedBrief.brief_id}.json`);
+    info(`Next: sdlab run generate --brief ${refinedBrief.brief_id} (from refine dir)`);
+  }
+}

package/scripts/reingest-selected.js

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+
+/**
+ * reingest-selected.js — Re-ingest selected outputs as candidate records.
+ *
+ * Usage:
+ *   sdlab reingest selected --selection selection_2026-04-16_001 --project star-freight
+ *   sdlab reingest selected --selection selection_2026-04-16_001 --dry-run
+ */
+
+import { parseArgs } from '../lib/args.js';
+import { getProjectRoot } from '../lib/paths.js';
+import { reingestSelection } from '../lib/reingest-selected.js';
+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' },
+      selection: { type: 'string' },
+      'dry-run': { type: 'boolean' },
+      json: { type: 'boolean' },
+    },
+    deprecated: { game: 'project' },
+  });
+
+  if (!flags.selection) {
+    console.log('Usage: sdlab reingest selected --selection <id> [--project <name>]');
+    console.log('');
+    console.log('Options:');
+    console.log('  --selection <id>   Selection to re-ingest (required)');
+    console.log('  --dry-run          Preview without writing records');
+    console.log('  --json             Output as JSON');
+    return;
+  }
+
+  const projectName = flags.project;
+  const projectRoot = getProjectRoot(projectName);
+  const dryRun = flags['dry-run'] || false;
+
+  console.log(`\x1b[1mstyle-dataset-lab\x1b[0m reingest selected`);
+  console.log(`  Selection: ${flags.selection}`);
+  console.log(`  Project: ${projectName}`);
+  if (dryRun) console.log('  ⚠ DRY RUN');
+  console.log('');
+
+  const { created, skipped } = await reingestSelection({
+    projectRoot,
+    projectId: projectName,
+    selectionId: flags.selection,
+    dryRun,
+  });
+
+  if (flags.json) {
+    console.log(JSON.stringify({ created, skipped }, null, 2));
+    return;
+  }
+
+  if (created.length > 0) {
+    console.log(`  Created ${created.length} candidate record(s):`);
+    for (const id of created) {
+      console.log(`    ✓ ${id}`);
+    }
+  }
+
+  if (skipped.length > 0) {
+    console.log(`  Skipped ${skipped.length} (already exist):`);
+    for (const id of skipped) {
+      console.log(`    ○ ${id}`);
+    }
+  }
+
+  console.log('');
+  if (!dryRun && created.length > 0) {
+    info('Records staged for review. Use sdlab curate to approve/reject.');
+    info(`Images copied to inbox/generated/`);
+  }
+}

package/scripts/reingest.js

@@ -50,6 +50,12 @@ export async function run(argv = process.argv.slice(2)) {
       console.log('    3. Then eligible for future snapshots');
     }
 
+  } else if (subcommand === 'selected') {
+    // Delegate to reingest-selected.js
+    const { run: runSelected } = await import('./reingest-selected.js');
+    await runSelected(args);
+    return;
+
   } else if (subcommand === 'audit') {
     console.log(`\x1b[1msdlab reingest audit\x1b[0m — ${projectName}\n`);
 
@@ -77,7 +83,7 @@ export async function run(argv = process.argv.slice(2)) {
     }
 
   } else {
-    throw new Error(`Unknown subcommand: ${subcommand}. Use: generated, audit`);
+    throw new Error(`Unknown subcommand: ${subcommand}. Use: generated, selected, audit`);
   }
 }
 

package/scripts/run-generate.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+
+/**
+ * run-generate.js — Execute a compiled brief through ComfyUI.
+ *
+ * Usage:
+ *   sdlab run generate --brief brief_2026-04-15_001 --project star-freight
+ *   sdlab run generate --brief brief_2026-04-15_001 --project star-freight --dry-run
+ *   sdlab run generate --brief brief_2026-04-15_001 --project star-freight --seed 42
+ */
+
+import { parseArgs } from '../lib/args.js';
+import { getProjectRoot, getRunsDir } from '../lib/paths.js';
+import { loadCompiledBrief } from '../lib/brief-compiler.js';
+import { executeRun } from '../lib/adapters/comfyui-runner.js';
+import { saveRunSummary, renderRunText } from '../lib/run-summary.js';
+import { info } from '../lib/log.js';
+import { join } from 'node:path';
+
+export async function run(argv = process.argv.slice(2)) {
+  const { flags } = parseArgs(argv, {
+    flags: {
+      project: { type: 'string', default: 'star-freight' },
+      brief: { type: 'string' },
+      seed: { type: 'string' },
+      'dry-run': { type: 'boolean' },
+      json: { type: 'boolean' },
+    },
+    deprecated: { game: 'project' },
+  });
+
+  if (!flags.brief) {
+    console.log('Usage: sdlab run generate --brief <id> [--project <name>]');
+    console.log('');
+    console.log('Options:');
+    console.log('  --brief <id>      Compiled brief ID (required)');
+    console.log('  --seed <n>        Override base seed');
+    console.log('  --dry-run         Prepare run dir without submitting to ComfyUI');
+    console.log('  --json            Output manifest as JSON');
+    return;
+  }
+
+  const projectName = flags.project;
+  const projectRoot = getProjectRoot(projectName);
+
+  console.log(`\x1b[1mstyle-dataset-lab\x1b[0m run generate`);
+  console.log(`  Project: ${projectName}`);
+  console.log(`  Brief: ${flags.brief}`);
+  if (flags['dry-run']) console.log('  ⚠ DRY RUN');
+  console.log('');
+
+  // Load brief
+  const brief = await loadCompiledBrief(projectRoot, flags.brief);
+
+  // Execute
+  const manifest = await executeRun({
+    projectRoot,
+    projectName,
+    brief,
+    baseSeed: flags.seed ? parseInt(flags.seed, 10) : undefined,
+    dryRun: flags['dry-run'] || false,
+  });
+
+  // Save summary
+  const runDir = join(getRunsDir(projectRoot), manifest.run_id);
+  await saveRunSummary(runDir, manifest);
+
+  console.log('');
+  if (flags.json) {
+    console.log(JSON.stringify(manifest, null, 2));
+  } else {
+    console.log(renderRunText(manifest));
+    console.log('');
+    info(`Run saved to: runs/${manifest.run_id}/`);
+  }
+}

package/scripts/run-list.js

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+
+/**
+ * run-list.js — List all runs for a project.
+ *
+ * Usage:
+ *   sdlab run list --project star-freight
+ *   sdlab run list --project star-freight --json
+ */
+
+import { parseArgs } from '../lib/args.js';
+import { getProjectRoot } from '../lib/paths.js';
+import { listRuns } from '../lib/runtime-runs.js';
+
+export async function run(argv = process.argv.slice(2)) {
+  const { flags } = parseArgs(argv, {
+    flags: {
+      project: { type: 'string', default: 'star-freight' },
+      json: { type: 'boolean' },
+    },
+    deprecated: { game: 'project' },
+  });
+
+  const projectName = flags.project;
+  const projectRoot = getProjectRoot(projectName);
+  const runs = listRuns(projectRoot);
+
+  if (flags.json) {
+    console.log(JSON.stringify(runs, null, 2));
+    return;
+  }
+
+  if (runs.length === 0) {
+    console.log('No runs found. Run: sdlab run generate --brief <id>');
+    return;
+  }
+
+  console.log(`\x1b[1mRuns for ${projectName}\x1b[0m (${runs.length})\n`);
+
+  const header = '  ' +
+    'Run ID'.padEnd(26) +
+    'Brief'.padEnd(26) +
+    'Mode'.padEnd(18) +
+    'Count'.padEnd(8) +
+    'Created';
+  console.log(header);
+  console.log('  ' + '─'.repeat(90));
+
+  for (const r of runs) {
+    const line = '  ' +
+      (r.run_id || '').padEnd(26) +
+      (r.brief_id || '').padEnd(26) +
+      (r.adapter_target || '?').padEnd(18) +
+      String(r.output_count ?? '?').padEnd(8) +
+      (r.created_at ? r.created_at.slice(0, 16) : '?');
+    console.log(line);
+  }
+}

package/scripts/run-show.js

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+
+/**
+ * run-show.js — Show details of a completed run.
+ *
+ * Usage:
+ *   sdlab run show run_2026-04-16_001 --project star-freight
+ *   sdlab run show run_2026-04-16_001 --project star-freight --json
+ *   sdlab run show run_2026-04-16_001 --project star-freight --md
+ */
+
+import { parseArgs } from '../lib/args.js';
+import { getProjectRoot } from '../lib/paths.js';
+import { loadRun, listRuns } from '../lib/runtime-runs.js';
+import { renderRunText, renderRunMarkdown } from '../lib/run-summary.js';
+
+export async function run(argv = process.argv.slice(2)) {
+  const { positionals, flags } = parseArgs(argv, {
+    flags: {
+      project: { type: 'string', default: 'star-freight' },
+      json: { type: 'boolean' },
+      md: { type: 'boolean' },
+    },
+    deprecated: { game: 'project' },
+  });
+
+  const runId = positionals[0];
+  const projectName = flags.project;
+  const projectRoot = getProjectRoot(projectName);
+
+  // No run ID → list runs
+  if (!runId) {
+    const runs = listRuns(projectRoot);
+    if (runs.length === 0) {
+      console.log('No runs found. Run: sdlab run generate --brief <id>');
+      return;
+    }
+
+    console.log(`\x1b[1mRuns for ${projectName}\x1b[0m (${runs.length})\n`);
+    console.log('  ID                       Brief                      Mode            Outputs  Adapter');
+    console.log('  ─'.padEnd(100, '─'));
+    for (const r of runs) {
+      const id = (r.run_id || '').padEnd(24);
+      const brief = (r.brief_id || '').padEnd(24);
+      const mode = (r.output_count != null ? `${r.output_count}` : '?').padStart(7);
+      const adapter = r.adapter_target || '?';
+      // output_mode if we have it
+      console.log(`  ${id}  ${brief}  ${mode}  ${adapter}`);
+    }
+    return;
+  }
+
+  // Show single run
+  const manifest = await loadRun(projectRoot, runId);
+
+  if (flags.json) {
+    console.log(JSON.stringify(manifest, null, 2));
+  } else if (flags.md) {
+    console.log(renderRunMarkdown(manifest));
+  } else {
+    console.log(renderRunText(manifest));
+  }
+}