@synap-core/workspace-templates 0.9.3 → 0.10.0

package/src/base.template.test.ts

@@ -0,0 +1,160 @@
+/**
+ * Contract + fidelity tests for the `base` template (Wave 2+3 of
+ * REPORT-AUTOMATION-ONE-DOOR-PLAN).
+ *
+ * `base` carries the pod-wide operational defaults that three hardcoded seeders
+ * used to inject: the report automation, the default relation vocabulary, and
+ * the default command pack. These tests are the guardrail that lets those
+ * seeders be deleted (Wave 4) without silently changing what every workspace
+ * gets.
+ *
+ * FIDELITY MECHANISM. The report prompts are the product — a single altered
+ * character is a regression. Importing `REPORT_AUTOMATION_FLOW` from
+ * `@synap/database` into this frontend package would be an upward layering
+ * violation, so instead the byte-for-byte guardrail is a COMMITTED, GENERATED
+ * fixture (`__fixtures__/report-automation-flow.json`) snapshotted from the
+ * backend const at authoring time, never hand-typed. The chain the test proves:
+ *     compiled base flow  ===  fixture  (=== REPORT_AUTOMATION_FLOW at capture).
+ * Same for the 23-ish relation defs via `__fixtures__/default-relation-defs.json`.
+ */
+
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+import { describe, expect, it } from "vitest";
+import { getWorkspaceTemplate } from "./templates.js";
+import { toWorkspaceDefinition, toPackageDefinition } from "./define.js";
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const readFixture = (name: string) =>
+  JSON.parse(readFileSync(join(HERE, "__fixtures__", name), "utf-8"));
+
+const base = (() => {
+  const resolved = getWorkspaceTemplate("base");
+  if (!resolved) throw new Error("base template is not registered");
+  return resolved;
+})();
+
+describe("base template — identity", () => {
+  it("is a pod-visible core-domain template", () => {
+    expect(base.meta.slug).toBe("base");
+    expect(base.meta.domain).toBe("core");
+    expect(base.meta.isPublic).toBe(true);
+    expect(base.workspace.visibility).toBe("pod_visible");
+  });
+});
+
+describe("Task A — report automation, byte-faithful", () => {
+  const automation = base.automations?.[0];
+
+  it("carries exactly one manual, active 'Generate report' automation", () => {
+    expect(base.automations).toHaveLength(1);
+    expect(automation?.name).toBe("Generate report");
+    expect(automation?.triggerType).toBe("manual");
+    expect(automation?.status).toBe("active");
+    expect(automation?.description).toMatch(/Gather this workspace's state/);
+  });
+
+  it("flow BYTE-MATCHES the REPORT_AUTOMATION_FLOW snapshot", () => {
+    const fixture = readFixture("report-automation-flow.json");
+    // deep-equal: the compiled template's flow is JSON.stringify(parsed YAML), so
+    // a deep-equal against the JSON snapshot of the source const proves the
+    // transcription is lossless (nodes, edges, and every prompt string).
+    expect(automation?.flow).toEqual(fixture);
+  });
+
+  it("preserves the load-bearing hardened prompt fragments (v13)", () => {
+    // A coarse smoke check that the specific product content survived — the
+    // deep-equal above is authoritative, but these named fragments make a
+    // regression legible if the fixture is ever regenerated wrongly.
+    const flowStr = JSON.stringify(automation?.flow);
+    for (const marker of [
+      "COUNTS — the exact number of records gathered",
+      "NEVER NARRATE YOUR OWN INSTRUCTIONS",
+      "LINK THE RECORDS YOU NAME",
+      "DATA INTEGRITY CHECK",
+    ]) {
+      expect(flowStr).toContain(marker);
+    }
+  });
+});
+
+describe("Task B — relation defs, full coverage", () => {
+  const fixture: Array<{ slug: string }> = readFixture(
+    "default-relation-defs.json"
+  );
+
+  it("covers every DEFAULT_RELATION_DEFS slug, byte-faithfully", () => {
+    // deep-equal against the generated snapshot: proves slug + displayName +
+    // description + isDirectional + uiHints all survived (the fields the
+    // entityLinks path would have dropped).
+    expect(base.relationDefs).toEqual(fixture);
+  });
+
+  it("has no duplicate slugs and carries the expected count", () => {
+    const slugs = (base.relationDefs ?? []).map((d) => d.slug);
+    expect(new Set(slugs).size).toBe(slugs.length);
+    expect(slugs.length).toBe(fixture.length);
+    // Spot-check a representative spread across categories.
+    for (const s of ["assigned_to", "relates_to", "works_at", "knows"]) {
+      expect(slugs).toContain(s);
+    }
+  });
+});
+
+describe("Task C — default command pack", () => {
+  const EXPECTED_TITLES = [
+    "Create View from Description",
+    "Extract Entities from Text",
+    "Summarize Selection",
+    "Analyze Entities",
+    "Create Task from Text",
+    "Create Event from Text",
+  ];
+
+  it("carries all 6 default command titles", () => {
+    const titles = (base.commands ?? []).map((c) => c.title);
+    expect(titles).toEqual(EXPECTED_TITLES);
+  });
+
+  it("every command has a non-empty prompt template", () => {
+    for (const c of base.commands ?? []) {
+      expect(typeof c.promptTemplate).toBe("string");
+      expect(c.promptTemplate.length).toBeGreaterThan(0);
+    }
+  });
+
+  it("the view command derives a goal input and can create views", () => {
+    const viewCmd = base.commands?.find(
+      (c) => c.title === "Create View from Description"
+    );
+    expect(viewCmd?.canCreateViews).toBe(true);
+    expect(viewCmd?.outputMode).toBe("view");
+    expect(viewCmd?.derivedInputs).toEqual([
+      { name: "goal", label: "Goal", type: "text" },
+    ]);
+  });
+});
+
+describe("door contract — resolved definitions forward the new surfaces", () => {
+  it("toWorkspaceDefinition('base') exposes commands, relationDefs, flowAutomations", () => {
+    const { definition } = toWorkspaceDefinition("base");
+    expect(definition.relationDefs).toEqual(base.relationDefs);
+    expect(definition.commands).toEqual(base.commands);
+    // flowAutomations is the existing wire field (define.ts maps flow→flowDefinition).
+    expect(definition.flowAutomations).toHaveLength(1);
+    expect(definition.flowAutomations?.[0]?.name).toBe("Generate report");
+    expect(definition.flowAutomations?.[0]?.flowDefinition).toEqual(
+      base.automations?.[0]?.flow
+    );
+  });
+
+  it("toPackageDefinition('base') carries the same surfaces (CP seed path)", () => {
+    const pkg = toPackageDefinition("base");
+    expect(pkg.relationDefs).toEqual(base.relationDefs);
+    expect(pkg.commands).toEqual(base.commands);
+    expect(pkg.automations?.[0]?.flowDefinition).toEqual(
+      base.automations?.[0]?.flow
+    );
+  });
+});