@inneranimalmedia/agentsam-sdk 2.6.10 → 2.6.11

package/packages/agentsam-merch/src/node/vector.js

@@ -0,0 +1,239 @@
+import { execFile } from "node:child_process";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
+
+async function loadSharp(injected) {
+  if (injected) return injected;
+  try {
+    const mod = await import("sharp");
+    return mod.default || mod;
+  } catch (error) {
+    const wrapped = new Error(
+      "Raster-to-vector tracing requires the optional 'sharp' runtime dependency.",
+    );
+    wrapped.code = "sharp_unavailable";
+    wrapped.cause = error;
+    throw wrapped;
+  }
+}
+
+async function commandAvailable(command) {
+  try {
+    await execFileAsync(command, ["--version"], { timeout: 2500 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function detectNodeTransformCapabilities() {
+  let rasterNormalizer = false;
+  let svgNormalizer = false;
+  try {
+    await import("sharp");
+    rasterNormalizer = true;
+  } catch {}
+  try {
+    await import("svgo");
+    svgNormalizer = true;
+  } catch {}
+
+  const [potrace, vtracer, inkscape] = await Promise.all([
+    commandAvailable("potrace"),
+    commandAvailable("vtracer"),
+    commandAvailable("inkscape"),
+  ]);
+
+  return Object.freeze({
+    raster_normalizer: rasterNormalizer,
+    format_converter: rasterNormalizer,
+    vector_rasterizer: rasterNormalizer,
+    vector_tracer: potrace || vtracer,
+    svg_normalizer: svgNormalizer,
+    vector_normalizer: svgNormalizer,
+    text_outliner: inkscape,
+    tools: Object.freeze({ potrace, vtracer, inkscape, svgo: svgNormalizer }),
+  });
+}
+
+function occupancyIou(a, b) {
+  const length = Math.min(a.length, b.length);
+  let intersection = 0;
+  let union = 0;
+  for (let i = 0; i < length; i += 1) {
+    const left = a[i] < 128;
+    const right = b[i] < 128;
+    if (left && right) intersection += 1;
+    if (left || right) union += 1;
+  }
+  return union === 0 ? 1 : intersection / union;
+}
+
+async function rasterMask(sharp, input, width, height, threshold) {
+  const { data } = await sharp(input, { failOn: "warning" })
+    .rotate()
+    .resize(width, height, { fit: "fill" })
+    .flatten({ background: "#ffffff" })
+    .grayscale()
+    .threshold(threshold)
+    .raw()
+    .toBuffer({ resolveWithObject: true });
+  return data;
+}
+
+export async function traceRasterToSvg(
+  input,
+  {
+    tracer = "auto",
+    threshold = 190,
+    turdSize = 2,
+    sharp: injectedSharp,
+  } = {},
+) {
+  const sharp = await loadSharp(injectedSharp);
+  const metadata = await sharp(input, { failOn: "warning" }).metadata();
+  const width = metadata.width;
+  const height = metadata.height;
+  if (!width || !height) {
+    const error = new Error("Raster dimensions are required before tracing.");
+    error.code = "raster_dimensions_missing";
+    throw error;
+  }
+
+  const potraceAvailable = await commandAvailable("potrace");
+  const vtracerAvailable = await commandAvailable("vtracer");
+  let selected = tracer;
+  if (selected === "auto") {
+    selected = vtracerAvailable ? "vtracer" : potraceAvailable ? "potrace" : null;
+  }
+  if (selected === "vtracer" && !vtracerAvailable) selected = null;
+  if (selected === "potrace" && !potraceAvailable) selected = null;
+  if (!selected) {
+    const error = new Error("No supported vector tracer is installed (vtracer or potrace).");
+    error.code = "vector_tracer_unavailable";
+    throw error;
+  }
+
+  const dir = await mkdtemp(join(tmpdir(), "agentsam-vectorize-"));
+  try {
+    const inputPath = join(dir, "source.png");
+    const outputPath = join(dir, "output.svg");
+    await writeFile(inputPath, Buffer.from(input));
+
+    if (selected === "vtracer") {
+      await execFileAsync(
+        "vtracer",
+        [
+          "--input",
+          inputPath,
+          "--output",
+          outputPath,
+          "--colormode",
+          "binary",
+        ],
+        { timeout: 30_000, maxBuffer: 1024 * 1024 },
+      );
+    } else {
+      const pgmPath = join(dir, "source.pgm");
+      const { data } = await sharp(input, { failOn: "warning" })
+        .rotate()
+        .flatten({ background: "#ffffff" })
+        .grayscale()
+        .threshold(threshold)
+        .raw()
+        .toBuffer({ resolveWithObject: true });
+      const header = Buffer.from(`P5\n${width} ${height}\n255\n`);
+      await writeFile(pgmPath, Buffer.concat([header, data]));
+      await execFileAsync(
+        "potrace",
+        [
+          pgmPath,
+          "--svg",
+          "--output",
+          outputPath,
+          "--turdsize",
+          String(Math.max(0, Number(turdSize) || 0)),
+        ],
+        { timeout: 30_000, maxBuffer: 1024 * 1024 },
+      );
+    }
+
+    const svg = await readFile(outputPath, "utf8");
+    const sourceMask = await rasterMask(sharp, input, width, height, threshold);
+    const tracedMask = await rasterMask(
+      sharp,
+      Buffer.from(svg),
+      width,
+      height,
+      threshold,
+    );
+    const boundaryIntegrity = occupancyIou(sourceMask, tracedMask);
+
+    return Object.freeze({
+      svg,
+      tracer: selected,
+      descriptor: Object.freeze({
+        format: "svg",
+        mediaKind: "vector",
+        widthPx: width,
+        heightPx: height,
+        contentWidthPx: width,
+        contentHeightPx: height,
+        colorMode: "monochrome",
+        hasGradients: false,
+        hasOpenPaths: false,
+        hasLiveText: false,
+        hasExplicitViewBox: /\bviewBox\s*=/.test(svg),
+        boundaryIntegrity,
+      }),
+      metrics: Object.freeze({
+        boundaryIntegrity,
+        width,
+        height,
+      }),
+    });
+  } finally {
+    await rm(dir, { recursive: true, force: true }).catch(() => {});
+  }
+}
+
+export async function normalizeSvgWithSvgo(
+  svg,
+  { multipass = true } = {},
+) {
+  let optimize;
+  try {
+    ({ optimize } = await import("svgo"));
+  } catch (error) {
+    const wrapped = new Error(
+      "SVG normalization requires the optional 'svgo' runtime dependency.",
+    );
+    wrapped.code = "svgo_unavailable";
+    wrapped.cause = error;
+    throw wrapped;
+  }
+
+  const result = optimize(String(svg), {
+    multipass,
+    plugins: [
+      "preset-default",
+      "removeDimensions",
+      {
+        name: "removeAttrs",
+        params: { attrs: "(data-name|data-layer|xml:space)" },
+      },
+    ],
+  });
+
+  return Object.freeze({
+    svg: result.data,
+    hasExplicitViewBox: /\bviewBox\s*=/.test(result.data),
+    hasLiveText: /<text\b/i.test(result.data),
+    note:
+      "SVGO normalizes SVG structure but does not outline live fonts. Use a font-aware outliner for <text> elements.",
+  });
+}

package/packages/agentsam-merch/src/product-concepts.js

@@ -0,0 +1,118 @@
+function normalizeProvider(value) {
+  return value == null ? null : String(value).trim().toLowerCase();
+}
+
+function normalizeTarget(target = {}, index = 0) {
+  return Object.freeze({
+    ...target,
+    provider: normalizeProvider(target.provider),
+    profileId: target.profileId ? String(target.profileId) : null,
+    priority: Number.isFinite(Number(target.priority))
+      ? Number(target.priority)
+      : index,
+    enabled: target.enabled !== false,
+  });
+}
+
+export function normalizeProductConcept(input = {}) {
+  if (!input.id) throw new TypeError("product concept id is required");
+  const targets = (input.targets || []).map(normalizeTarget);
+  return Object.freeze({
+    ...input,
+    id: String(input.id),
+    label: input.label ? String(input.label) : String(input.id),
+    category: input.category ? String(input.category) : null,
+    targets: Object.freeze(targets),
+  });
+}
+
+export function createProductConceptRegistry(initial = []) {
+  const concepts = new Map();
+
+  function register(input, { replace = false } = {}) {
+    const concept = normalizeProductConcept(input);
+    if (!replace && concepts.has(concept.id)) {
+      throw new Error(`Product concept already registered: ${concept.id}`);
+    }
+    concepts.set(concept.id, concept);
+    return concept;
+  }
+
+  function get(id) {
+    return concepts.get(String(id)) || null;
+  }
+
+  function list() {
+    return [...concepts.values()];
+  }
+
+  for (const concept of initial) register(concept);
+
+  return Object.freeze({ register, get, list });
+}
+
+export function resolveProductConceptTarget(
+  conceptInput,
+  {
+    profileRegistry,
+    availableProviders = [],
+    preferredProvider = null,
+  } = {},
+) {
+  const concept = normalizeProductConcept(conceptInput);
+  if (!profileRegistry?.get) {
+    throw new TypeError("profileRegistry is required");
+  }
+
+  const available = new Set(
+    availableProviders.map(normalizeProvider).filter(Boolean),
+  );
+  const preferred = normalizeProvider(preferredProvider);
+
+  const ranked = concept.targets
+    .filter((target) => target.enabled)
+    .map((target) => {
+      const profile = target.profileId
+        ? profileRegistry.get(target.profileId)
+        : null;
+      const providerAvailable =
+        available.size === 0 || available.has(target.provider);
+      const preferredBoost =
+        preferred && target.provider === preferred ? -1000 : 0;
+      return {
+        target,
+        profile,
+        providerAvailable,
+        rank: target.priority + preferredBoost,
+      };
+    })
+    .filter((entry) => entry.profile && entry.providerAvailable)
+    .sort(
+      (a, b) =>
+        a.rank - b.rank ||
+        String(a.target.provider).localeCompare(String(b.target.provider)),
+    );
+
+  const selected = ranked[0] || null;
+  return Object.freeze({
+    conceptId: concept.id,
+    selected: selected
+      ? Object.freeze({
+          provider: selected.target.provider,
+          profileId: selected.target.profileId,
+          profile: selected.profile,
+          adapter: selected.target.adapter || null,
+          metadata: selected.target.metadata || null,
+        })
+      : null,
+    candidates: Object.freeze(
+      ranked.map((entry) =>
+        Object.freeze({
+          provider: entry.target.provider,
+          profileId: entry.target.profileId,
+          priority: entry.target.priority,
+        }),
+      ),
+    ),
+  });
+}

package/packages/agentsam-merch/src/profile-registry.js

@@ -0,0 +1,104 @@
+import { validateManufacturingProfile } from "./profile.js";
+
+function text(value) {
+  return value == null ? "" : String(value).trim().toLowerCase();
+}
+
+function asArray(value) {
+  if (value == null) return [];
+  return Array.isArray(value) ? value : [value];
+}
+
+function equalsAny(expected, actual) {
+  const target = text(actual);
+  return asArray(expected).some((value) => text(value) === target);
+}
+
+function scoreProfile(profile, context = {}) {
+  const match = profile.match || {};
+  let score = 0;
+
+  if (match.manufacturer != null) {
+    if (!equalsAny(match.manufacturer, context.manufacturer)) return -1;
+    score += 20;
+  }
+  if (match.process != null) {
+    if (!equalsAny(match.process, context.process)) return -1;
+    score += 20;
+  }
+  if (match.locationName != null) {
+    if (!equalsAny(match.locationName, context.locationName)) return -1;
+    score += 8;
+  }
+  if (match.productType != null) {
+    if (!equalsAny(match.productType, context.productType)) return -1;
+    score += 6;
+  }
+
+  const width = Number(context.printWidthIn || 0);
+  const height = Number(context.printHeightIn || 0);
+
+  if (match.minWidthIn != null) {
+    if (!width || width < Number(match.minWidthIn)) return -1;
+    score += 3;
+  }
+  if (match.maxWidthIn != null) {
+    if (!width || width > Number(match.maxWidthIn)) return -1;
+    score += 3;
+  }
+  if (match.minHeightIn != null) {
+    if (!height || height < Number(match.minHeightIn)) return -1;
+    score += 3;
+  }
+  if (match.maxHeightIn != null) {
+    if (!height || height > Number(match.maxHeightIn)) return -1;
+    score += 3;
+  }
+
+  return score;
+}
+
+export function createManufacturingProfileRegistry(initialProfiles = []) {
+  const profiles = new Map();
+
+  function register(input, { replace = false } = {}) {
+    const result = validateManufacturingProfile(input);
+    if (!result.ok) {
+      throw new TypeError(`Invalid manufacturing profile: ${result.errors.join("; ")}`);
+    }
+    if (!replace && profiles.has(result.profile.id)) {
+      throw new Error(`Manufacturing profile already registered: ${result.profile.id}`);
+    }
+    profiles.set(result.profile.id, result.profile);
+    return result.profile;
+  }
+
+  function get(id) {
+    return profiles.get(String(id)) || null;
+  }
+
+  function list(filter = {}) {
+    return [...profiles.values()].filter((profile) => {
+      if (filter.manufacturer && profile.manufacturer !== text(filter.manufacturer)) return false;
+      if (filter.process && profile.process !== text(filter.process)) return false;
+      return true;
+    });
+  }
+
+  function select(context = {}) {
+    return (
+      list()
+        .map((profile) => ({ profile, score: scoreProfile(profile, context) }))
+        .filter((entry) => entry.score >= 0)
+        .sort((a, b) => b.score - a.score || a.profile.id.localeCompare(b.profile.id))[0]?.profile || null
+    );
+  }
+
+  function unregister(id) {
+    return profiles.delete(String(id));
+  }
+
+  for (const profile of initialProfiles) register(profile);
+
+  return Object.freeze({ register, get, list, select, unregister });
+}

package/packages/agentsam-merch/src/profile.js

@@ -0,0 +1,158 @@
+export const MANUFACTURING_PROFILE_SCHEMA = "agentsam.manufacturing-profile.v1";
+
+export const RASTER_FORMATS = Object.freeze(["png", "jpg", "jpeg", "webp", "avif", "gif", "tiff"]);
+export const VECTOR_FORMATS = Object.freeze(["svg", "eps", "ai"]);
+export const DOCUMENT_FORMATS = Object.freeze(["pdf"]);
+
+const supportedFormats = new Set([...RASTER_FORMATS, ...VECTOR_FORMATS, ...DOCUMENT_FORMATS]);
+
+function cleanString(value) {
+  return value == null ? null : String(value).trim();
+}
+
+function positiveNumber(value) {
+  const number = Number(value);
+  return Number.isFinite(number) && number > 0 ? number : null;
+}
+
+function booleanOr(value, fallback = false) {
+  return typeof value === "boolean" ? value : fallback;
+}
+
+export function normalizeFormat(value) {
+  const format = cleanString(value)?.toLowerCase().replace(/^\./, "") || null;
+  return format === "jpeg" ? "jpg" : format;
+}
+
+export function mediaKindForFormat(value) {
+  const format = normalizeFormat(value);
+  if (!format) return "unknown";
+  if (RASTER_FORMATS.includes(format)) return "raster";
+  if (VECTOR_FORMATS.includes(format)) return "vector";
+  if (DOCUMENT_FORMATS.includes(format)) return "document";
+  return "unknown";
+}
+
+export function normalizeResolutionPolicy(input = {}, fallbackPpi = null) {
+  const readyPpi = positiveNumber(input.readyPpi) || positiveNumber(fallbackPpi);
+  const minimumPpi = positiveNumber(input.minimumPpi) || readyPpi;
+  return Object.freeze({
+    readyPpi,
+    minimumPpi,
+  });
+}
+
+export function normalizeManufacturingProfile(input = {}) {
+  const format = normalizeFormat(input.format || input.preferredFormat);
+  const formatKind = mediaKindForFormat(format);
+  const allowRaster =
+    typeof input.allowRaster === "boolean" ? input.allowRaster : formatKind === "raster";
+  const allowVector =
+    typeof input.allowVector === "boolean" ? input.allowVector : formatKind === "vector";
+
+  const ppi = positiveNumber(input.ppi);
+  const resolution = normalizeResolutionPolicy(input.resolution || {}, ppi);
+
+  const autoNormalizeInput =
+    input.autoNormalize && typeof input.autoNormalize === "object" ? input.autoNormalize : {};
+  const autoNormalize = Object.freeze({
+    trimAlpha: booleanOr(autoNormalizeInput.trimAlpha, false),
+    colorSpace: booleanOr(autoNormalizeInput.colorSpace, false),
+    svgOptimize: booleanOr(autoNormalizeInput.svgOptimize, false),
+    outlineText: booleanOr(autoNormalizeInput.outlineText, false),
+  });
+
+  const vectorizationInput =
+    input.vectorization && typeof input.vectorization === "object" ? input.vectorization : {};
+  const vectorization = Object.freeze({
+    enabled: booleanOr(vectorizationInput.enabled, false),
+    preferredTracer: cleanString(vectorizationInput.preferredTracer)?.toLowerCase() || null,
+    maxAspectDrift: positiveNumber(vectorizationInput.maxAspectDrift) ?? 0.02,
+    minBoundaryIntegrity:
+      Number.isFinite(Number(vectorizationInput.minBoundaryIntegrity))
+        ? Math.max(0, Math.min(1, Number(vectorizationInput.minBoundaryIntegrity)))
+        : 0.98,
+    outputFormat: normalizeFormat(vectorizationInput.outputFormat || "svg"),
+  });
+
+  return Object.freeze({
+    ...input,
+    schemaVersion: cleanString(input.schemaVersion) || MANUFACTURING_PROFILE_SCHEMA,
+    id: cleanString(input.id),
+    manufacturer: cleanString(input.manufacturer)?.toLowerCase() || null,
+    process: cleanString(input.process)?.toLowerCase() || null,
+    format,
+    preferredFormat: format,
+    colorSpace: cleanString(input.colorSpace)?.toLowerCase() || null,
+    colorMode: cleanString(input.colorMode)?.toLowerCase() || null,
+    ppi: resolution.readyPpi || ppi,
+    resolution,
+    maxBytes: positiveNumber(input.maxBytes),
+    preferredPrintWidthIn: positiveNumber(input.preferredPrintWidthIn),
+    preferredPrintHeightIn: positiveNumber(input.preferredPrintHeightIn),
+    allowRaster,
+    allowVector,
+    allowGradients: input.allowGradients !== false,
+    requireClosedPaths: input.requireClosedPaths === true,
+    requireViewBox: input.requireViewBox === true,
+    outlineText: input.outlineText === true,
+    requireAlpha: input.requireAlpha === true,
+    alpha: input.alpha === true,
+    autoNormalize,
+    vectorization,
+    handoff:
+      input.handoff && typeof input.handoff === "object"
+        ? Object.freeze({ ...input.handoff })
+        : null,
+    match:
+      input.match && typeof input.match === "object"
+        ? Object.freeze({ ...input.match })
+        : null,
+    source:
+      input.source && typeof input.source === "object"
+        ? Object.freeze({ ...input.source })
+        : null,
+  });
+}
+
+export function validateManufacturingProfile(input) {
+  const profile = normalizeManufacturingProfile(input);
+  const errors = [];
+
+  if (!profile.id) errors.push("id is required");
+  if (!profile.manufacturer) errors.push("manufacturer is required");
+  if (!profile.process) errors.push("process is required");
+  if (!profile.format) errors.push("format or preferredFormat is required");
+  if (profile.format && !supportedFormats.has(profile.format)) {
+    errors.push(`unsupported format: ${profile.format}`);
+  }
+  if (!profile.allowRaster && !profile.allowVector && profile.format !== "pdf") {
+    errors.push("profile must allow raster, vector, or a documented handoff format");
+  }
+  if (profile.ppi != null && profile.ppi < 36) {
+    errors.push("ppi is implausibly low; use null for resolution-independent processes");
+  }
+  if (
+    profile.resolution.readyPpi != null &&
+    profile.resolution.minimumPpi != null &&
+    profile.resolution.minimumPpi > profile.resolution.readyPpi
+  ) {
+    errors.push("resolution.minimumPpi cannot exceed resolution.readyPpi");
+  }
+  if (profile.vectorization.enabled && !profile.allowVector) {
+    errors.push("vectorization.enabled requires allowVector=true");
+  }
+  if (
+    profile.vectorization.enabled &&
+    profile.vectorization.outputFormat &&
+    mediaKindForFormat(profile.vectorization.outputFormat) !== "vector"
+  ) {
+    errors.push("vectorization.outputFormat must be a vector format");
+  }
+
+  return Object.freeze({
+    ok: errors.length === 0,
+    errors: Object.freeze(errors),
+    profile,
+  });
+}