@inneranimalmedia/agentsam-sdk 2.6.9 → 2.6.11

package/packages/agentsam-merch/schemas/manufacturing-profile.schema.json

@@ -0,0 +1,221 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://schemas.inneranimalmedia.com/agentsam/schemas/agentsam.manufacturing-profile.v1.json",
+  "title": "AgentSam Manufacturing Profile",
+  "type": "object",
+  "required": [
+    "id",
+    "manufacturer",
+    "process"
+  ],
+  "properties": {
+    "schemaVersion": {
+      "const": "agentsam.manufacturing-profile.v1"
+    },
+    "id": {
+      "type": "string",
+      "minLength": 1
+    },
+    "manufacturer": {
+      "type": "string",
+      "minLength": 1
+    },
+    "process": {
+      "type": "string",
+      "minLength": 1
+    },
+    "format": {
+      "type": "string"
+    },
+    "preferredFormat": {
+      "type": "string"
+    },
+    "colorSpace": {
+      "type": [
+        "string",
+        "null"
+      ]
+    },
+    "colorMode": {
+      "type": [
+        "string",
+        "null"
+      ]
+    },
+    "alpha": {
+      "type": "boolean"
+    },
+    "requireAlpha": {
+      "type": "boolean"
+    },
+    "ppi": {
+      "type": [
+        "number",
+        "null"
+      ],
+      "exclusiveMinimum": 0
+    },
+    "maxBytes": {
+      "type": [
+        "number",
+        "null"
+      ],
+      "exclusiveMinimum": 0
+    },
+    "preferredPrintWidthIn": {
+      "type": [
+        "number",
+        "null"
+      ],
+      "exclusiveMinimum": 0
+    },
+    "preferredPrintHeightIn": {
+      "type": [
+        "number",
+        "null"
+      ],
+      "exclusiveMinimum": 0
+    },
+    "allowRaster": {
+      "type": "boolean"
+    },
+    "allowVector": {
+      "type": "boolean"
+    },
+    "allowGradients": {
+      "type": "boolean"
+    },
+    "requireClosedPaths": {
+      "type": "boolean"
+    },
+    "outlineText": {
+      "type": "boolean"
+    },
+    "match": {
+      "type": [
+        "object",
+        "null"
+      ]
+    },
+    "handoff": {
+      "type": [
+        "object",
+        "null"
+      ]
+    },
+    "source": {
+      "type": [
+        "object",
+        "null"
+      ],
+      "properties": {
+        "kind": {
+          "type": "string"
+        },
+        "verified": {
+          "type": "boolean"
+        }
+      },
+      "additionalProperties": true
+    },
+    "resolution": {
+      "type": [
+        "object",
+        "null"
+      ],
+      "properties": {
+        "readyPpi": {
+          "type": [
+            "number",
+            "null"
+          ],
+          "exclusiveMinimum": 0
+        },
+        "minimumPpi": {
+          "type": [
+            "number",
+            "null"
+          ],
+          "exclusiveMinimum": 0
+        }
+      },
+      "additionalProperties": false
+    },
+    "autoNormalize": {
+      "type": [
+        "object",
+        "null"
+      ],
+      "properties": {
+        "trimAlpha": {
+          "type": "boolean"
+        },
+        "colorSpace": {
+          "type": "boolean"
+        },
+        "svgOptimize": {
+          "type": "boolean"
+        },
+        "outlineText": {
+          "type": "boolean"
+        }
+      },
+      "additionalProperties": false
+    },
+    "vectorization": {
+      "type": [
+        "object",
+        "null"
+      ],
+      "properties": {
+        "enabled": {
+          "type": "boolean"
+        },
+        "preferredTracer": {
+          "type": [
+            "string",
+            "null"
+          ]
+        },
+        "maxAspectDrift": {
+          "type": [
+            "number",
+            "null"
+          ],
+          "exclusiveMinimum": 0
+        },
+        "minBoundaryIntegrity": {
+          "type": [
+            "number",
+            "null"
+          ],
+          "minimum": 0,
+          "maximum": 1
+        },
+        "outputFormat": {
+          "type": [
+            "string",
+            "null"
+          ]
+        }
+      },
+      "additionalProperties": true
+    },
+    "requireViewBox": {
+      "type": "boolean"
+    }
+  },
+  "anyOf": [
+    {
+      "required": [
+        "format"
+      ]
+    },
+    {
+      "required": [
+        "preferredFormat"
+      ]
+    }
+  ],
+  "additionalProperties": true
+}

package/packages/agentsam-merch/src/adapters-completeful.js

@@ -0,0 +1,50 @@
+function lower(value) {
+  return value == null ? null : String(value).trim().toLowerCase();
+}
+
+function toInches(value, unit) {
+  const number = Number(value);
+  if (!Number.isFinite(number) || number <= 0) return null;
+  const normalized = String(unit || "IN").trim().toUpperCase();
+  if (normalized === "IN" || normalized === "INCH" || normalized === "INCHES") {
+    return number;
+  }
+  if (normalized === "CM") return number / 2.54;
+  if (normalized === "MM") return number / 25.4;
+  return null;
+}
+
+function physicalTarget(location = {}) {
+  const unit = location.unit || location.file_unit || location.fileUnit || "IN";
+  return {
+    printWidthIn: toInches(location.file_width || location.fileWidth, unit),
+    printHeightIn: toInches(location.file_height || location.fileHeight, unit),
+    providerDpi: Number(location.dpi || 0) || null,
+    providerUnit: String(unit).toUpperCase(),
+  };
+}
+
+/**
+ * Translate Completeful catalog metadata into provider-neutral profile context.
+ * No manufacturing requirement lives in this adapter.
+ */
+export function completefulProfileContext(product = {}, location = {}) {
+  const target = physicalTarget(location);
+  return Object.freeze({
+    manufacturer: "completeful",
+    process: lower(product.print_type || product.printType),
+    productType: lower(product.product_type || product.productType),
+    locationName: lower(location.name),
+    ...target,
+    providerProductId:
+      product.completeful_product_id ||
+      product.catalog_product_id ||
+      product.id ||
+      null,
+    providerLocationId: location.print_location_id || location.id || null,
+  });
+}
+
+export function completefulTarget(location = {}) {
+  return Object.freeze(physicalTarget(location));
+}

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

@@ -0,0 +1,93 @@
+import { readFile, readdir } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  buildMerchPlan,
+  createManufacturingProfileRegistry,
+} from "./index.js";
+
+const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+
+export async function readBundledProfiles(root = packageRoot) {
+  const profiles = [];
+  const base = join(root, "profiles");
+  for (const manufacturer of await readdir(base, { withFileTypes: true })) {
+    if (!manufacturer.isDirectory()) continue;
+    const dir = join(base, manufacturer.name);
+    for (const entry of await readdir(dir, { withFileTypes: true })) {
+      if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
+      profiles.push(JSON.parse(await readFile(join(dir, entry.name), "utf8")));
+    }
+  }
+  return profiles;
+}
+
+export function merchStatusLabel(status) {
+  return {
+    ready: "READY",
+    ready_with_warning: "READY / WARNING",
+    ready_with_transform: "READY / TRANSFORM",
+    needs_variant: "NEEDS VARIANT",
+    prepared_for_digitization: "PREPARED FOR DIGITIZATION",
+    unsupported: "UNSUPPORTED",
+  }[status] || String(status).toUpperCase();
+}
+
+export async function runMerchCli(
+  argv = [],
+  { write = (value) => process.stdout.write(value), profileRoot = packageRoot } = {},
+) {
+  const args = [...argv];
+  if (args[0] === "merch") args.shift();
+  const command = args.shift();
+  const registry = createManufacturingProfileRegistry(
+    await readBundledProfiles(profileRoot),
+  );
+
+  if (command === "profiles") {
+    const rows = registry.list();
+    for (const profile of rows) {
+      write(
+        `${profile.id}\t${profile.manufacturer}\t${profile.process}\t${profile.format}\n`,
+      );
+    }
+    return { command, profiles: rows };
+  }
+
+  if (command !== "build") {
+    const error = new Error(
+      "Usage: agentsam merch build <manifest.json> [--all-compatible]\n" +
+        "       agentsam merch profiles",
+    );
+    error.code = "AGENTSAM_MERCH_USAGE";
+    throw error;
+  }
+
+  const manifestPath = args.find((arg) => !arg.startsWith("--"));
+  if (!manifestPath) {
+    const error = new Error("agentsam merch build requires a manifest JSON path");
+    error.code = "AGENTSAM_MERCH_MANIFEST_REQUIRED";
+    throw error;
+  }
+
+  const manifest = JSON.parse(await readFile(resolve(manifestPath), "utf8"));
+  const plan = buildMerchPlan({ ...manifest, registry });
+
+  write(`Design: ${plan.design.id || plan.design.name || "unnamed"}\n\n`);
+  write("Compatible products\n");
+  for (const target of plan.targets) {
+    const compatibility = target.derivatives?.manufacturing?.compatibility;
+    const notes = [];
+    if (compatibility?.requirementsVerified === false) notes.push("PROFILE UNVERIFIED");
+    if (compatibility?.issues?.[0]?.message) {
+      notes.push(compatibility.issues[0].message);
+    }
+    write(
+      `${String(target.name || target.id).padEnd(30)} ${merchStatusLabel(
+        target.status,
+      )}${notes.length ? ` · ${notes.join(" · ")}` : ""}\n`,
+    );
+  }
+
+  return { command, manifestPath: resolve(manifestPath), plan };
+}

package/packages/agentsam-merch/src/collection-lab.js

@@ -0,0 +1,60 @@
+export const COLLECTION_CANDIDATE_STATE = Object.freeze({
+  CONCEPT: "concept",
+  APPROVED_ART: "approved-art",
+  PRODUCTION_READY: "production-ready",
+  SAMPLE_ORDERED: "sample-ordered",
+  SAMPLE_APPROVED: "sample-approved",
+  PUBLISHED: "published",
+  RETIRED: "retired",
+});
+
+const transitions = Object.freeze({
+  "concept": ["approved-art", "retired"],
+  "approved-art": ["production-ready", "concept", "retired"],
+  "production-ready": ["sample-ordered", "approved-art", "retired"],
+  "sample-ordered": ["sample-approved", "production-ready", "retired"],
+  "sample-approved": ["published", "production-ready", "retired"],
+  "published": ["retired"],
+  "retired": [],
+});
+
+export function canTransitionCollectionCandidate(from, to) {
+  return (transitions[from] || []).includes(to);
+}
+
+export function createCollectionCandidate(input = {}) {
+  if (!input.id) throw new TypeError("candidate id is required");
+  if (!input.designId) throw new TypeError("candidate designId is required");
+
+  return Object.freeze({
+    id: String(input.id),
+    designId: String(input.designId),
+    collectionPath: Object.freeze([...(input.collectionPath || [])]),
+    state: input.state || COLLECTION_CANDIDATE_STATE.CONCEPT,
+    products: Object.freeze([...(input.products || [])]),
+    approvals: Object.freeze({
+      artwork: Boolean(input.approvals?.artwork),
+      wording: Boolean(input.approvals?.wording),
+      palette: Boolean(input.approvals?.palette),
+      visualIdentity: Boolean(input.approvals?.visualIdentity),
+    }),
+    metadata: Object.freeze({ ...(input.metadata || {}) }),
+  });
+}
+
+export function transitionCollectionCandidate(candidate, nextState) {
+  if (!canTransitionCollectionCandidate(candidate.state, nextState)) {
+    throw new Error(`Invalid collection candidate transition: ${candidate.state} -> ${nextState}`);
+  }
+  return Object.freeze({ ...candidate, state: nextState });
+}
+
+export function approvalsComplete(candidate) {
+  const approvals = candidate.approvals || {};
+  return Boolean(
+    approvals.artwork &&
+      approvals.wording &&
+      approvals.palette &&
+      approvals.visualIdentity
+  );
+}