@mcptoolshop/style-dataset-lab 2.3.0 → 3.0.0

package/lib/adapters/comfyui-workflows.js

@@ -0,0 +1,163 @@
+/**
+ * ComfyUI workflow adapter — builds executable ComfyUI prompt graphs from briefs.
+ *
+ * The brief carries everything needed: prompt, negative, runtime plan,
+ * plus project defaults for checkpoint/LoRAs. This module translates
+ * that into a ComfyUI node graph.
+ */
+
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { getRuntimeDir } from '../paths.js';
+
+// ─── Template registry ───────────────────────────────────────────
+
+/**
+ * List available workflow templates from runtime/comfyui/.
+ */
+export function listWorkflowTemplates() {
+  const dir = join(getRuntimeDir(), 'comfyui');
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir)
+    .filter(f => f.endsWith('.json'))
+    .map(f => {
+      const data = JSON.parse(readFileSync(join(dir, f), 'utf-8'));
+      return {
+        template_id: data.template_id,
+        label: data.label,
+        compatible_modes: data.compatible_modes || [],
+      };
+    });
+}
+
+/**
+ * Resolve a template for a given output mode.
+ * Returns 'txt2img-standard' for all standard modes.
+ * Throws if no template matches.
+ */
+export function resolveTemplateId(outputMode) {
+  const templates = listWorkflowTemplates();
+  const match = templates.find(t => t.compatible_modes.includes(outputMode));
+  if (match) return match.template_id;
+  // Default fallback for unknown modes
+  return 'txt2img-standard';
+}
+
+// ─── Graph builder ───────────────────────────────────────────────
+
+/**
+ * Build a ComfyUI prompt graph from a compiled brief + project config.
+ *
+ * @param {Object} opts
+ * @param {Object} opts.brief — compiled brief from brief-compiler
+ * @param {Object} opts.projectDefaults — project.json defaults block
+ * @param {number} opts.seed — specific seed for this generation
+ * @returns {{ nodes: Object, saveNodeId: string }}
+ */
+export function buildWorkflowGraph({ brief, projectDefaults, seed }) {
+  const rp = brief.runtime_plan;
+  const defaults = projectDefaults;
+
+  const checkpoint = defaults.checkpoint;
+  const loras = defaults.loras || [];
+  const prompt = brief.prompt;
+  const negativePrompt = brief.negative_prompt;
+  const width = rp.width || defaults.width || 1024;
+  const height = rp.height || defaults.height || 1024;
+  const steps = rp.steps || defaults.steps || 30;
+  const cfg = rp.cfg || defaults.cfg || 6.5;
+  const sampler = rp.sampler || defaults.sampler || 'dpmpp_2m';
+  const scheduler = rp.scheduler || defaults.scheduler || 'karras';
+
+  const nodes = {};
+  let nextId = 1;
+
+  // Checkpoint loader
+  const ckptId = String(nextId++);
+  nodes[ckptId] = {
+    class_type: 'CheckpointLoaderSimple',
+    inputs: { ckpt_name: checkpoint },
+  };
+
+  let modelOut = [ckptId, 0];
+  let clipOut = [ckptId, 1];
+
+  // LoRA loaders (chained)
+  for (const lora of loras) {
+    const loraId = String(nextId++);
+    nodes[loraId] = {
+      class_type: 'LoraLoader',
+      inputs: {
+        model: modelOut,
+        clip: clipOut,
+        lora_name: lora.name,
+        strength_model: lora.weight,
+        strength_clip: lora.clip_weight ?? lora.weight,
+      },
+    };
+    modelOut = [loraId, 0];
+    clipOut = [loraId, 1];
+  }
+
+  // CLIP Text Encode — positive
+  const posId = String(nextId++);
+  nodes[posId] = {
+    class_type: 'CLIPTextEncode',
+    inputs: { text: prompt, clip: clipOut },
+  };
+
+  // CLIP Text Encode — negative
+  const negId = String(nextId++);
+  nodes[negId] = {
+    class_type: 'CLIPTextEncode',
+    inputs: { text: negativePrompt, clip: clipOut },
+  };
+
+  // Empty latent image
+  const latentId = String(nextId++);
+  nodes[latentId] = {
+    class_type: 'EmptyLatentImage',
+    inputs: { width, height, batch_size: 1 },
+  };
+
+  // KSampler
+  const samplerId = String(nextId++);
+  nodes[samplerId] = {
+    class_type: 'KSampler',
+    inputs: {
+      model: modelOut,
+      positive: [posId, 0],
+      negative: [negId, 0],
+      latent_image: [latentId, 0],
+      seed,
+      steps,
+      cfg,
+      sampler_name: sampler,
+      scheduler,
+      denoise: 1.0,
+    },
+  };
+
+  // VAE Decode
+  const vaeId = String(nextId++);
+  nodes[vaeId] = {
+    class_type: 'VAEDecode',
+    inputs: {
+      samples: [samplerId, 0],
+      vae: [ckptId, 2],
+    },
+  };
+
+  // Save Image
+  const saveId = String(nextId++);
+  nodes[saveId] = {
+    class_type: 'SaveImage',
+    inputs: {
+      images: [vaeId, 0],
+      filename_prefix: 'sdl_run',
+    },
+  };
+
+  return { nodes, saveNodeId: saveId };
+}

package/lib/batch-compiler.js

@@ -0,0 +1,118 @@
+/**
+ * Batch compiler — expand a batch mode into multiple coordinated briefs.
+ *
+ * Takes a batch mode + subject/theme inputs and produces one brief per
+ * variant slot, each with controlled prompt/negative/runtime deltas
+ * on top of a base compiled brief from 4A.
+ */
+
+import { compileBrief, saveCompiledBrief } from './brief-compiler.js';
+import { getBatchMode } from './batch-modes.js';
+import { getWorkflowProfile } from './workflow-profiles.js';
+import { inputError } from './errors.js';
+
+/**
+ * Apply slot-level deltas to a base brief.
+ *
+ * @param {Object} baseBrief — compiled brief from brief-compiler
+ * @param {Object} slot — variant_plan slot definition
+ * @returns {Object} — modified brief (new object, base untouched)
+ */
+export function applySlotDelta(baseBrief, slot) {
+  const modified = JSON.parse(JSON.stringify(baseBrief));
+
+  // Prompt additions — append to the end
+  if (slot.prompt_additions?.length > 0) {
+    modified.prompt = `${modified.prompt}, ${slot.prompt_additions.join(', ')}`;
+  }
+
+  // Negative additions — append without duplicating
+  if (slot.negative_additions?.length > 0) {
+    const existingLower = modified.negative_prompt.toLowerCase().split(',').map(s => s.trim());
+    const additions = slot.negative_additions.filter(
+      n => !existingLower.some(e => e.includes(n.toLowerCase()))
+    );
+    if (additions.length > 0) {
+      modified.negative_prompt = `${modified.negative_prompt}, ${additions.join(', ')}`;
+    }
+  }
+
+  // Runtime overrides
+  if (slot.runtime_overrides) {
+    for (const [key, val] of Object.entries(slot.runtime_overrides)) {
+      if (modified.runtime_plan && val !== undefined) {
+        modified.runtime_plan[key] = val;
+      }
+    }
+  }
+
+  // Tag the slot
+  modified._batch_slot_id = slot.slot_id;
+  modified._batch_slot_label = slot.label;
+
+  return modified;
+}
+
+/**
+ * Compile a full batch — one brief per variant slot.
+ *
+ * @param {Object} opts
+ * @param {string} opts.projectRoot — absolute project path
+ * @param {string} opts.projectId — project name
+ * @param {string} opts.modeId — batch mode ID
+ * @param {string} [opts.subjectId] — subject for subject-driven modes
+ * @param {string} [opts.theme] — theme label for environment modes
+ * @param {string} [opts.assetRef] — optional training asset reference
+ * @param {Object} [opts.overrides] — CLI runtime overrides
+ * @returns {Promise<{ mode: Object, baseBrief: Object, slotBriefs: Object[] }>}
+ */
+export async function compileBatch({
+  projectRoot,
+  projectId,
+  modeId,
+  subjectId,
+  theme,
+  assetRef,
+  overrides = {},
+}) {
+  // Load batch mode
+  const mode = getBatchMode(projectRoot, modeId);
+
+  // Enforce subject mode
+  const subjectMode = mode.subject_mode || 'optional';
+  if (subjectMode === 'required' && !subjectId) {
+    throw inputError(
+      'BATCH_SUBJECT_REQUIRED',
+      `Batch mode "${modeId}" requires a subject`,
+      'Add --subject <id> to the command.'
+    );
+  }
+  if (subjectMode === 'forbidden' && subjectId) {
+    throw inputError(
+      'BATCH_SUBJECT_FORBIDDEN',
+      `Batch mode "${modeId}" does not accept a subject`,
+      'Remove --subject from the command.'
+    );
+  }
+
+  // Compile the base brief using the mode's base workflow
+  // Force output_count to 1 — each slot produces one primary candidate
+  const baseBrief = await compileBrief({
+    projectRoot,
+    projectId,
+    workflowId: mode.base_workflow_id,
+    subjectId,
+    assetRef,
+    overrides: { ...overrides, output_count: 1 },
+  });
+
+  // Add theme to prompt if provided
+  if (theme) {
+    baseBrief.prompt = `${baseBrief.prompt}, ${theme}`;
+  }
+
+  // Expand into slot briefs
+  const slotBriefs = mode.variant_plan.map(slot => applySlotDelta(baseBrief, slot));
+
+  return { mode, baseBrief, slotBriefs };
+}

package/lib/batch-modes.js

@@ -0,0 +1,111 @@
+/**
+ * Batch modes — load, validate, list batch production mode definitions.
+ *
+ * A batch mode is a production recipe above the single-brief level.
+ * It defines what deliverable is being made, how many coordinated briefs
+ * are needed, and how results should be assembled.
+ */
+
+import { join } from 'node:path';
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { getProjectRoot } from './paths.js';
+import { inputError } from './errors.js';
+
+const VALID_BATCH_TYPES = [
+  'expression_sheet', 'variant_board', 'moodboard',
+  'silhouette_grid', 'continuity_pack',
+];
+const VALID_LAYOUTS = ['grid', 'moodboard', 'sheet', 'strip'];
+const VALID_SUBJECT_MODES = ['required', 'optional', 'forbidden'];
+
+/**
+ * Return the batch modes directory for a project.
+ */
+export function getBatchModesDir(projectRoot) {
+  return join(projectRoot, 'workflows', 'batch-modes');
+}
+
+/**
+ * List all batch modes for a project.
+ */
+export function listBatchModes(projectRoot) {
+  const dir = getBatchModesDir(projectRoot);
+  if (!existsSync(dir)) return [];
+
+  return readdirSync(dir)
+    .filter(f => f.endsWith('.json'))
+    .map(f => {
+      const data = JSON.parse(readFileSync(join(dir, f), 'utf-8'));
+      return {
+        mode_id: data.mode_id,
+        label: data.label,
+        batch_type: data.batch_type,
+        base_workflow_id: data.base_workflow_id,
+        subject_mode: data.subject_mode || 'optional',
+        slot_count: data.variant_plan?.length || 0,
+      };
+    })
+    .sort((a, b) => a.mode_id.localeCompare(b.mode_id));
+}
+
+/**
+ * Load a batch mode by ID.
+ */
+export function getBatchMode(projectRoot, modeId) {
+  const dir = getBatchModesDir(projectRoot);
+  const filePath = join(dir, `${modeId}.json`);
+
+  if (!existsSync(filePath)) {
+    throw inputError(
+      'BATCH_MODE_NOT_FOUND',
+      `Batch mode "${modeId}" not found`,
+      `Check workflows/batch-modes/ or run: sdlab batch list`
+    );
+  }
+
+  return JSON.parse(readFileSync(filePath, 'utf-8'));
+}
+
+/**
+ * Validate a batch mode definition.
+ * @returns {{ valid: boolean, errors: string[] }}
+ */
+export function validateBatchMode(mode) {
+  const errors = [];
+
+  if (!mode.mode_id) errors.push('missing mode_id');
+  if (!mode.label) errors.push('missing label');
+  if (!mode.base_workflow_id) errors.push('missing base_workflow_id');
+
+  if (!mode.batch_type || !VALID_BATCH_TYPES.includes(mode.batch_type)) {
+    errors.push(`invalid batch_type "${mode.batch_type}" — must be one of: ${VALID_BATCH_TYPES.join(', ')}`);
+  }
+
+  if (mode.subject_mode && !VALID_SUBJECT_MODES.includes(mode.subject_mode)) {
+    errors.push(`invalid subject_mode "${mode.subject_mode}"`);
+  }
+
+  if (!Array.isArray(mode.variant_plan) || mode.variant_plan.length === 0) {
+    errors.push('variant_plan must be a non-empty array');
+  } else {
+    const slotIds = new Set();
+    for (const slot of mode.variant_plan) {
+      if (!slot.slot_id) errors.push('variant slot missing slot_id');
+      if (!slot.label) errors.push('variant slot missing label');
+      if (slot.slot_id && slotIds.has(slot.slot_id)) {
+        errors.push(`duplicate slot_id "${slot.slot_id}"`);
+      }
+      slotIds.add(slot.slot_id);
+    }
+  }
+
+  if (!mode.assembly) {
+    errors.push('missing assembly');
+  } else {
+    if (!mode.assembly.layout || !VALID_LAYOUTS.includes(mode.assembly.layout)) {
+      errors.push(`invalid assembly.layout "${mode.assembly?.layout}" — must be one of: ${VALID_LAYOUTS.join(', ')}`);
+    }
+  }
+
+  return { valid: errors.length === 0, errors };
+}

package/lib/batch-runs.js

@@ -0,0 +1,168 @@
+/**
+ * Batch runs — create batch directories, execute coordinated runs, save manifests.
+ *
+ * A batch groups multiple runs under one artifact:
+ *   batch_YYYY-MM-DD_NNN/
+ *     manifest.json
+ *     summary.json / summary.md
+ *     sheets/
+ *     runs/   (symlinks or copies to project-level runs)
+ *     briefs/ (slot briefs)
+ */
+
+import { writeFile, mkdir, copyFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { getProjectRoot, getRunsDir } from './paths.js';
+import { executeRun } from './adapters/comfyui-runner.js';
+import { saveRunSummary } from './run-summary.js';
+import { log, info, warn } from './log.js';
+import { inputError } from './errors.js';
+
+/**
+ * Return the batches directory for a project.
+ */
+export function getBatchesDir(projectRoot) {
+  return join(projectRoot, 'batches');
+}
+
+/**
+ * Generate batch ID: batch_YYYY-MM-DD_NNN
+ */
+export function generateBatchId(batchesDir) {
+  const today = new Date().toISOString().slice(0, 10);
+  const prefix = `batch_${today}_`;
+
+  let maxSeq = 0;
+  if (existsSync(batchesDir)) {
+    const existing = readdirSync(batchesDir, { withFileTypes: true })
+      .filter(e => e.isDirectory() && e.name.startsWith(prefix));
+    for (const e of existing) {
+      const seqStr = e.name.slice(prefix.length);
+      const seq = parseInt(seqStr, 10);
+      if (!isNaN(seq) && seq > maxSeq) maxSeq = seq;
+    }
+  }
+
+  const seq = String(maxSeq + 1).padStart(3, '0');
+  return `${prefix}${seq}`;
+}
+
+/**
+ * Create a batch directory and prepare its structure.
+ */
+export async function createBatchDir(projectRoot) {
+  const batchesDir = getBatchesDir(projectRoot);
+  const batchId = generateBatchId(batchesDir);
+  const batchDir = join(batchesDir, batchId);
+
+  await mkdir(join(batchDir, 'sheets'), { recursive: true });
+  await mkdir(join(batchDir, 'briefs'), { recursive: true });
+
+  return { batchId, batchDir };
+}
+
+/**
+ * Execute all slot briefs as coordinated runs.
+ *
+ * @param {Object} opts
+ * @param {string} opts.projectRoot
+ * @param {string} opts.projectName
+ * @param {string} opts.batchDir
+ * @param {Object} opts.mode — batch mode definition
+ * @param {Object[]} opts.slotBriefs — one brief per slot
+ * @param {boolean} [opts.dryRun]
+ * @returns {Promise<Object[]>} — array of { slot, brief, manifest }
+ */
+export async function executeBatchRuns({
+  projectRoot,
+  projectName,
+  batchDir,
+  mode,
+  slotBriefs,
+  dryRun = false,
+}) {
+  const results = [];
+
+  for (let i = 0; i < slotBriefs.length; i++) {
+    const slot = mode.variant_plan[i];
+    const brief = slotBriefs[i];
+    const slotLabel = slot.label || slot.slot_id;
+
+    info(`[${i + 1}/${slotBriefs.length}] Slot: ${slotLabel}`);
+
+    // Save brief into batch/briefs/
+    const briefFilename = `${slot.slot_id}.json`;
+    await writeFile(
+      join(batchDir, 'briefs', briefFilename),
+      JSON.stringify(brief, null, 2) + '\n'
+    );
+
+    // Execute the run through the existing 4B pipeline
+    const manifest = await executeRun({
+      projectRoot,
+      projectName,
+      brief,
+      dryRun,
+    });
+
+    // Save run summary
+    const runDir = join(getRunsDir(projectRoot), manifest.run_id);
+    await saveRunSummary(runDir, manifest);
+
+    results.push({
+      slot_id: slot.slot_id,
+      label: slotLabel,
+      brief_id: brief.brief_id,
+      run_id: manifest.run_id,
+      manifest,
+      // Pick the first successful output as the selected one
+      selected_output: manifest.outputs.find(o =>
+        o.status === 'ok' || o.status === 'dry_run'
+      )?.filename || null,
+    });
+  }
+
+  return results;
+}
+
+/**
+ * Save a batch manifest.
+ */
+export async function saveBatchManifest(batchDir, manifest) {
+  await writeFile(
+    join(batchDir, 'manifest.json'),
+    JSON.stringify(manifest, null, 2) + '\n'
+  );
+}
+
+/**
+ * Load a batch manifest by ID.
+ */
+export function loadBatchManifest(projectRoot, batchId) {
+  const batchDir = join(getBatchesDir(projectRoot), batchId);
+  const manifestPath = join(batchDir, 'manifest.json');
+
+  if (!existsSync(manifestPath)) {
+    throw inputError(
+      'BATCH_NOT_FOUND',
+      `Batch "${batchId}" not found`,
+      'Check the batch ID or run: sdlab batch generate --mode <id>'
+    );
+  }
+
+  return JSON.parse(readFileSync(manifestPath, 'utf-8'));
+}
+
+/**
+ * List all batches for a project.
+ */
+export function listBatches(projectRoot) {
+  const batchesDir = getBatchesDir(projectRoot);
+  if (!existsSync(batchesDir)) return [];
+
+  return readdirSync(batchesDir, { withFileTypes: true })
+    .filter(e => e.isDirectory() && e.name.startsWith('batch_'))
+    .sort((a, b) => a.name.localeCompare(b.name))
+    .map(e => e.name);
+}