@mcptoolshop/style-dataset-lab 1.2.0 → 2.0.0

package/scripts/init.js

@@ -0,0 +1,226 @@
+#!/usr/bin/env node
+
+/**
+ * init.js — Scaffold a new project from a domain template.
+ *
+ * Usage:
+ *   sdlab init my-project --domain character-design
+ *   sdlab init my-project                              # uses 'generic' domain
+ *   node scripts/init.js my-project --domain game-art
+ */
+
+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';
+
+const TEMPLATES_DIR = join(REPO_ROOT, 'templates');
+const PROJECTS_DIR = join(REPO_ROOT, 'projects');
+
+const PROJECT_DIRS = [
+  'canon',
+  'records',
+  'comparisons',
+  'inputs/prompts',
+  'inputs/identity-packets',
+  'inputs/references',
+  'inputs/control-guides',
+  'outputs/candidates',
+  'outputs/approved',
+  'outputs/rejected',
+  'outputs/borderline',
+  'outputs/painterly',
+  'outputs/painterly-test',
+  'exports',
+];
+
+function isValidName(name) {
+  return /^[a-z0-9][a-z0-9-]*[a-z0-9]$/.test(name) || /^[a-z0-9]$/.test(name);
+}
+
+async function listDomains() {
+  const domainsDir = join(TEMPLATES_DIR, 'domains');
+  if (!existsSync(domainsDir)) return [];
+  const entries = await readdir(domainsDir, { withFileTypes: true });
+  return entries.filter(e => e.isDirectory()).map(e => e.name);
+}
+
+export async function run(argv = process.argv.slice(2)) {
+  const projectName = argv.find(a => !a.startsWith('--'));
+
+  // Parse --domain
+  let domain = 'generic';
+  const domainIdx = argv.indexOf('--domain');
+  if (domainIdx >= 0 && argv[domainIdx + 1]) {
+    domain = argv[domainIdx + 1];
+  }
+
+  if (!projectName) {
+    const domains = await listDomains();
+    console.log('Usage: sdlab init <project-name> [--domain <domain>]\n');
+    console.log('Available domains:');
+    console.log('  generic              Minimal starter (default)');
+    for (const d of domains) {
+      console.log(`  ${d.padEnd(20)} Domain-specific starter`);
+    }
+    return;
+  }
+
+  if (!isValidName(projectName)) {
+    throw new Error(
+      `Invalid project name "${projectName}".\n` +
+      `Use lowercase letters, numbers, and hyphens (e.g. "my-project").`
+    );
+  }
+
+  const projectDir = join(PROJECTS_DIR, projectName);
+  if (existsSync(projectDir)) {
+    throw new Error(`Project "${projectName}" already exists at ${projectDir}`);
+  }
+
+  // Resolve domain template source
+  let domainDir = null;
+  if (domain !== 'generic') {
+    domainDir = join(TEMPLATES_DIR, 'domains', domain);
+    if (!existsSync(domainDir)) {
+      const domains = await listDomains();
+      throw new Error(
+        `Domain "${domain}" not found.\n` +
+        `Available: generic, ${domains.join(', ')}`
+      );
+    }
+  }
+
+  console.log(`\x1b[1msdlab init\x1b[0m`);
+  console.log(`  Project: ${projectName}`);
+  console.log(`  Domain:  ${domain}`);
+  console.log(`  Path:    ${projectDir}`);
+  console.log('');
+
+  // Create directory structure
+  for (const dir of PROJECT_DIRS) {
+    await mkdir(join(projectDir, dir), { recursive: true });
+  }
+  console.log(`  \x1b[32m✓\x1b[0m Created ${PROJECT_DIRS.length} directories`);
+
+  // Copy config files from domain template or generate generic ones
+  const configFiles = ['project.json', 'constitution.json', 'lanes.json', 'rubric.json', 'terminology.json'];
+
+  if (domainDir) {
+    for (const file of configFiles) {
+      const src = join(domainDir, file);
+      if (existsSync(src)) {
+        let content = await readFile(src, 'utf-8');
+        // Replace template project name
+        if (file === 'project.json') {
+          const parsed = JSON.parse(content);
+          parsed.name = projectName;
+          content = JSON.stringify(parsed, null, 2) + '\n';
+        }
+        await writeFile(join(projectDir, file), content);
+        console.log(`  \x1b[32m✓\x1b[0m ${file} (from ${domain} template)`);
+      }
+    }
+  } else {
+    // Generic starters
+    await writeFile(join(projectDir, 'project.json'), JSON.stringify({
+      name: projectName,
+      display_name: projectName.replace(/-/g, ' ').replace(/\b\w/g, c => c.toUpperCase()),
+      domain: 'generic',
+      version: '0.1.0',
+      defaults: {
+        checkpoint: '',
+        loras: [],
+        width: 1024,
+        height: 1024,
+        steps: 8,
+        cfg: 2.0,
+        sampler: 'dpmpp_sde',
+        scheduler: 'karras',
+        comfy_url: 'http://127.0.0.1:8188'
+      }
+    }, null, 2) + '\n');
+
+    await writeFile(join(projectDir, 'constitution.json'), JSON.stringify({
+      version: '0.1.0',
+      rules: [
+        { id: 'STY-001', category: 'style', desc: 'Consistent visual style across all assets',
+          dims: ['style_consistency'], faction_specific: false,
+          rationale_pass: 'Style consistency achieved (${scorePct}%)',
+          rationale_fail: 'Style inconsistent (${scorePct}%)' },
+        { id: 'CMP-001', category: 'composition', desc: 'Clean composition and framing',
+          dims: ['composition'], faction_specific: false,
+          rationale_pass: 'Composition reads clearly (${scorePct}%)',
+          rationale_fail: 'Composition unclear or cluttered (${scorePct}%)' },
+      ]
+    }, null, 2) + '\n');
+
+    await writeFile(join(projectDir, 'lanes.json'), JSON.stringify({
+      default_lane: 'default',
+      lanes: [
+        { id: 'default', label: 'Default', description: 'All assets', id_patterns: [] }
+      ]
+    }, null, 2) + '\n');
+
+    await writeFile(join(projectDir, 'rubric.json'), JSON.stringify({
+      dimensions: ['style_consistency', 'composition', 'detail', 'originality'],
+      thresholds: {
+        approved: { pass: 0.7, partial: 0.5 },
+        borderline: { pass: 0.7, partial: 0.5 },
+        rejected: { fail_ceiling: 0.4, partial_ceiling: 0.6 }
+      },
+      failure_to_rules: {}
+    }, null, 2) + '\n');
+
+    await writeFile(join(projectDir, 'terminology.json'), JSON.stringify({
+      group_label: 'group',
+      id_detection_order: [],
+      prompt_detection_order: [],
+      groups: {},
+      cross_group_patterns: {},
+      edge_defaults: {},
+      null_faction_patterns: [],
+      id_fallbacks: {},
+      faction_context: {}
+    }, null, 2) + '\n');
+
+    for (const file of configFiles) {
+      console.log(`  \x1b[32m✓\x1b[0m ${file} (generic starter)`);
+    }
+  }
+
+  // Copy canon markdown templates
+  const canonTemplates = ['constitution.md', 'review-rubric.md'];
+  for (const file of canonTemplates) {
+    const src = join(TEMPLATES_DIR, 'canon', file);
+    if (existsSync(src)) {
+      await copyFile(src, join(projectDir, 'canon', file));
+      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)) {
+    await copyFile(examplePack, join(projectDir, 'inputs', 'prompts', 'example-wave.json'));
+    console.log(`  \x1b[32m✓\x1b[0m inputs/prompts/example-wave.json`);
+  }
+
+  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}`);
+}
+
+// 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);
+  });
+}

package/scripts/migrate-records.js

@@ -12,43 +12,33 @@
  * Usage:
  *   node scripts/migrate-records.js --dry-run    # Preview changes
  *   node scripts/migrate-records.js              # Apply changes
+ *   sdlab project migrate --dry-run --project star-freight
  */
 
 import { readdir, readFile, writeFile, access } from 'node:fs/promises';
 import { join, basename } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const __dirname = new URL('.', import.meta.url).pathname.replace(/^\/([A-Z]:)/, '$1');
-const REPO_ROOT = join(__dirname, '..');
-const GAME = process.argv.find((a, i) => process.argv[i - 1] === '--game') || 'star-freight';
-const GAME_ROOT = join(REPO_ROOT, 'games', GAME);
-const RECORDS_DIR = join(GAME_ROOT, 'records');
-const DRY_RUN = process.argv.includes('--dry-run');
+import { getProjectName } from '../lib/args.js';
+import { REPO_ROOT } from '../lib/paths.js';
 
 async function fileExists(p) {
   try { await access(p); return true; } catch { return false; }
 }
 
 function isCuratorDivergent(rec) {
-  // Shape 2/4: has verdict at top level, judgment is null
   return rec.judgment === null && typeof rec.verdict === 'string' && !rec.identity;
 }
 
 function isIdentityRecord(rec) {
-  // Shape 3: has identity block — Grounded pipeline, DO NOT TOUCH
   return rec.identity != null;
 }
 
-async function migrateRecord(filePath) {
+async function migrateRecord(filePath, GAME_ROOT, DRY_RUN) {
   const raw = await readFile(filePath, 'utf-8');
   const rec = JSON.parse(raw);
 
-  // Skip identity records entirely — Grounded pipeline
   if (isIdentityRecord(rec)) return { file: basename(filePath), action: 'skip-identity' };
 
-  // Skip records that are already in standard shape
   if (!isCuratorDivergent(rec)) {
-    // Still check for stale asset_path on standard records
     if (rec.asset_path && rec.asset_path.includes('outputs/candidates/')) {
       const approvedPath = rec.asset_path.replace('outputs/candidates/', 'outputs/approved/');
       const fullApproved = join(GAME_ROOT, approvedPath);
@@ -61,10 +51,8 @@ async function migrateRecord(filePath) {
     return { file: basename(filePath), action: 'skip-standard' };
   }
 
-  // Migrate curator-divergent record
   const changes = [];
 
-  // Build judgment object from top-level fields
   rec.judgment = {
     status: rec.verdict || 'unknown',
     reviewer: rec.curator || 'wave25-script',
@@ -77,7 +65,6 @@ async function migrateRecord(filePath) {
   };
   changes.push(`verdict="${rec.verdict}" → judgment.status`);
 
-  // Remove top-level divergent fields
   delete rec.verdict;
   delete rec.scores;
   delete rec.explanation;
@@ -86,7 +73,6 @@ async function migrateRecord(filePath) {
   delete rec.curator;
   changes.push('removed top-level verdict/scores/explanation/failures/curated_at/curator');
 
-  // Fix asset_path if image moved to approved/
   if (rec.asset_path && rec.asset_path.includes('outputs/candidates/')) {
     const approvedPath = rec.asset_path.replace('outputs/candidates/', 'outputs/approved/');
     const fullApproved = join(GAME_ROOT, approvedPath);
@@ -105,7 +91,12 @@ async function migrateRecord(filePath) {
   return { file: basename(filePath), action: 'migrated', changes };
 }
 
-async function main() {
+export async function run(argv = process.argv.slice(2)) {
+  const projectName = getProjectName(argv);
+  const GAME_ROOT = join(REPO_ROOT, 'projects', projectName);
+  const RECORDS_DIR = join(GAME_ROOT, 'records');
+  const DRY_RUN = argv.includes('--dry-run');
+
   console.log(DRY_RUN ? '=== DRY RUN ===' : '=== APPLYING MIGRATION ===');
 
   const files = (await readdir(RECORDS_DIR)).filter(f => f.endsWith('.json'));
@@ -115,7 +106,7 @@ async function main() {
 
   for (const file of files) {
     try {
-      const result = await migrateRecord(join(RECORDS_DIR, file));
+      const result = await migrateRecord(join(RECORDS_DIR, file), GAME_ROOT, DRY_RUN);
       switch (result.action) {
         case 'skip-standard': results.skipped++; break;
         case 'skip-identity': results.identity++; break;
@@ -144,4 +135,7 @@ async function main() {
   console.log(`Total: ${files.length}`);
 }
 
-main().catch(err => { console.error(err); process.exit(1); });
+// Direct execution guard
+if (process.argv[1] && (process.argv[1].endsWith('migrate-records.js') || process.argv[1].endsWith('migrate-records'))) {
+  run().catch(err => { console.error(err.message || err); process.exit(1); });
+}

package/scripts/painterly-test.js

@@ -3,15 +3,17 @@
 /**
  * painterly-test.js — Test different denoise levels on a single image.
  * Outputs: outputs/painterly-test/<filename>_d<denoise>.png
+ *
+ * Usage:
+ *   node scripts/painterly-test.js
+ *   sdlab painterly:test --project star-freight
  */
 
-import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { writeFile, mkdir } from "node:fs/promises";
 import { join } from "node:path";
-
-const COMFY_URL = process.env.COMFY_URL || "http://127.0.0.1:8188";
-const REPO_ROOT = new URL("..", import.meta.url).pathname.replace(/^\/([A-Z]:)/, "$1");
-const GAME = process.argv.find((a, i) => process.argv[i - 1] === '--game') || 'star-freight';
-const GAME_ROOT = join(REPO_ROOT, 'games', GAME);
+import { getProjectName } from "../lib/args.js";
+import { REPO_ROOT } from "../lib/paths.js";
+import { submitAndWait, downloadImage, uploadImage } from "../lib/comfyui.js";
 
 const PAINTERLY_PROMPT = [
   "oil painting, visible brushstrokes, painterly concept art,",
@@ -68,43 +70,11 @@ function buildWorkflow(imagePath, denoise, loraWeight, seed) {
   return nodes;
 }
 
-async function upload(filePath, filename) {
-  const data = await readFile(filePath);
-  const form = new FormData();
-  form.append("image", new Blob([data], { type: "image/png" }), filename);
-  form.append("overwrite", "true");
-  const res = await fetch(`${COMFY_URL}/upload/image`, { method: "POST", body: form });
-  if (!res.ok) throw new Error(`Upload failed: ${res.status} ${await res.text()}`);
-  return (await res.json()).name;
-}
-
-const MAX_POLL_MS = 600_000; // 10 minutes
-
-async function run(workflow) {
-  const res = await fetch(`${COMFY_URL}/prompt`, {
-    method: "POST", headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ prompt: workflow, client_id: `test-${Date.now()}` }),
-  });
-  if (!res.ok) throw new Error(`ComfyUI submit failed: ${res.status} ${await res.text()}`);
-  const { prompt_id: promptId } = await res.json();
-  const start = Date.now();
-  while (true) {
-    if (Date.now() - start > MAX_POLL_MS) throw new Error(`ComfyUI poll timeout after ${MAX_POLL_MS/1000}s for prompt ${promptId}`);
-    await new Promise(r => setTimeout(r, 1000));
-    const histRes = await fetch(`${COMFY_URL}/history/${promptId}`);
-    if (!histRes.ok) continue;
-    const h = await histRes.json();
-    if (h[promptId]?.status?.completed) return h[promptId];
-  }
-}
-
-async function download(filename, subfolder) {
-  const res = await fetch(`${COMFY_URL}/view?filename=${encodeURIComponent(filename)}&subfolder=${encodeURIComponent(subfolder || "")}&type=output`);
-  if (!res.ok) throw new Error(`Download failed: ${res.status}`);
-  return Buffer.from(await res.arrayBuffer());
-}
+export async function run(argv = process.argv.slice(2)) {
+  const projectName = getProjectName(argv);
+  const GAME_ROOT = join(REPO_ROOT, 'projects', projectName);
+  const COMFY_URL = process.env.COMFY_URL || "http://127.0.0.1:8188";
 
-async function main() {
   const outDir = join(GAME_ROOT, "outputs/painterly-test");
   await mkdir(outDir, { recursive: true });
 
@@ -115,14 +85,14 @@ async function main() {
   ];
 
   const denoiseTests = [0.50, 0.60, 0.70];
-  const loraWeight = 1.0;  // Full LoRA weight for stronger effect
+  const loraWeight = 1.0;
 
   for (const testFile of testFiles) {
     const srcPath = join(GAME_ROOT, testFile);
     const fname = testFile.split("/").pop().replace(".png", "");
 
     console.log(`\nTesting: ${fname}`);
-    const uploaded = await upload(srcPath, `test_${fname}.png`);
+    const uploaded = await uploadImage(srcPath, `test_${fname}.png`, COMFY_URL);
 
     for (const denoise of denoiseTests) {
       const label = `${fname}_d${String(denoise).replace(".", "")}`;
@@ -130,14 +100,14 @@ async function main() {
 
       const t = Date.now();
       const wf = buildWorkflow(uploaded, denoise, loraWeight, 42);
-      const result = await run(wf);
+      const result = await submitAndWait(wf, COMFY_URL, { clientPrefix: 'test' });
 
       let imgFile, imgSub = "";
       for (const o of Object.values(result.outputs || {})) {
         if (o.images?.length) { imgFile = o.images[0].filename; imgSub = o.images[0].subfolder || ""; break; }
       }
 
-      const data = await download(imgFile, imgSub);
+      const data = await downloadImage(imgFile, imgSub, COMFY_URL);
       await writeFile(join(outDir, `${label}.png`), data);
       console.log(`    ✓ ${Date.now() - t}ms`);
     }
@@ -146,4 +116,7 @@ async function main() {
   console.log("\nDone — check outputs/painterly-test/");
 }
 
-main().catch(e => { console.error(e); process.exit(1); });
+// Direct execution guard
+if (process.argv[1] && (process.argv[1].endsWith('painterly-test.js') || process.argv[1].endsWith('painterly-test'))) {
+  run().catch(e => { console.error(e.message || e); process.exit(1); });
+}