@synap-core/workspace-templates 0.11.0 → 0.23.0

package/src/content-os.work-a-take.template.test.ts

@@ -0,0 +1,125 @@
+/**
+ * "One take, several videos" (founder decisions D1, D2, D3, 29 Oct), as
+ * catalog config, read from the YAML SOURCE so an edit is seen without a
+ * rebuild.
+ *
+ *   - D1: a take is a Content OS content-asset of Kind `recording`, holding
+ *     its facts; its `file-id` is the raw take.
+ *   - D2: a piece is a NEW video file cut from the take, recorded as the same
+ *     Kind with `source-take`, `source-start` and `source-end`. The raw take
+ *     is never overwritten; a re-cut is a new file, the old one kept.
+ *   - D3: the process "Work a take" transcribes, finds the pieces, asks the
+ *     person which to keep, cuts the kept ones and makes one post per piece.
+ *
+ * Content Studio and the other lanes read these exact keys, so they are pinned.
+ */
+import { readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { load } from "js-yaml";
+import { describe, expect, it } from "vitest";
+import type { TemplatePlaybook, WorkspaceYaml } from "./types.js";
+
+const source = load(
+  readFileSync(join(dirname(fileURLToPath(import.meta.url)), "content-os.yaml"), "utf8"),
+) as WorkspaceYaml;
+const asset = source.profiles.find((p) => p.slug === "content-asset");
+const prop = (slug: string) => asset?.properties.find((d) => d.slug === slug);
+const work = (source.playbooks ?? []).find((p) => p.name === "Work a take") as TemplatePlaybook | undefined;
+const goalOf = (key: string) => (work?.stages?.find((s) => s.key === key)?.goal ?? "").replace(/\s+/g, " ");
+
+/** The ONE transcript shape (D6 of 27 Oct), as every process that writes one states it. */
+const TRANSCRIPT_SHAPE = '[{"text","start","end"}]';
+
+describe("a take and a piece are content-assets of Kind recording", () => {
+  it("adds recording to the asset kinds, keeping every earlier value", () => {
+    expect(prop("asset-kind")?.enumValues).toEqual(["image", "video", "audio", "font", "script", "recording", "other"]);
+  });
+
+  it("declares the recording facts with their types", () => {
+    for (const slug of ["duration-seconds", "frame-width", "frame-height", "frame-rate", "source-start", "source-end"]) {
+      expect({ slug, valueType: prop(slug)?.valueType }).toEqual({ slug, valueType: "number" });
+    }
+    for (const slug of ["poster-file-id", "take-topic", "take-look", "piece-hook"]) {
+      expect({ slug, valueType: prop(slug)?.valueType }).toEqual({ slug, valueType: "string" });
+    }
+    expect(prop("recorded-at")?.valueType).toBe("date");
+    expect(prop("take-kind")?.enumValues).toEqual(["answer", "free"]);
+    expect(prop("piece-format")?.enumValues).toEqual(["Short Video", "Long Video"]);
+  });
+
+  it("gives a piece its lineage: the take it was cut from, and its earlier cuts", () => {
+    expect(prop("source-take")).toMatchObject({ valueType: "entity_id", targetProfileSlug: "content-asset" });
+    expect(prop("earlier-file-ids")?.valueType).toBe("array");
+  });
+});
+
+describe("Work a take finds the pieces in a take and makes them new files", () => {
+  it("is a process on the take, with no status of its own", () => {
+    expect(work?.subjectProfile).toEqual({ profileSlug: "content-asset" });
+    expect(work?.params).toEqual([{ name: "take", type: "entity", label: "Take", required: true }]);
+    expect(work?.executor).toBe("is-agent");
+    expect(work?.stages?.map((s) => s.key)).toEqual(["transcribe", "analyse", "keep", "cut", "posts"]);
+    for (const stage of work?.stages ?? []) {
+      expect({ stage: stage.key, subjectStatus: stage.subjectStatus }).toEqual({ stage: stage.key, subjectStatus: undefined });
+    }
+  });
+
+  it("asks the person about each piece on a slot, never through a stage gate or a stage-level slot", () => {
+    for (const stage of work?.stages ?? []) {
+      expect({ stage: stage.key, gate: stage.gate }).toEqual({ stage: stage.key, gate: undefined });
+    }
+    const declared = JSON.stringify([...(work?.expectedOutputs ?? []), ...(work?.stages ?? []).flatMap((s) => s.expectedOutputs ?? [])]);
+    for (const key of ["keep-piece-", "piece-<n>", "post-<n>"]) expect(declared).not.toContain(key);
+    const analyse = goalOf("analyse");
+    for (const part of [
+      "key keep-piece-<n>; kind decision; owner human; blockedReason decision",
+      "ask choose with allowOther, options Keep (recommended when it stands alone and fits its format), Drop, and Adjust",
+      "<start>-<end> in seconds",
+    ]) {
+      expect(analyse).toContain(part);
+    }
+    expect(goalOf("keep")).toContain("a piece the person dropped is never cut");
+  });
+
+  it("transcribes into the ONE transcript shape and writes ONE analysis with a pieces block", () => {
+    const transcribe = goalOf("transcribe");
+    expect(transcribe).toContain("ONE content-asset, Kind script, whose File ID is the take's file");
+    expect(transcribe).toContain(TRANSCRIPT_SHAPE);
+    expect(transcribe).toContain("Never transcribe twice, never a separate document");
+    expect(goalOf("analyse")).toContain('"## Pieces" heading followed by exactly one ```json fenced block [{"n","start","end","title","hook","format","why"}]');
+    expect(work?.stages?.find((s) => s.key === "analyse")?.expectedOutputs).toEqual([
+      { kind: "document", label: "Analysis", relationToSubject: "references" },
+    ]);
+  });
+
+  it("cuts each kept piece into a NEW file with ffmpeg and never touches the raw take", () => {
+    const cut = goalOf("cut");
+    for (const part of [
+      "Declare its slot as yours first (an outcome, key piece-<n>, kind content-asset, no owner, no ask)",
+      "from the raw take into a NEW file",
+      "~/synap-work/<this run's session id>/pieces/<n>.mp4",
+      "ffmpeg -ss <start> -to <end> -i <raw take>",
+      "Kind recording",
+      "source-take the take, source-start and source-end",
+      "append the old file id to earlier-file-ids; never delete or overwrite a file",
+    ]) {
+      expect(cut).toContain(part);
+    }
+    // The piece gets its own transcript in the same shape, so Produce Content finds it by its file.
+    expect(cut).toContain("its own transcript in the same ONE shape (File ID = the piece's file)");
+    expect((work?.goalTemplate ?? "").replace(/\s+/g, " ")).toContain("The raw take is never overwritten");
+  });
+
+  it("makes one video post at Idea per piece and starts nothing unasked", () => {
+    const posts = goalOf("posts");
+    expect(posts).toContain("Make one video post per cut piece, at Idea");
+    expect(posts).toContain("linked to the piece with a references relation");
+    expect(posts).toContain("key post-<n>, kind post");
+    expect(posts).toContain("Start Produce Content for a post only if the person asks");
+  });
+
+  it("links ideas from the take back to it", () => {
+    expect(goalOf("analyse")).toContain("propose each as a post at Idea that quotes the person's sentence and links to the take with a references relation");
+  });
+});