@mcptoolshop/style-dataset-lab 2.2.1 → 3.0.0

package/lib/adapters/comfyui-runner.js

@@ -0,0 +1,170 @@
+/**
+ * ComfyUI runner — executes a brief through ComfyUI and captures outputs.
+ *
+ * Orchestrates: seed plan → graph build → submit → poll → download → manifest.
+ * Each image in the seed plan becomes one submission to ComfyUI.
+ */
+
+import { writeFile, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { comfyHealth, submitAndWait, downloadImage } from '../comfyui.js';
+import { buildWorkflowGraph, resolveTemplateId } from './comfyui-workflows.js';
+import { buildSeedPlan, prepareRunDir, saveRunManifest } from '../runtime-runs.js';
+import { loadProjectConfig } from '../config.js';
+import { log, info, warn } from '../log.js';
+import { runtimeError } from '../errors.js';
+
+/**
+ * Execute a brief: build graphs, submit to ComfyUI, capture outputs.
+ *
+ * @param {Object} opts
+ * @param {string} opts.projectRoot — absolute project path
+ * @param {string} opts.projectName — project name
+ * @param {Object} opts.brief — compiled brief object
+ * @param {number} [opts.baseSeed] — override base seed
+ * @param {boolean} [opts.dryRun] — if true, prepare run dir but do not submit
+ * @returns {Promise<Object>} — manifest
+ */
+export async function executeRun({ projectRoot, projectName, brief, baseSeed, dryRun = false }) {
+  const config = loadProjectConfig(projectRoot);
+  const defaults = config.meta?.defaults ?? {};
+  const comfyUrl = defaults.comfy_url || process.env.COMFY_URL || 'http://127.0.0.1:8188';
+
+  // Resolve template
+  const outputMode = brief.expected_outputs?.output_mode || 'portrait_set';
+  const templateId = resolveTemplateId(outputMode);
+  const outputCount = brief.expected_outputs?.output_count || brief.runtime_plan?.output_count || 4;
+
+  // Build seed plan
+  const seedMode = brief.runtime_plan?.seed_mode || 'increment';
+  const seedPlan = buildSeedPlan({ seedMode, outputCount, baseSeed });
+
+  // Prepare run directory
+  const { runId, runDir } = await prepareRunDir(projectRoot, brief);
+
+  info(`Run ${runId} — ${outputCount} images, seed mode: ${seedMode}, base: ${seedPlan.base_seed}`);
+  info(`Template: ${templateId}, ComfyUI: ${comfyUrl}`);
+
+  // Health check
+  if (!dryRun) {
+    const healthy = await comfyHealth(comfyUrl);
+    if (!healthy) {
+      throw runtimeError(
+        'COMFYUI_OFFLINE',
+        `ComfyUI not reachable at ${comfyUrl}`,
+        'Start ComfyUI or set COMFY_URL / project defaults.comfy_url'
+      );
+    }
+    info('ComfyUI online');
+  }
+
+  const outputs = [];
+  const errors = [];
+
+  for (let i = 0; i < outputCount; i++) {
+    const seed = seedPlan.seeds[i];
+    const imageIndex = String(i + 1).padStart(3, '0');
+
+    log(`  [${i + 1}/${outputCount}] seed: ${seed}`);
+
+    if (dryRun) {
+      outputs.push({
+        index: i,
+        seed,
+        status: 'dry_run',
+        filename: `${imageIndex}.png`,
+      });
+      continue;
+    }
+
+    const startMs = Date.now();
+
+    try {
+      // Build graph
+      const { nodes } = buildWorkflowGraph({
+        brief,
+        projectDefaults: defaults,
+        seed,
+      });
+
+      // Submit and wait
+      const result = await submitAndWait(nodes, comfyUrl, {
+        clientPrefix: `sdl-run-${runId}`,
+      });
+
+      const elapsed = Date.now() - startMs;
+
+      // Extract output image
+      const nodeOutputs = result.outputs || {};
+      let imageFile = null;
+      let imageSubfolder = '';
+      for (const nodeOut of Object.values(nodeOutputs)) {
+        if (nodeOut.images && nodeOut.images.length > 0) {
+          imageFile = nodeOut.images[0].filename;
+          imageSubfolder = nodeOut.images[0].subfolder || '';
+          break;
+        }
+      }
+
+      if (!imageFile) {
+        warn(`  No output image for seed ${seed}`);
+        outputs.push({ index: i, seed, status: 'no_output', elapsed_ms: elapsed });
+        continue;
+      }
+
+      // Download and save
+      const imgData = await downloadImage(imageFile, imageSubfolder, comfyUrl);
+      const destFilename = `${imageIndex}.png`;
+      await writeFile(join(runDir, 'outputs', destFilename), imgData);
+
+      outputs.push({
+        index: i,
+        seed,
+        status: 'ok',
+        filename: destFilename,
+        bytes: imgData.length,
+        elapsed_ms: elapsed,
+        comfy_filename: imageFile,
+      });
+
+      log(`    ✓ ${destFilename} (${imgData.length} bytes, ${(elapsed / 1000).toFixed(1)}s)`);
+    } catch (err) {
+      const elapsed = Date.now() - startMs;
+      warn(`    ✗ seed ${seed}: ${err.message}`);
+      errors.push({ index: i, seed, error: err.message });
+      outputs.push({
+        index: i,
+        seed,
+        status: 'error',
+        error: err.message,
+        elapsed_ms: elapsed,
+      });
+    }
+  }
+
+  // Build manifest
+  const manifest = {
+    run_id: runId,
+    brief_id: brief.brief_id,
+    project_id: brief.project_id,
+    workflow_template_id: templateId,
+    adapter_target: 'comfyui',
+    output_mode: outputMode,
+    output_count: outputCount,
+    created_at: new Date().toISOString(),
+    seed_plan: seedPlan,
+    comfy_url: comfyUrl,
+    checkpoint: defaults.checkpoint,
+    loras: defaults.loras || [],
+    runtime_plan: brief.runtime_plan,
+    outputs,
+    errors,
+    dry_run: dryRun,
+    success_count: outputs.filter(o => o.status === 'ok' || o.status === 'dry_run').length,
+    error_count: errors.length,
+  };
+
+  await saveRunManifest(runDir, manifest);
+
+  return manifest;
+}

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 };
+}