ima2-gen 1.1.8 → 1.1.9

package/lib/storageMigration.ts

@@ -0,0 +1,284 @@
+import { mkdir, readdir, copyFile, stat, constants } from "node:fs/promises";
+import { dirname, isAbsolute, join, resolve, sep } from "node:path";
+import { homedir } from "node:os";
+
+const PACKAGE_NAME = "ima2-gen";
+const RECOVERY_DOCS_PATH = "docs/RECOVER_OLD_IMAGES.md";
+
+function addStats(a, b) {
+  return {
+    copied: a.copied + b.copied,
+    skippedExisting: a.skippedExisting + b.skippedExisting,
+  };
+}
+
+async function copyMissingTree(srcDir, dstDir) {
+  await mkdir(dstDir, { recursive: true });
+  const entries = await readdir(srcDir, { withFileTypes: true });
+  let stats = { copied: 0, skippedExisting: 0 };
+  for (const entry of entries) {
+    const src = join(srcDir, entry.name);
+    const dst = join(dstDir, entry.name);
+    if (entry.isDirectory()) {
+      stats = addStats(stats, await copyMissingTree(src, dst));
+      continue;
+    }
+    if (!entry.isFile()) continue;
+    try {
+      await copyFile(src, dst, constants.COPYFILE_EXCL);
+      stats.copied += 1;
+    } catch (err: any) {
+      if (err?.code !== "EEXIST") throw err;
+      stats.skippedExisting += 1;
+    }
+  }
+  return stats;
+}
+
+function isSameOrInside(child, parent) {
+  const a = resolve(child);
+  const b = resolve(parent);
+  return a === b || a.startsWith(b + sep);
+}
+
+export async function migrateGeneratedStorage(ctx, options: any = {}) {
+  const targetDir = ctx.config.storage.generatedDir;
+  const candidates = options.legacyDirs || await getLegacyGeneratedCandidates(ctx, options.env);
+  const result = {
+    copied: 0,
+    skippedExisting: 0,
+    sourcesScanned: 0,
+    sourcesSkipped: 0,
+  };
+  try {
+    for (const legacyDir of candidates) {
+      if (isSameOrInside(legacyDir, targetDir) || isSameOrInside(targetDir, legacyDir)) {
+        result.sourcesSkipped += 1;
+        continue;
+      }
+      try {
+        const legacyStat = await stat(legacyDir);
+        if (!legacyStat.isDirectory()) continue;
+        result.sourcesScanned += 1;
+        const copyStats = await copyMissingTree(legacyDir, targetDir);
+        result.copied += copyStats.copied;
+        result.skippedExisting += copyStats.skippedExisting;
+      } catch (err: any) {
+        if (err?.code !== "ENOENT") {
+          console.warn("[storage] generated asset migration source skipped:", legacyDir, err.message);
+        }
+      }
+    }
+    if (result.copied > 0) console.log(`[storage] migrated ${result.copied} generated assets to ${targetDir}`);
+  } catch (err: any) {
+    console.warn("[storage] generated asset migration skipped:", err.message);
+  }
+  return result;
+}
+
+export async function getLegacyGeneratedCandidates(ctx, env = process.env) {
+  const home = env.IMA2_TEST_HOME || homedir();
+  const execPath = env.IMA2_TEST_EXEC_PATH || process.execPath;
+  const argv1 = env.IMA2_TEST_ARGV1 || process.argv[1] || "";
+  const nodePrefix = dirname(dirname(execPath));
+  const prefixes = getGlobalPrefixCandidates({ env, execPath, argv1 });
+  const appData = env.APPDATA || join(home, "AppData", "Roaming");
+  const localAppData = env.LOCALAPPDATA || join(home, "AppData", "Local");
+  const npmCache = env.npm_config_cache || join(home, ".npm");
+  const xdgDataHome = env.XDG_DATA_HOME || join(home, ".local", "share");
+  const pnpmHome = env.PNPM_HOME || "";
+  const nvmHome = env.NVM_HOME || join(appData, "nvm");
+
+  const candidates = [
+    join(ctx.rootDir, "generated"),
+    join(appData, "npm", "node_modules", PACKAGE_NAME, "generated"),
+    join(home, ".npm-global", "lib", "node_modules", PACKAGE_NAME, "generated"),
+    join(home, ".nvm", "versions", "node", process.version, "lib", "node_modules", PACKAGE_NAME, "generated"),
+    join(home, ".volta", "tools", "image", "packages", PACKAGE_NAME, "lib", "node_modules", PACKAGE_NAME, "generated"),
+    join(home, ".fnm", "node-versions", process.version, "installation", "lib", "node_modules", PACKAGE_NAME, "generated"),
+    join(home, ".bun", "install", "global", "node_modules", PACKAGE_NAME, "generated"),
+    join(home, ".config", "yarn", "global", "node_modules", PACKAGE_NAME, "generated"),
+    join(localAppData, "Yarn", "Data", "global", "node_modules", PACKAGE_NAME, "generated"),
+    join(localAppData, "Volta", "tools", "image", "packages", PACKAGE_NAME, "lib", "node_modules", PACKAGE_NAME, "generated"),
+    join(nvmHome, process.version, "node_modules", PACKAGE_NAME, "generated"),
+    join(dirname(execPath), "node_modules", PACKAGE_NAME, "generated"),
+  ];
+
+  for (const prefix of prefixes) {
+    candidates.push(join(prefix, "lib", "node_modules", PACKAGE_NAME, "generated"));
+    candidates.push(join(prefix, "node_modules", PACKAGE_NAME, "generated"));
+  }
+
+  candidates.push(join(nodePrefix, "lib", "node_modules", PACKAGE_NAME, "generated"));
+  candidates.push(
+    ...await expandOneLevelCandidates([
+      [join(home, ".nvm", "versions", "node"), ["*", "lib", "node_modules", PACKAGE_NAME, "generated"]],
+      [join(home, ".fnm", "node-versions"), ["*", "installation", "lib", "node_modules", PACKAGE_NAME, "generated"]],
+      [join(home, ".asdf", "installs", "nodejs"), ["*", "lib", "node_modules", PACKAGE_NAME, "generated"]],
+      [join(home, ".local", "share", "mise", "installs", "node"), ["*", "lib", "node_modules", PACKAGE_NAME, "generated"]],
+      [join(home, "Library", "pnpm", "global"), ["*", "node_modules", PACKAGE_NAME, "generated"]],
+      [join(xdgDataHome, "pnpm", "global"), ["*", "node_modules", PACKAGE_NAME, "generated"]],
+      [join(localAppData, "pnpm", "global"), ["*", "node_modules", PACKAGE_NAME, "generated"]],
+      [pnpmHome ? join(pnpmHome, "global") : "", ["*", "node_modules", PACKAGE_NAME, "generated"]],
+      [join(npmCache, "_npx"), ["*", "node_modules", PACKAGE_NAME, "generated"]],
+      [join(localAppData, "npm-cache", "_npx"), ["*", "node_modules", PACKAGE_NAME, "generated"]],
+      [join(appData, "npm-cache", "_npx"), ["*", "node_modules", PACKAGE_NAME, "generated"]],
+      [nvmHome, ["*", "node_modules", PACKAGE_NAME, "generated"]],
+    ]),
+  );
+  return uniqueResolvedCandidates(candidates);
+}
+
+export async function inspectGeneratedStorage(ctx, options: any = {}) {
+  const env = options.env || process.env;
+  const targetDir = ctx.config.storage.generatedDir;
+  try {
+    const candidates = options.legacyDirs || await getLegacyGeneratedCandidates(ctx, env);
+    const targetFileCount = await countFiles(targetDir);
+    const legacySources = [];
+
+    for (const candidate of candidates) {
+      if (isSameOrInside(candidate, targetDir) || isSameOrInside(targetDir, candidate)) continue;
+      try {
+        const candidateStat = await stat(candidate);
+        if (!candidateStat.isDirectory()) continue;
+        const fileCount = await countFiles(candidate);
+        if (fileCount > 0) legacySources.push({ path: candidate, fileCount });
+      } catch (err: any) {
+        if (err?.code !== "ENOENT") {
+          console.warn("[storage] legacy candidate inspect skipped:", candidate, err.message);
+        }
+      }
+    }
+
+    const legacyFilesFound = legacySources.reduce((sum, source) => sum + source.fileCount, 0);
+    const state =
+      targetFileCount > 0 ? "ok"
+      : legacyFilesFound > 0 ? "recoverable"
+      : "not_found";
+
+    return {
+      ok: true,
+      targetDir,
+      generatedDirLabel: labelPath(targetDir, env),
+      targetExists: await isDirectory(targetDir),
+      targetFileCount,
+      legacyCandidatesScanned: candidates.length,
+      legacySourcesFound: legacySources.length,
+      legacyFilesFound,
+      legacySources,
+      overrides: {
+        generatedDir: Boolean(env.IMA2_GENERATED_DIR),
+        configDir: Boolean(env.IMA2_CONFIG_DIR),
+      },
+      state,
+      messageKind: state === "not_found" ? "apology" : state,
+      recoveryDocsPath: RECOVERY_DOCS_PATH,
+      doctorCommand: "ima2 doctor",
+    };
+  } catch (err: any) {
+    return {
+      ok: false,
+      targetDir,
+      generatedDirLabel: labelPath(targetDir, env),
+      targetExists: false,
+      targetFileCount: 0,
+      legacyCandidatesScanned: 0,
+      legacySourcesFound: 0,
+      legacyFilesFound: 0,
+      legacySources: [],
+      overrides: {
+        generatedDir: Boolean(env.IMA2_GENERATED_DIR),
+        configDir: Boolean(env.IMA2_CONFIG_DIR),
+      },
+      state: "unknown",
+      messageKind: "unknown",
+      recoveryDocsPath: RECOVERY_DOCS_PATH,
+      doctorCommand: "ima2 doctor",
+      error: err?.message || String(err),
+    };
+  }
+}
+
+async function expandOneLevelCandidates(patterns) {
+  const candidates = [];
+  for (const [baseDir, segments] of patterns) {
+    if (!baseDir) continue;
+    candidates.push(...await expandOneLevelPattern(baseDir, segments));
+  }
+  return candidates;
+}
+
+async function expandOneLevelPattern(baseDir, segments) {
+  const wildcardIndex = segments.indexOf("*");
+  if (wildcardIndex < 0) return [join(baseDir, ...segments)];
+
+  const before = segments.slice(0, wildcardIndex);
+  const after = segments.slice(wildcardIndex + 1);
+  const wildcardBase = join(baseDir, ...before);
+  try {
+    const entries = await readdir(wildcardBase, { withFileTypes: true });
+    return entries
+      .filter((entry) => entry.isDirectory())
+      .map((entry) => join(wildcardBase, entry.name, ...after));
+  } catch (err: any) {
+    if (err?.code === "ENOENT") return [];
+    console.warn("[storage] legacy candidate scan skipped:", wildcardBase, err.message);
+    return [];
+  }
+}
+
+async function countFiles(dir) {
+  try {
+    const entries = await readdir(dir, { withFileTypes: true });
+    let count = 0;
+    for (const entry of entries) {
+      if (entry.name === ".trash") continue;
+      const fullPath = join(dir, entry.name);
+      if (entry.isDirectory()) count += await countFiles(fullPath);
+      else if (entry.isFile()) count += 1;
+    }
+    return count;
+  } catch (err: any) {
+    if (err?.code === "ENOENT") return 0;
+    throw err;
+  }
+}
+
+async function isDirectory(dir) {
+  try {
+    return (await stat(dir)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+function uniqueResolvedCandidates(candidates) {
+  return Array.from(new Set(candidates.filter(Boolean).map((p) => resolve(p))));
+}
+
+function labelPath(targetPath, env = process.env) {
+  const home = env.IMA2_TEST_HOME || homedir();
+  const resolved = resolve(targetPath);
+  const resolvedHome = resolve(home);
+  if (resolved === resolvedHome) return "~";
+  if (resolved.startsWith(resolvedHome + sep)) return `~${sep}${resolved.slice(resolvedHome.length + 1)}`;
+  return resolved;
+}
+
+function getGlobalPrefixCandidates({ env, execPath, argv1 }) {
+  const prefixes: Set<string> = new Set();
+  if (env.npm_config_prefix) prefixes.add(env.npm_config_prefix);
+  if (isAbsolute(argv1)) prefixes.add(dirname(dirname(argv1)));
+  prefixes.add(dirname(dirname(execPath)));
+  addHomebrewPrefix(prefixes, execPath);
+  prefixes.add("/opt/homebrew");
+  prefixes.add("/usr/local");
+  return Array.from(prefixes);
+}
+
+function addHomebrewPrefix(prefixes, execPath) {
+  const marker = `${sep}Cellar${sep}node`;
+  const idx = execPath.indexOf(marker);
+  if (idx > 0) prefixes.add(execPath.slice(0, idx));
+}

package/lib/styleSheet.js

@@ -17,10 +17,8 @@
 //
 // The module is pure JS + openai SDK. When no API key is configured it throws
 // STYLE_SHEET_NO_KEY so callers can surface a friendly "connect key" UI.
-
 import { config } from "../config.js";
 const STYLE_SHEET_MODEL = config.styleSheet.model;
-
 const SYSTEM_PROMPT = `You extract a reusable visual style guide from a user
 image prompt (and an optional reference image). Return ONLY a JSON object with
 these keys: palette (array of 3-6 concrete color names), composition (one
@@ -29,100 +27,98 @@ naming technique/material), subject_details (one sentence capturing identity
 cues: face, outfit, pose, distinctive features), negative (array of 0-4 short
 phrases of things to avoid). Keep entries tight — each under 120 characters.
 Do not wrap in markdown. Do not add commentary.`;
-
 function coerceStyleSheet(raw) {
-  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
-  const arr = (v, max = 6) =>
-    Array.isArray(v)
-      ? v
-          .filter((x) => typeof x === "string" && x.trim())
-          .slice(0, max)
-          .map((s) => s.trim())
-      : [];
-  const str = (v) => (typeof v === "string" ? v.trim().slice(0, 400) : "");
-  const sheet = {
-    palette: arr(raw.palette, 6),
-    composition: str(raw.composition),
-    mood: str(raw.mood),
-    medium: str(raw.medium),
-    subject_details: str(raw.subject_details),
-    negative: arr(raw.negative, 4),
-  };
-  const hasContent =
-    sheet.palette.length > 0 ||
-    sheet.negative.length > 0 ||
-    sheet.composition ||
-    sheet.mood ||
-    sheet.medium ||
-    sheet.subject_details;
-  return hasContent ? sheet : null;
+    if (!raw || typeof raw !== "object" || Array.isArray(raw))
+        return null;
+    const arr = (v, max = 6) => Array.isArray(v)
+        ? v
+            .filter((x) => typeof x === "string" && x.trim())
+            .slice(0, max)
+            .map((s) => s.trim())
+        : [];
+    const str = (v) => (typeof v === "string" ? v.trim().slice(0, 400) : "");
+    const sheet = {
+        palette: arr(raw.palette, 6),
+        composition: str(raw.composition),
+        mood: str(raw.mood),
+        medium: str(raw.medium),
+        subject_details: str(raw.subject_details),
+        negative: arr(raw.negative, 4),
+    };
+    const hasContent = sheet.palette.length > 0 ||
+        sheet.negative.length > 0 ||
+        sheet.composition ||
+        sheet.mood ||
+        sheet.medium ||
+        sheet.subject_details;
+    return hasContent ? sheet : null;
 }
-
 export async function extractStyleSheet(openai, { prompt, referenceDataUrl }) {
-  if (!openai) {
-    const err = new Error("No OpenAI client configured for style-sheet extraction");
-    err.code = "STYLE_SHEET_NO_KEY";
-    throw err;
-  }
-  if (!prompt || typeof prompt !== "string" || !prompt.trim()) {
-    const err = new Error("prompt is required");
-    err.code = "STYLE_SHEET_BAD_INPUT";
-    throw err;
-  }
-
-  const userContent = referenceDataUrl
-    ? [
-        { type: "text", text: prompt },
-        { type: "image_url", image_url: { url: referenceDataUrl } },
-      ]
-    : prompt;
-
-  const resp = await openai.chat.completions.create({
-    model: STYLE_SHEET_MODEL,
-    response_format: { type: "json_object" },
-    messages: [
-      { role: "system", content: SYSTEM_PROMPT },
-      { role: "user", content: userContent },
-    ],
-  });
-
-  const raw = resp.choices?.[0]?.message?.content;
-  if (!raw) {
-    const err = new Error("Empty response from style-sheet model");
-    err.code = "STYLE_SHEET_EMPTY";
-    throw err;
-  }
-
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch {
-    const err = new Error("Style-sheet model returned non-JSON");
-    err.code = "STYLE_SHEET_PARSE";
-    throw err;
-  }
-
-  const sheet = coerceStyleSheet(parsed);
-  if (!sheet) {
-    const err = new Error("Style-sheet shape invalid");
-    err.code = "STYLE_SHEET_SHAPE";
-    throw err;
-  }
-  return sheet;
+    if (!openai) {
+        const err = new Error("No OpenAI client configured for style-sheet extraction");
+        err.code = "STYLE_SHEET_NO_KEY";
+        throw err;
+    }
+    if (!prompt || typeof prompt !== "string" || !prompt.trim()) {
+        const err = new Error("prompt is required");
+        err.code = "STYLE_SHEET_BAD_INPUT";
+        throw err;
+    }
+    const userContent = referenceDataUrl
+        ? [
+            { type: "text", text: prompt },
+            { type: "image_url", image_url: { url: referenceDataUrl } },
+        ]
+        : prompt;
+    const resp = await openai.chat.completions.create({
+        model: STYLE_SHEET_MODEL,
+        response_format: { type: "json_object" },
+        messages: [
+            { role: "system", content: SYSTEM_PROMPT },
+            { role: "user", content: userContent },
+        ],
+    });
+    const raw = resp.choices?.[0]?.message?.content;
+    if (!raw) {
+        const err = new Error("Empty response from style-sheet model");
+        err.code = "STYLE_SHEET_EMPTY";
+        throw err;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        const err = new Error("Style-sheet model returned non-JSON");
+        err.code = "STYLE_SHEET_PARSE";
+        throw err;
+    }
+    const sheet = coerceStyleSheet(parsed);
+    if (!sheet) {
+        const err = new Error("Style-sheet shape invalid");
+        err.code = "STYLE_SHEET_SHAPE";
+        throw err;
+    }
+    return sheet;
 }
-
 // Render a style sheet into a prompt preamble that gpt-image-1/2 can consume.
 // Kept short so it doesn't blow the 4K prompt window on long user prompts.
 export function renderStyleSheetPrefix(sheet) {
-  if (!sheet) return "";
-  const parts = [];
-  if (sheet.medium) parts.push(`Medium: ${sheet.medium}.`);
-  if (sheet.palette?.length) parts.push(`Palette: ${sheet.palette.join(", ")}.`);
-  if (sheet.composition) parts.push(`Composition: ${sheet.composition}.`);
-  if (sheet.mood) parts.push(`Mood: ${sheet.mood}.`);
-  if (sheet.subject_details) parts.push(`Subject: ${sheet.subject_details}.`);
-  if (sheet.negative?.length) parts.push(`Avoid: ${sheet.negative.join(", ")}.`);
-  return parts.join(" ");
+    if (!sheet)
+        return "";
+    const parts = [];
+    if (sheet.medium)
+        parts.push(`Medium: ${sheet.medium}.`);
+    if (sheet.palette?.length)
+        parts.push(`Palette: ${sheet.palette.join(", ")}.`);
+    if (sheet.composition)
+        parts.push(`Composition: ${sheet.composition}.`);
+    if (sheet.mood)
+        parts.push(`Mood: ${sheet.mood}.`);
+    if (sheet.subject_details)
+        parts.push(`Subject: ${sheet.subject_details}.`);
+    if (sheet.negative?.length)
+        parts.push(`Avoid: ${sheet.negative.join(", ")}.`);
+    return parts.join(" ");
 }
-
 export { STYLE_SHEET_MODEL, SYSTEM_PROMPT, coerceStyleSheet };

package/lib/styleSheet.ts

@@ -0,0 +1,128 @@
+// Style-sheet extractor (0.10)
+//
+// Uses GPT-5.4 (chat completions) to derive a structured "style guide" from a
+// user prompt and optional reference image. The style guide is stored per
+// session and automatically prepended to subsequent image generations so
+// continuations feel cohesive — closer to ChatGPT 4o's image carry-over.
+//
+// Shape:
+//   {
+//     palette: string[],         // e.g. ["deep navy", "gold leaf"]
+//     composition: string,       // e.g. "centered 3/4 portrait, shallow depth"
+//     mood: string,              // e.g. "melancholic, reverent"
+//     medium: string,            // e.g. "oil painting, glazed layers"
+//     subject_details: string,   // identity/pose/outfit cues for character continuity
+//     negative: string[]         // things to avoid
+//   }
+//
+// The module is pure JS + openai SDK. When no API key is configured it throws
+// STYLE_SHEET_NO_KEY so callers can surface a friendly "connect key" UI.
+
+import { config } from "../config.js";
+const STYLE_SHEET_MODEL = config.styleSheet.model;
+
+const SYSTEM_PROMPT = `You extract a reusable visual style guide from a user
+image prompt (and an optional reference image). Return ONLY a JSON object with
+these keys: palette (array of 3-6 concrete color names), composition (one
+sentence), mood (2-4 comma-separated adjectives), medium (one short phrase
+naming technique/material), subject_details (one sentence capturing identity
+cues: face, outfit, pose, distinctive features), negative (array of 0-4 short
+phrases of things to avoid). Keep entries tight — each under 120 characters.
+Do not wrap in markdown. Do not add commentary.`;
+
+function coerceStyleSheet(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+  const arr = (v, max = 6) =>
+    Array.isArray(v)
+      ? v
+          .filter((x) => typeof x === "string" && x.trim())
+          .slice(0, max)
+          .map((s) => s.trim())
+      : [];
+  const str = (v) => (typeof v === "string" ? v.trim().slice(0, 400) : "");
+  const sheet = {
+    palette: arr(raw.palette, 6),
+    composition: str(raw.composition),
+    mood: str(raw.mood),
+    medium: str(raw.medium),
+    subject_details: str(raw.subject_details),
+    negative: arr(raw.negative, 4),
+  };
+  const hasContent =
+    sheet.palette.length > 0 ||
+    sheet.negative.length > 0 ||
+    sheet.composition ||
+    sheet.mood ||
+    sheet.medium ||
+    sheet.subject_details;
+  return hasContent ? sheet : null;
+}
+
+export async function extractStyleSheet(openai, { prompt, referenceDataUrl }) {
+  if (!openai) {
+    const err: any = new Error("No OpenAI client configured for style-sheet extraction");
+    err.code = "STYLE_SHEET_NO_KEY";
+    throw err;
+  }
+  if (!prompt || typeof prompt !== "string" || !prompt.trim()) {
+    const err: any = new Error("prompt is required");
+    err.code = "STYLE_SHEET_BAD_INPUT";
+    throw err;
+  }
+
+  const userContent = referenceDataUrl
+    ? [
+        { type: "text", text: prompt },
+        { type: "image_url", image_url: { url: referenceDataUrl } },
+      ]
+    : prompt;
+
+  const resp = await openai.chat.completions.create({
+    model: STYLE_SHEET_MODEL,
+    response_format: { type: "json_object" },
+    messages: [
+      { role: "system", content: SYSTEM_PROMPT },
+      { role: "user", content: userContent },
+    ],
+  });
+
+  const raw = resp.choices?.[0]?.message?.content;
+  if (!raw) {
+    const err: any = new Error("Empty response from style-sheet model");
+    err.code = "STYLE_SHEET_EMPTY";
+    throw err;
+  }
+
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    const err: any = new Error("Style-sheet model returned non-JSON");
+    err.code = "STYLE_SHEET_PARSE";
+    throw err;
+  }
+
+  const sheet = coerceStyleSheet(parsed);
+  if (!sheet) {
+    const err: any = new Error("Style-sheet shape invalid");
+    err.code = "STYLE_SHEET_SHAPE";
+    throw err;
+  }
+  return sheet;
+}
+
+// Render a style sheet into a prompt preamble that gpt-image-1/2 can consume.
+// Kept short so it doesn't blow the 4K prompt window on long user prompts.
+export function renderStyleSheetPrefix(sheet) {
+  if (!sheet) return "";
+  const parts = [];
+  if (sheet.medium) parts.push(`Medium: ${sheet.medium}.`);
+  if (sheet.palette?.length) parts.push(`Palette: ${sheet.palette.join(", ")}.`);
+  if (sheet.composition) parts.push(`Composition: ${sheet.composition}.`);
+  if (sheet.mood) parts.push(`Mood: ${sheet.mood}.`);
+  if (sheet.subject_details) parts.push(`Subject: ${sheet.subject_details}.`);
+  if (sheet.negative?.length) parts.push(`Avoid: ${sheet.negative.join(", ")}.`);
+  return parts.join(" ");
+}
+
+export { STYLE_SHEET_MODEL, SYSTEM_PROMPT, coerceStyleSheet };

package/lib/systemTrash.js

@@ -0,0 +1,18 @@
+import { mkdir, rename } from "fs/promises";
+import { basename, join } from "path";
+import trash from "trash";
+export async function moveToSystemTrash(paths) {
+    if (process.env.NODE_ENV === "test" && process.env.IMA2_TEST_SYSTEM_TRASH_DIR) {
+        if (process.env.IMA2_TEST_SYSTEM_TRASH_FAIL === "1") {
+            throw new Error("Simulated system trash failure");
+        }
+        const targetDir = process.env.IMA2_TEST_SYSTEM_TRASH_DIR;
+        await mkdir(targetDir, { recursive: true });
+        const prefix = `${Date.now()}_`;
+        for (const path of paths) {
+            await rename(path, join(targetDir, `${prefix}${basename(path)}`));
+        }
+        return;
+    }
+    await trash(paths, { glob: false });
+}

package/lib/systemTrash.ts

@@ -0,0 +1,20 @@
+import { mkdir, rename } from "fs/promises";
+import { basename, join } from "path";
+import trash from "trash";
+
+export async function moveToSystemTrash(paths: string[]): Promise<void> {
+  if (process.env.NODE_ENV === "test" && process.env.IMA2_TEST_SYSTEM_TRASH_DIR) {
+    if (process.env.IMA2_TEST_SYSTEM_TRASH_FAIL === "1") {
+      throw new Error("Simulated system trash failure");
+    }
+    const targetDir = process.env.IMA2_TEST_SYSTEM_TRASH_DIR;
+    await mkdir(targetDir, { recursive: true });
+    const prefix = `${Date.now()}_`;
+    for (const path of paths) {
+      await rename(path, join(targetDir, `${prefix}${basename(path)}`));
+    }
+    return;
+  }
+
+  await trash(paths, { glob: false });
+}