@synap-core/workspace-templates 0.9.3 → 0.10.0

package/src/validate.ts

@@ -152,6 +152,11 @@ export const SYSTEM_PROFILES = new Set([
   "research",
   "knowledge",
   "user_observation",
+  // Generated artifact — a workspace-scoped pod system profile
+  // (`ensure-system-profiles.ts`) written by the `base` report automation. It
+  // was simply missing from this hand-maintained list; the flow's
+  // `create-report` node references it, so referential integrity needs it here.
+  "report",
 ]);
 
 // ── Dependency-vocabulary closure (compose vs require semantics) ─────────────
@@ -274,7 +279,8 @@ export function validateTemplate(
   if (!tpl.meta) add("meta-required", "meta", "Missing required field: meta");
   else {
     for (const f of REQUIRED_META_FIELDS) {
-      if (!tpl.meta[f]) add("meta-field-required", `meta.${f}`, `meta.${f} is required`);
+      if (!tpl.meta[f])
+        add("meta-field-required", `meta.${f}`, `meta.${f} is required`);
     }
   }
   if (!tpl.workspace)
@@ -283,12 +289,33 @@ export function validateTemplate(
     for (const f of REQUIRED_WORKSPACE_FIELDS) {
       if (!tpl.workspace[f])
         add(
-          "workspace-field-required", `workspace.${f}`, `workspace.${f} is required`
+          "workspace-field-required",
+          `workspace.${f}`,
+          `workspace.${f} is required`
         );
     }
   }
-  if (!tpl.profiles || tpl.profiles.length === 0) {
-    add("profiles-required", "profiles", "At least one profile is required");
+  // A template earns validity by declaring a data-schema profile OR by carrying
+  // operational defaults (relation vocabulary / commands / automations). The
+  // `base` template is the latter: pod-wide operational config with no
+  // data-schema profile of its own (its report automation writes the `report`
+  // system profile and reads other system profiles, none declared here). Without
+  // this carve-out a legitimate operational-defaults template fails the gate,
+  // while a data template that forgot its profiles still does (it carries no
+  // operational config either).
+  const carriesOperationalDefaults =
+    (tpl.relationDefs && tpl.relationDefs.length > 0) ||
+    (tpl.commands && tpl.commands.length > 0) ||
+    (tpl.automations && tpl.automations.length > 0);
+  if (
+    (!tpl.profiles || tpl.profiles.length === 0) &&
+    !carriesOperationalDefaults
+  ) {
+    add(
+      "profiles-required",
+      "profiles",
+      "At least one profile is required (or operational defaults: relationDefs / commands / automations)"
+    );
   }
   if (
     tpl.app &&
@@ -434,7 +461,110 @@ export function validateTemplate(
     }
   }
 
-  for (const c of tpl.onboarding?.collect || []) {
+  const onboarding = tpl.onboarding;
+  if (onboarding) {
+    if (typeof onboarding.goal !== "string" || onboarding.goal.trim() === "") {
+      add(
+        "onboarding-goal-empty",
+        "onboarding.goal",
+        "onboarding.goal must be a non-empty string"
+      );
+    }
+    if (
+      typeof onboarding.framing !== "string" ||
+      onboarding.framing.trim() === ""
+    ) {
+      add(
+        "onboarding-framing-empty",
+        "onboarding.framing",
+        "onboarding.framing must be a non-empty string"
+      );
+    }
+    if (!Array.isArray(onboarding.collect) || onboarding.collect.length === 0) {
+      add(
+        "onboarding-collect-empty",
+        "onboarding.collect",
+        "onboarding.collect must contain at least one structured target"
+      );
+    }
+
+    const expertise = onboarding.expertise;
+    for (const [field, values] of [
+      ["starters", expertise?.starters],
+      ["blindSpots", expertise?.blindSpots],
+    ] as const) {
+      if (
+        values !== undefined &&
+        (!Array.isArray(values) ||
+          values.some(
+            (value) => typeof value !== "string" || value.trim() === ""
+          ))
+      ) {
+        add(
+          "onboarding-expertise-invalid",
+          `onboarding.expertise.${field}`,
+          `onboarding.expertise.${field} must contain only non-empty strings`
+        );
+      }
+    }
+    if (
+      expertise?.bar !== undefined &&
+      (typeof expertise.bar !== "string" || expertise.bar.trim() === "")
+    ) {
+      add(
+        "onboarding-expertise-invalid",
+        "onboarding.expertise.bar",
+        "onboarding.expertise.bar must be a non-empty string"
+      );
+    }
+
+    if (
+      onboarding.openingQuestions !== undefined &&
+      (!Array.isArray(onboarding.openingQuestions) ||
+        onboarding.openingQuestions.some(
+          (question) => typeof question !== "string" || question.trim() === ""
+        ))
+    ) {
+      add(
+        "onboarding-opening-questions-invalid",
+        "onboarding.openingQuestions",
+        "onboarding.openingQuestions must contain only non-empty strings"
+      );
+    }
+    if (
+      onboarding.doneWhen !== undefined &&
+      (typeof onboarding.doneWhen !== "string" ||
+        onboarding.doneWhen.trim() === "")
+    ) {
+      add(
+        "onboarding-done-when-invalid",
+        "onboarding.doneWhen",
+        "onboarding.doneWhen must be a non-empty string"
+      );
+    }
+  }
+
+  for (const c of onboarding?.collect || []) {
+    if (typeof c.what !== "string" || c.what.trim() === "") {
+      add(
+        "onboarding-collect-what-empty",
+        `onboarding.collect.${c.profileSlug}.what`,
+        `onboarding.collect target "${c.profileSlug}" must describe what to capture`
+      );
+    }
+    if (
+      c.keyFields !== undefined &&
+      (!Array.isArray(c.keyFields) ||
+        c.keyFields.some(
+          (field) => typeof field !== "string" || field.trim() === ""
+        ))
+    ) {
+      add(
+        "onboarding-collect-key-fields-invalid",
+        `onboarding.collect.${c.profileSlug}.keyFields`,
+        `onboarding.collect target "${c.profileSlug}" keyFields must contain only non-empty strings`
+      );
+    }
     if (!known(c.profileSlug))
       add(
         "onboarding-ref-unknown",
@@ -457,14 +587,17 @@ export function validateTemplate(
   for (const a of tpl.automations || []) {
     const refs: Array<{ where: string; slug: string }> = [];
     collectProfileSlugRefs(
-      a.triggerConfig, `automation "${a.name}".triggerConfig`,
+      a.triggerConfig,
+      `automation "${a.name}".triggerConfig`,
       refs
     );
     collectProfileSlugRefs(a.flow, `automation "${a.name}".flow`, refs);
     for (const r of refs)
       if (!known(r.slug))
         add(
-          "automation-ref-unknown", r.where, `${r.where} references unknown profile "${r.slug}"`
+          "automation-ref-unknown",
+          r.where,
+          `${r.where} references unknown profile "${r.slug}"`
         );
 
     // Node-contract validation. Previously validate.ts checked automations for
@@ -476,9 +609,8 @@ export function validateTemplate(
     // author time); the structural + per-node contract checks always run.
     const flow = a.flow ?? (a as { flowDefinition?: unknown }).flowDefinition;
     if (flow != null) {
-      const { errors: flowErrors
-  } = validateFlowDefinition(flow);
-  for (const fe of flowErrors) {
+      const { errors: flowErrors } = validateFlowDefinition(flow);
+      for (const fe of flowErrors) {
         const loc = fe.nodeId
           ? `automation "${a.name}".flow.node "${fe.nodeId}"`
           : fe.edgeId
@@ -602,11 +734,15 @@ export function validateTemplate(
 
       const doors: Array<
         [
-          string, Array<{ widgetType?: unknown }>, Array<{ viewName?: unknown; kind?: unknown }>,
+          string,
+          Array<{ widgetType?: unknown }>,
+          Array<{ viewName?: unknown; kind?: unknown }>,
         ]
       > = [
         [
-          "tRPC createFromDefinition", definition.bentoLayout ?? [], definition.bentoViewBlocks ?? [],
+          "tRPC createFromDefinition",
+          definition.bentoLayout ?? [],
+          definition.bentoViewBlocks ?? [],
         ],
         ["CP packages/apply", pkg.bentoLayout ?? [], pkg.bentoViewBlocks ?? []],
       ];