@mcptoolshop/style-dataset-lab 2.3.0 → 3.0.0

package/lib/reingest-selected.js

@@ -0,0 +1,173 @@
+/**
+ * Re-ingest selected outputs as new candidate records.
+ *
+ * Selected outputs re-enter the project as generated candidates
+ * with full provenance. They go through the same review and
+ * canon-binding flow as everything else. No bypass.
+ */
+
+import { writeFile, mkdir, copyFile } from 'node:fs/promises';
+import { join, extname } from 'node:path';
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import { getRunsDir } from './paths.js';
+import { getBatchesDir } from './batch-runs.js';
+import { getSelectionsDir, loadSelection } from './selections.js';
+import { buildGeneratedProvenance } from './generated-provenance.js';
+import { buildBaseRecord } from './records.js';
+import { inputError } from './errors.js';
+
+/**
+ * Re-ingest a selection — creates candidate records from chosen outputs.
+ *
+ * @param {Object} opts
+ * @param {string} opts.projectRoot
+ * @param {string} opts.projectId
+ * @param {string} opts.selectionId
+ * @param {boolean} [opts.dryRun]
+ * @returns {Promise<{created: string[], skipped: string[]}>}
+ */
+export async function reingestSelection({ projectRoot, projectId, selectionId, dryRun }) {
+  const manifest = loadSelection(projectRoot, selectionId);
+
+  if (!manifest.reingest_ready) {
+    throw inputError(
+      'SELECTION_NOT_READY',
+      `Selection "${selectionId}" is not marked reingest_ready`,
+      'Set reingest_ready: true in the selection manifest.',
+    );
+  }
+
+  const selectionDir = join(getSelectionsDir(projectRoot), selectionId);
+  const recordsDir = join(projectRoot, 'records');
+  const inboxDir = join(projectRoot, 'inbox', 'generated');
+
+  if (!dryRun) {
+    await mkdir(recordsDir, { recursive: true });
+    await mkdir(inboxDir, { recursive: true });
+  }
+
+  // Load source manifests for provenance
+  const runsDir = getRunsDir(projectRoot);
+  const runManifestCache = new Map();
+
+  function getRunManifest(runId) {
+    if (runManifestCache.has(runId)) return runManifestCache.get(runId);
+    const mPath = join(runsDir, runId, 'manifest.json');
+    if (!existsSync(mPath)) return null;
+    const m = JSON.parse(readFileSync(mPath, 'utf-8'));
+    runManifestCache.set(runId, m);
+    return m;
+  }
+
+  let batchManifest = null;
+  if (manifest.source_type === 'batch') {
+    const bmPath = join(getBatchesDir(projectRoot), manifest.source_id, 'manifest.json');
+    if (existsSync(bmPath)) {
+      batchManifest = JSON.parse(readFileSync(bmPath, 'utf-8'));
+    }
+  }
+
+  const created = [];
+  const skipped = [];
+  const provenanceLines = [];
+
+  for (const item of manifest.items) {
+    // Determine record ID from selection + item index
+    const idx = String(manifest.items.indexOf(item) + 1).padStart(3, '0');
+    const recordId = `gen_${selectionId}_${idx}`;
+    const recordPath = join(recordsDir, `${recordId}.json`);
+
+    if (existsSync(recordPath)) {
+      skipped.push(recordId);
+      continue;
+    }
+
+    // Resolve the run manifest for this item
+    let runManifest;
+    if (manifest.source_type === 'run') {
+      runManifest = getRunManifest(manifest.source_id);
+    } else if (manifest.source_type === 'batch' && batchManifest) {
+      // Find which run this slot belongs to
+      const slotId = item.slot_or_output.split(':')[0];
+      const slot = batchManifest.slots?.find(s => s.slot_id === slotId);
+      if (slot) {
+        runManifest = getRunManifest(slot.run_id);
+      }
+    }
+
+    if (!runManifest) {
+      // Fallback: minimal provenance
+      runManifest = {
+        run_id: manifest.source_id,
+        brief_id: 'unknown',
+        workflow_template_id: manifest.workflow_id || 'unknown',
+        created_at: manifest.created_at,
+      };
+    }
+
+    // Build provenance
+    const prov = buildGeneratedProvenance({
+      sourceType: manifest.source_type,
+      sourceId: manifest.source_id,
+      runManifest,
+      batchManifest,
+      item,
+      projectRoot,
+    });
+
+    // Image source in selection/chosen/
+    const srcImage = join(selectionDir, 'chosen', item.filename);
+    const ext = extname(item.filename) || '.png';
+    const destImage = `${recordId}${ext}`;
+    const inboxPath = join(inboxDir, destImage);
+    const assetPath = `inbox/generated/${destImage}`;
+
+    // Get file size
+    let fileBytes = 0;
+    if (existsSync(srcImage)) {
+      fileBytes = statSync(srcImage).size;
+    }
+
+    // Build record
+    const record = buildBaseRecord(recordId, assetPath, {
+      width: null,
+      height: null,
+      bytes: fileBytes,
+    }, {
+      source: 'generated',
+      selection_id: selectionId,
+      generation_provenance: prov,
+    });
+
+    record.schema_version = '2.2.0';
+
+    // Tags
+    const recordTags = ['generated', 'selected'];
+    if (manifest.workflow_id) recordTags.push(manifest.workflow_id);
+    if (manifest.subject_id) recordTags.push(manifest.subject_id);
+    if (item.tags?.length) recordTags.push(...item.tags);
+    record.tags = [...new Set(recordTags)];
+
+    if (!dryRun) {
+      // Copy image into inbox
+      if (existsSync(srcImage)) {
+        await copyFile(srcImage, inboxPath);
+      }
+      // Write record
+      await writeFile(recordPath, JSON.stringify(record, null, 2) + '\n');
+    }
+
+    created.push(recordId);
+    provenanceLines.push(JSON.stringify({ record_id: recordId, ...prov }));
+  }
+
+  // Write provenance log
+  if (!dryRun && provenanceLines.length > 0) {
+    await writeFile(
+      join(selectionDir, 'provenance.jsonl'),
+      provenanceLines.join('\n') + '\n',
+    );
+  }
+
+  return { created, skipped };
+}

package/lib/run-summary.js

@@ -0,0 +1,131 @@
+/**
+ * Run summary — render manifest to human-readable summary files.
+ *
+ * Writes summary.md + summary.json to the run directory.
+ * Contact sheet generation is separate (requires image processing).
+ */
+
+import { writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
+/**
+ * Build a summary object from a manifest.
+ */
+export function buildRunSummary(manifest) {
+  const ok = manifest.outputs.filter(o => o.status === 'ok');
+  const failed = manifest.outputs.filter(o => o.status === 'error');
+  const totalElapsed = ok.reduce((sum, o) => sum + (o.elapsed_ms || 0), 0);
+
+  return {
+    run_id: manifest.run_id,
+    brief_id: manifest.brief_id,
+    project_id: manifest.project_id,
+    adapter_target: manifest.adapter_target,
+    output_mode: manifest.output_mode,
+    created_at: manifest.created_at,
+    dry_run: manifest.dry_run,
+    success_count: manifest.success_count,
+    error_count: manifest.error_count,
+    total_outputs: manifest.output_count,
+    total_elapsed_ms: totalElapsed,
+    avg_elapsed_ms: ok.length > 0 ? Math.round(totalElapsed / ok.length) : 0,
+    seed_plan: manifest.seed_plan,
+    checkpoint: manifest.checkpoint,
+  };
+}
+
+/**
+ * Render a manifest to Markdown summary.
+ */
+export function renderRunMarkdown(manifest) {
+  const lines = [];
+  lines.push(`# Run: ${manifest.run_id}`);
+  lines.push('');
+  lines.push(`**Brief:** ${manifest.brief_id}`);
+  lines.push(`**Project:** ${manifest.project_id}`);
+  lines.push(`**Created:** ${manifest.created_at}`);
+  lines.push(`**Adapter:** ${manifest.adapter_target}`);
+  lines.push(`**Mode:** ${manifest.output_mode}`);
+  if (manifest.dry_run) lines.push('**⚠ DRY RUN — no images generated**');
+  lines.push('');
+
+  // Results
+  lines.push('## Results');
+  lines.push('');
+  lines.push(`| # | Seed | Status | File | Time |`);
+  lines.push(`|---|------|--------|------|------|`);
+  for (const out of manifest.outputs) {
+    const file = out.filename || '—';
+    const time = out.elapsed_ms ? `${(out.elapsed_ms / 1000).toFixed(1)}s` : '—';
+    const status = out.status === 'ok' ? '✓' : out.status === 'dry_run' ? '○' : '✗';
+    lines.push(`| ${out.index + 1} | ${out.seed} | ${status} | ${file} | ${time} |`);
+  }
+  lines.push('');
+
+  // Errors
+  if (manifest.errors.length > 0) {
+    lines.push('## Errors');
+    lines.push('');
+    for (const err of manifest.errors) {
+      lines.push(`- **Image ${err.index + 1}** (seed ${err.seed}): ${err.error}`);
+    }
+    lines.push('');
+  }
+
+  // Runtime
+  lines.push('## Runtime');
+  lines.push('');
+  lines.push(`| Parameter | Value |`);
+  lines.push(`|-----------|-------|`);
+  lines.push(`| Checkpoint | ${manifest.checkpoint || '—'} |`);
+  lines.push(`| LoRAs | ${(manifest.loras || []).map(l => l.name).join(', ') || '—'} |`);
+  lines.push(`| ComfyUI | ${manifest.comfy_url || '—'} |`);
+
+  const rp = manifest.runtime_plan || {};
+  lines.push(`| Size | ${rp.width || '?'}×${rp.height || '?'} |`);
+  lines.push(`| Steps | ${rp.steps || '?'} |`);
+  lines.push(`| CFG | ${rp.cfg || '?'} |`);
+  lines.push(`| Sampler | ${rp.sampler || '?'} |`);
+  lines.push(`| Seed mode | ${rp.seed_mode || '?'} |`);
+  lines.push(`| Base seed | ${manifest.seed_plan?.base_seed || '?'} |`);
+  lines.push('');
+
+  return lines.join('\n');
+}
+
+/**
+ * Render a manifest to terminal text.
+ */
+export function renderRunText(manifest) {
+  const ok = manifest.outputs.filter(o => o.status === 'ok' || o.status === 'dry_run');
+  const failed = manifest.outputs.filter(o => o.status === 'error');
+  const lines = [];
+
+  lines.push(`Run: ${manifest.run_id}`);
+  lines.push(`Brief: ${manifest.brief_id}`);
+  lines.push(`Project: ${manifest.project_id}`);
+  lines.push(`Mode: ${manifest.output_mode} (${manifest.adapter_target})`);
+  if (manifest.dry_run) lines.push('⚠ DRY RUN');
+  lines.push(`Results: ${ok.length}/${manifest.output_count} succeeded`);
+  if (failed.length > 0) lines.push(`Errors: ${failed.length}`);
+  lines.push('');
+
+  for (const out of manifest.outputs) {
+    const status = out.status === 'ok' ? '✓' : out.status === 'dry_run' ? '○' : '✗';
+    const time = out.elapsed_ms ? ` (${(out.elapsed_ms / 1000).toFixed(1)}s)` : '';
+    const file = out.filename ? ` → ${out.filename}` : '';
+    const err = out.error ? ` — ${out.error}` : '';
+    lines.push(`  ${status} [${out.index + 1}] seed ${out.seed}${file}${time}${err}`);
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Save summary files into the run directory.
+ */
+export async function saveRunSummary(runDir, manifest) {
+  const summary = buildRunSummary(manifest);
+  await writeFile(join(runDir, 'summary.json'), JSON.stringify(summary, null, 2) + '\n');
+  await writeFile(join(runDir, 'summary.md'), renderRunMarkdown(manifest) + '\n');
+}

package/lib/runtime-runs.js

@@ -0,0 +1,168 @@
+/**
+ * Runtime run management — create, load, list run artifacts.
+ *
+ * A run is a frozen execution artifact: brief + seeds + outputs + manifest.
+ * The run folder IS the review surface — humans open it directly.
+ */
+
+import { readFile, writeFile, mkdir, readdir, copyFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { getRunsDir, getBriefsDir } from './paths.js';
+import { inputError } from './errors.js';
+
+// ─── Run ID generation ───────────────────────────────────────────
+
+/**
+ * Generate a run ID: run_YYYY-MM-DD_NNN
+ */
+export function generateRunId(runsDir) {
+  const today = new Date().toISOString().slice(0, 10);
+  const prefix = `run_${today}_`;
+
+  let maxSeq = 0;
+  if (existsSync(runsDir)) {
+    const existing = readdirSync(runsDir, { 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}`;
+}
+
+// ─── Seed planning ───────────────────────────────────────────────
+
+/**
+ * Build a deterministic seed plan.
+ * @param {Object} opts
+ * @param {'fixed'|'increment'|'random'} opts.seedMode
+ * @param {number} opts.outputCount
+ * @param {number} [opts.baseSeed] — explicit base seed (default: random)
+ * @returns {{ base_seed: number, seeds: number[] }}
+ */
+export function buildSeedPlan({ seedMode, outputCount, baseSeed }) {
+  const base = baseSeed ?? Math.floor(Math.random() * 2_147_483_647);
+  const seeds = [];
+
+  switch (seedMode) {
+    case 'fixed':
+      for (let i = 0; i < outputCount; i++) seeds.push(base);
+      break;
+    case 'increment':
+      for (let i = 0; i < outputCount; i++) seeds.push(base + i);
+      break;
+    case 'random':
+      seeds.push(base);
+      for (let i = 1; i < outputCount; i++) {
+        seeds.push(Math.floor(Math.random() * 2_147_483_647));
+      }
+      break;
+    default:
+      // Default to increment
+      for (let i = 0; i < outputCount; i++) seeds.push(base + i);
+  }
+
+  return { base_seed: base, seeds };
+}
+
+// ─── Run directory setup ─────────────────────────────────────────
+
+/**
+ * Prepare a run directory and copy brief artifacts into it.
+ * @returns {{ runId: string, runDir: string }}
+ */
+export async function prepareRunDir(projectRoot, brief) {
+  const runsDir = getRunsDir(projectRoot);
+  const runId = generateRunId(runsDir);
+  const runDir = join(runsDir, runId);
+
+  await mkdir(join(runDir, 'outputs'), { recursive: true });
+
+  // Copy brief artifacts
+  const briefsDir = getBriefsDir(projectRoot);
+  const briefJsonSrc = join(briefsDir, `${brief.brief_id}.json`);
+  const briefMdSrc = join(briefsDir, `${brief.brief_id}.md`);
+
+  await writeFile(join(runDir, 'brief.json'), JSON.stringify(brief, null, 2) + '\n');
+
+  if (existsSync(briefMdSrc)) {
+    await copyFile(briefMdSrc, join(runDir, 'brief.md'));
+  }
+
+  // Write standalone prompt/negative files for easy inspection
+  await writeFile(join(runDir, 'prompt.txt'), brief.prompt || '');
+  await writeFile(join(runDir, 'negative-prompt.txt'), brief.negative_prompt || '');
+
+  return { runId, runDir };
+}
+
+// ─── Manifest ────────────────────────────────────────────────────
+
+/**
+ * Build and save a run manifest.
+ */
+export async function saveRunManifest(runDir, manifest) {
+  await writeFile(
+    join(runDir, 'manifest.json'),
+    JSON.stringify(manifest, null, 2) + '\n'
+  );
+}
+
+// ─── Load / List ─────────────────────────────────────────────────
+
+/**
+ * Load a run manifest by ID.
+ */
+export async function loadRun(projectRoot, runId) {
+  const runDir = join(getRunsDir(projectRoot), runId);
+  const manifestPath = join(runDir, 'manifest.json');
+
+  if (!existsSync(manifestPath)) {
+    throw inputError(
+      'RUN_NOT_FOUND',
+      `Run "${runId}" not found`,
+      `Check the run ID or run: sdlab run generate --brief <id>`
+    );
+  }
+
+  return JSON.parse(await readFile(manifestPath, 'utf-8'));
+}
+
+/**
+ * List all runs in a project.
+ */
+export function listRuns(projectRoot) {
+  const runsDir = getRunsDir(projectRoot);
+  if (!existsSync(runsDir)) return [];
+
+  const entries = readdirSync(runsDir, { withFileTypes: true })
+    .filter(e => e.isDirectory() && e.name.startsWith('run_'))
+    .sort((a, b) => a.name.localeCompare(b.name));
+
+  const runs = [];
+  for (const entry of entries) {
+    const manifestPath = join(runsDir, entry.name, 'manifest.json');
+    if (!existsSync(manifestPath)) continue;
+
+    try {
+      const manifest = JSON.parse(readFileSync(manifestPath, 'utf-8'));
+      runs.push({
+        run_id: manifest.run_id,
+        brief_id: manifest.brief_id,
+        workflow_template_id: manifest.workflow_template_id,
+        output_count: manifest.output_count,
+        created_at: manifest.created_at,
+        adapter_target: manifest.adapter_target,
+      });
+    } catch {
+      // Skip malformed
+    }
+  }
+
+  return runs;
+}