@gentbajko/slopify 3.25.9 → 4.0.0

package/dist/slices/images/scenes.js

@@ -1,30 +1,79 @@
 import { z } from "zod";
+import { jsonBetween } from "../../kernel/json-answer.js";
 import { detectSlots, render, sceneKeyword } from "../admission/substitute.js";
 // Scenes from the article (Images → Scenes from the article): each image is drawn from its
 // own scene instead of the same text every time. One call to the project's AI model reads the
 // article and writes every scene, following the article from its opening to its end in the
 // order the images are shown.
+// The keywords Slopify fills per picture from the scenes call (`keywords/specs.ts`): any of them
+// turns scenes on for that picture, whatever the Images switch says.
+export const slopifySceneKeywords = ["Slopify_Scene", "Slopify_Setting", "Slopify_Mood"];
+const sceneNames = [sceneKeyword, "Slopify_Scene"];
+const detailNames = ["Slopify_Setting", "Slopify_Mood"];
+// `{{Scene}}` or `{{Slopify_Scene}}`: where the scene goes.
 export function usesScene(body) {
+    return body != null && detectSlots(body).names.some((name) => sceneNames.includes(name));
+}
+// The old name, which follows Images → Scenes from the article as it always did.
+export function usesLegacyScene(body) {
     return body != null && detectSlots(body).names.includes(sceneKeyword);
 }
-// The prompt with its scene: where the prompt has `{{Scene}}`, there; otherwise as a line of
-// its own after the prompt's first paragraph, so any prompt takes a scene without editing.
-export function withScene(body, scene) {
-    if (usesScene(body))
-        return render(body, { [sceneKeyword]: scene });
-    const at = body.indexOf("\n\n");
+// `{{Slopify_Scene}}`, `{{Slopify_Setting}}` or `{{Slopify_Mood}}`: the picture gets its scene.
+export function usesSlopifyScene(body) {
+    return (body != null &&
+        detectSlots(body).names.some((name) => slopifySceneKeywords.includes(name)));
+}
+// `{{Slopify_Setting}}` or `{{Slopify_Mood}}`: the scenes call writes them too.
+export function wantsSceneDetails(body) {
+    return body != null && detectSlots(body).names.some((name) => detailNames.includes(name));
+}
+// The prompt with its scene: where the prompt has `{{Scene}}` or `{{Slopify_Scene}}`, there;
+// otherwise, while the Images switch is on (`legacy`), as a line of its own after the prompt's
+// first paragraph, so any prompt takes a scene without editing. With the switch off a picture is
+// here only for its `Slopify_` keywords, and a `{{Scene}}` line is left out as it always was.
+// The setting and mood go where the prompt asks; a line asking for one not written is left out.
+export function withScene(body, scene, options = {}) {
+    const legacy = options.legacy !== false;
+    const text = legacy ? body : withoutLines(body, [sceneKeyword]);
+    const detailed = withDetails(text, options);
+    if (usesScene(detailed))
+        return render(detailed, { [sceneKeyword]: scene, Slopify_Scene: scene });
+    if (!legacy)
+        return detailed;
+    const at = detailed.indexOf("\n\n");
     return at === -1
-        ? `${body}\n\nScene: ${scene}`
-        : `${body.slice(0, at)}\n\nScene: ${scene}${body.slice(at)}`;
+        ? `${detailed}\n\nScene: ${scene}`
+        : `${detailed.slice(0, at)}\n\nScene: ${scene}${detailed.slice(at)}`;
 }
-// The prompt with the switch off: a line that holds `{{Scene}}` is left out, so the image is
-// drawn from the rest of the prompt as it always was.
+// A picture that is drawn without scenes (the establishing image): a line holding a `Slopify_`
+// scene keyword is left out, and `{{Scene}}` stays as it always did.
+export function withoutSlopifyScene(body) {
+    return withoutLines(body, slopifySceneKeywords);
+}
+// The prompt with no scene: a line that holds a scene keyword is left out, so the image is drawn
+// from the rest of the prompt as it always was.
 export function withoutScene(body) {
-    if (!usesScene(body))
+    return withoutLines(body, [...sceneNames, ...detailNames]);
+}
+function withDetails(body, details) {
+    if (!wantsSceneDetails(body))
+        return body;
+    const missing = [
+        ...(details.setting?.trim() ? [] : ["Slopify_Setting"]),
+        ...(details.mood?.trim() ? [] : ["Slopify_Mood"]),
+    ];
+    return render(withoutLines(body, missing), {
+        ...(details.setting?.trim() ? { Slopify_Setting: details.setting.trim() } : {}),
+        ...(details.mood?.trim() ? { Slopify_Mood: details.mood.trim() } : {}),
+    });
+}
+function withoutLines(body, names) {
+    const holds = (line) => detectSlots(line).names.some((name) => names.includes(name));
+    if (!body.split("\n").some(holds))
         return body;
     return body
         .split("\n")
-        .filter((line) => !usesScene(line))
+        .filter((line) => !holds(line))
         .join("\n")
         .replace(/\n{3,}/g, "\n\n")
         .trim();
@@ -42,7 +91,25 @@ const countLine = /^Pictures: (\d+)$/m;
 // prompt asks for one with `{{Scene}}`. They are not tied to a stretch of the article: each is
 // the moment that would make someone click, a different one for each thumbnail.
 const thumbnailLine = /^Thumbnails: (\d+)$/m;
+// With `details`, each scene comes with its setting and mood for `{{Slopify_Setting}}` and
+// `{{Slopify_Mood}}`; without, the request is the one it always was.
 export function sceneMessages(brief) {
+    const plain = plainSceneMessages(brief);
+    return brief.details === true ? plain.map(askingDetails) : plain;
+}
+const answerLine = /^Answer with a JSON array of exactly (\d+) strings, (.*), and nothing else\.$/m;
+function askingDetails(message) {
+    if (message.role !== "system")
+        return message;
+    return {
+        ...message,
+        content: message.content.replace(answerLine, (_whole, total, order) => [
+            "For each scene also write its setting: the era and place of that moment in a few words (period, region, season), so the picture stays true to its time; and its mood: the feeling of that moment in one to three words (calm, tense, sad), for the picture's light and colour.",
+            `Answer with a JSON array of exactly ${total} objects, ${order}, each {"scene": "…", "setting": "…", "mood": "…"}, and nothing else.`,
+        ].join("\n\n")),
+    };
+}
+function plainSceneMessages(brief) {
     const count = brief.pictures.length;
     const thumbnails = brief.thumbnails ?? 0;
     if (thumbnails > 0)
@@ -120,15 +187,33 @@ function withThumbnails(brief, count, thumbnails) {
         },
     ];
 }
+const sceneAnswer = z.array(z.union([
+    z.string(),
+    z.object({
+        scene: z.string(),
+        setting: z.string().optional(),
+        mood: z.string().optional(),
+    }),
+]));
+// A list of scenes, or of scenes with their setting and mood (`details`, only then present).
 export function checkScenes(text, count) {
     const fix = "Use Try again; if it keeps happening, choose another model in the Providers section of Edit project.";
-    const parsed = z.array(z.string()).safeParse(jsonArrayOf(text));
+    const parsed = sceneAnswer.safeParse(jsonBetween(text, "[", "]"));
     if (!parsed.success)
         return {
             ok: false,
             reason: `The AI model didn't answer with a list of image scenes. ${fix}`,
         };
-    const scenes = parsed.data.map((scene) => scene.replace(/\s+/g, " ").trim());
+    const tidy = (value) => value.replace(/\s+/g, " ").trim();
+    const scenes = parsed.data.map((one) => tidy(typeof one === "string" ? one : one.scene));
+    const details = parsed.data.some((one) => typeof one !== "string")
+        ? parsed.data.map((one) => typeof one === "string"
+            ? {}
+            : {
+                ...(one.setting === undefined ? {} : { setting: tidy(one.setting) }),
+                ...(one.mood === undefined ? {} : { mood: tidy(one.mood) }),
+            })
+        : undefined;
     if (scenes.length !== count)
         return {
             ok: false,
@@ -136,17 +221,5 @@ export function checkScenes(text, count) {
         };
     if (scenes.some((scene) => scene === ""))
         return { ok: false, reason: `One of the AI model's image scenes is empty. ${fix}` };
-    return { ok: true, scenes };
-}
-function jsonArrayOf(text) {
-    const start = text.indexOf("[");
-    const end = text.lastIndexOf("]");
-    if (start === -1 || end <= start)
-        return undefined;
-    try {
-        return JSON.parse(text.slice(start, end + 1));
-    }
-    catch {
-        return undefined;
-    }
+    return { ok: true, scenes, ...(details === undefined ? {} : { details }) };
 }

package/dist/slices/keywords/digest.js

@@ -0,0 +1,84 @@
+import { z } from "zod";
+import { keywordSpecs } from "./specs.js";
+// The keyword digest: one call to the project's AI model reads the article once and writes every
+// digest keyword (`{{Slopify_Summary}}`, `{{Slopify_Hook}}`…), so a run that uses several pays for
+// one call. It asks for all six every time, so adding one more digest keyword to a prompt later
+// reuses the same answer.
+export const digestNames = keywordSpecs
+    .filter((spec) => spec.filler === "digest")
+    .map((spec) => spec.name);
+export function digestMessages(brief) {
+    return [
+        {
+            role: "system",
+            content: [
+                "You write short texts about a narrated video from its article, for its pictures, thumbnail, description, shorts and reviews.",
+                "summary: two or three sentences on what the video covers.",
+                "hook: the single most click-worthy idea of the video, in one sentence.",
+                "thumbnailText: two to four words to put on the thumbnail, in the video's language.",
+                "keyFacts: three to five striking facts the article states, each one sentence.",
+                "quote: one quotable line from the article, as it is written there.",
+                "tags: five to fifteen search terms someone would type to find this video.",
+                "Use only what the article says. Write in the article's language.",
+                'Answer with JSON and nothing else: {"summary": "…", "hook": "…", "thumbnailText": "…", "keyFacts": ["…"], "quote": "…", "tags": ["…"]}.',
+            ].join("\n\n"),
+        },
+        {
+            role: "user",
+            content: [`Video: ${brief.title}`, `Article:\n\n${brief.article}`].join("\n\n"),
+        },
+    ];
+}
+const listOrText = z.union([z.array(z.string()), z.string()]);
+const digestSchema = z.object({
+    summary: z.string(),
+    hook: z.string(),
+    thumbnailText: z.string(),
+    keyFacts: listOrText,
+    quote: z.string(),
+    tags: listOrText,
+});
+export function checkDigest(text) {
+    const fix = "Use Try again; if it keeps happening, choose another model in the Providers section of Edit project.";
+    const parsed = digestSchema.safeParse(jsonObjectOf(text));
+    if (!parsed.success)
+        return {
+            ok: false,
+            reason: `The AI model didn't answer with the keyword digest (summary, hook, thumbnail text, key facts, quote and tags). ${fix}`,
+        };
+    const tidy = (value) => value.replace(/\s+/g, " ").trim();
+    const list = (value) => (typeof value === "string" ? value.split("\n") : value)
+        .map((one) => tidy(one).replace(/^[-•*]\s*/, ""))
+        .filter((one) => one !== "");
+    const { summary, hook, thumbnailText, keyFacts, quote, tags } = parsed.data;
+    const digest = {
+        Slopify_Summary: tidy(summary),
+        Slopify_Hook: tidy(hook),
+        Slopify_Thumbnail_Text: tidy(thumbnailText),
+        Slopify_Key_Facts: list(keyFacts).join("\n"),
+        Slopify_Quote: tidy(quote),
+        Slopify_Tags: (typeof tags === "string" ? tags.split(",") : tags)
+            .map(tidy)
+            .filter((one) => one !== "")
+            .join(", "),
+    };
+    const empty = digestNames.filter((name) => (digest[name] ?? "") === "");
+    if (empty.length > 0)
+        return {
+            ok: false,
+            reason: `The AI model left part of the keyword digest empty (${empty.map((name) => `{{${name}}}`).join(", ")}). ${fix}`,
+        };
+    return { ok: true, digest };
+}
+function jsonObjectOf(text) {
+    const start = text.indexOf("{");
+    const end = text.lastIndexOf("}");
+    if (start === -1 || end <= start)
+        return undefined;
+    try {
+        return JSON.parse(text.slice(start, end + 1));
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/slices/keywords/facts.js

@@ -0,0 +1,92 @@
+// The facts a run copies when it starts, for the keywords Slopify fills from them: what the
+// channel, its links, its cast, its brand kit and its other projects are now. Later edits there
+// never change a project already made; Edit project's Refresh keyword facts copies them again.
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { listProjects } from "../admission/repo.js";
+import { castOfChannel, channelById, projectChannels, resolveChannelId } from "../channels/repo.js";
+import { readFontMetadata } from "../fonts/sfnt.js";
+import { seriesOf } from "../studio/plan-model.js";
+import { allReleases } from "../studio/releases.js";
+import { videoOf } from "../studio/videos.js";
+import { readChannelLinksFor } from "../youtube/edits-repo.js";
+// ceiling: the titles a prompt is told about. A channel with hundreds of videos would fill the
+// prompt with titles; the newest are the ones it is likeliest to repeat.
+export const coveredBeforeMax = 50;
+// `projectId` is the project the facts are for, when it exists already (a refresh): it is
+// neither its own previous video nor one it covered before.
+export function keywordFactsFor(deps, draft, now, projectId) {
+    const { db } = deps;
+    const channelId = resolveChannelId(db, draft.channelId);
+    const channel = channelById(db, channelId);
+    const channels = projectChannels(db);
+    const projects = listProjects(db);
+    // A refresh sees the channel as it was before this project, never the episodes made after it.
+    const made = projects.find((project) => project.id === projectId)?.createdAt;
+    const own = projects.filter((project) => project.id !== projectId &&
+        (made === undefined || project.createdAt < made) &&
+        (channels.get(project.id) ?? channelId) === channelId);
+    const series = seriesOf(draft);
+    const sameSeries = own.filter((project) => seriesOf(project.config) === series);
+    const later = projects.filter((project) => project.id !== projectId &&
+        seriesOf(project.config) === series &&
+        (channels.get(project.id) ?? channelId) === channelId);
+    const previous = sameSeries[0];
+    const previousVideo = previous === undefined ? undefined : videoOf(db, previous.id, null)?.videoId;
+    const upcoming = allReleases(db).find((release) => release.short === 0 &&
+        Date.parse(release.at) > now.getTime() &&
+        later.some((project) => project.id === release.projectId));
+    const next = upcoming === undefined ? undefined : later.find((one) => one.id === upcoming.projectId);
+    const links = readChannelLinksFor(db, channelId);
+    const cast = castOfChannel(db, channelId);
+    const brand = draft.useBrandKit === false ? undefined : channel?.brand;
+    const colours = unique([brand?.captionColor, brand?.captionOutlineColor, brand?.titleColor]);
+    const fonts = unique([brand?.captionFontId, brand?.titleFontId].map((id) => id === undefined ? undefined : fontName(deps.paths, id)));
+    return {
+        ...(channel === undefined ? {} : { channel: channel.name }),
+        ...(channel?.seriesBrief.trim() ? { series: channel.seriesBrief.trim() } : {}),
+        ...(links.length === 0 ? {} : { links: links.map(({ name, url }) => ({ name, url })) }),
+        ...(previous === undefined
+            ? {}
+            : {
+                previousVideo: {
+                    title: previous.title,
+                    ...(previousVideo === undefined ? {} : { url: `https://youtu.be/${previousVideo}` }),
+                },
+            }),
+        ...(next === undefined ? {} : { nextVideo: { title: next.title } }),
+        ...(cast.length === 0
+            ? {}
+            : { cast: cast.map(({ name, description }) => ({ name, description })) }),
+        ...(own.length === 0
+            ? {}
+            : { coveredBefore: own.slice(0, coveredBeforeMax).map((project) => project.title) }),
+        episode: sameSeries.length + 1,
+        ...(colours.length === 0 && fonts.length === 0 ? {} : { brand: { colours, fonts } }),
+    };
+}
+// A brand-kit font's name: the bundled one's, or an uploaded font's own. A system font is
+// found only by scanning the computer's font folders, which a run's start never waits for, so
+// it is left out.
+function fontName(paths, id) {
+    if (id === "default")
+        return "Barlow";
+    if (!/^uploaded-[a-f0-9]{64}$/.test(id))
+        return undefined;
+    for (const extension of [".ttf", ".otf"]) {
+        let bytes;
+        try {
+            bytes = readFileSync(join(paths.dataDir, "fonts", `${id}${extension}`));
+        }
+        catch (error) {
+            if (error instanceof Error && "code" in error && error.code === "ENOENT")
+                continue;
+            throw error;
+        }
+        return readFontMetadata(bytes)?.[0]?.family;
+    }
+    return undefined;
+}
+function unique(values) {
+    return [...new Set(values.filter((value) => value !== undefined))];
+}

package/dist/slices/keywords/fill.js

@@ -0,0 +1,80 @@
+// Filling the keywords Slopify fills into a prompt that `render` has already filled with the
+// person's own values, so a value they gave a `Slopify_` name still wins. A body with no
+// keyword comes back as the very same string. Browser-safe.
+import { keywordOf } from "./specs.js";
+const slot = /\{\{([^{}\n]*)\}\}/g;
+// Filled elsewhere: each picture's own keywords by the pictures, the release date and the length
+// when the step runs.
+const elsewhere = ["scenes", "appearance", "release", "duration"];
+export function mentionsKeyword(body) {
+    for (const match of body.matchAll(slot))
+        if (keywordOf((match[1] ?? "").trim())?.name === (match[1] ?? "").trim())
+            return true;
+    return false;
+}
+export function fillKeywords(body, place, values) {
+    return fillWith(body, (name) => {
+        const spec = keywordOf(name);
+        if (spec === undefined || spec.name !== name || !spec.places.includes(place))
+            return undefined;
+        if (elsewhere.includes(spec.filler))
+            return undefined;
+        return Object.hasOwn(values, name) ? (values[name] ?? "") : null;
+    });
+}
+// The release date and the length, filled when the step runs: they are left in the planned
+// request, so a later change to either never makes anything outdated.
+export function fillLateKeywords(text, late) {
+    const filled = fillWith(text, (name) => name === "Slopify_Release_Date"
+        ? (late.releaseDate ?? "")
+        : name === "Slopify_Duration"
+            ? (late.duration ?? "")
+            : undefined);
+    return filled.ok ? filled.text : text;
+}
+export function mentionsLateKeyword(text) {
+    return text.includes("Slopify_Release_Date") || text.includes("Slopify_Duration");
+}
+// `valueFor` answers a string to fill (an empty one leaves its line out), null for a keyword
+// still waiting, and undefined for a name to leave as written.
+export function fillWith(body, valueFor) {
+    const waiting = [];
+    const blank = [];
+    let touched = false;
+    for (const match of body.matchAll(slot)) {
+        const name = (match[1] ?? "").trim();
+        const value = valueFor(name);
+        if (value === undefined)
+            continue;
+        touched = true;
+        if (value === null && !waiting.includes(name))
+            waiting.push(name);
+        if (value === "" && !blank.includes(name))
+            blank.push(name);
+    }
+    if (!touched)
+        return { ok: true, text: body };
+    if (waiting.length > 0)
+        return { ok: false, waiting };
+    const kept = blank.length === 0
+        ? body
+        : body
+            .split("\n")
+            .filter((line) => !blank.some((name) => holds(line, name)))
+            .join("\n")
+            .replace(/\n{3,}/g, "\n\n")
+            .trim();
+    return {
+        ok: true,
+        text: kept.replace(slot, (whole, inside) => {
+            const value = valueFor(inside.trim());
+            return value === undefined || value === null ? whole : value;
+        }),
+    };
+}
+function holds(line, name) {
+    for (const match of line.matchAll(slot))
+        if ((match[1] ?? "").trim() === name)
+            return true;
+    return false;
+}

package/dist/slices/keywords/model.js

@@ -0,0 +1,75 @@
+// The keywords Slopify fills itself: never fields for the person, always written with the
+// reserved `Slopify_` prefix so they never take a name a template already uses. One table
+// says, for each, what fills it, where it works and what it costs; the editor's Insert bar,
+// its hover cards, the help tips, the lint and the fillers all read it. Browser-safe: the
+// editor imports it.
+// Where a keyword can appear: the prompt kinds, the intro and outro entries, and the title.
+export const keywordPlaces = [
+    "title",
+    "article",
+    "script",
+    "narration",
+    "intro",
+    "outro",
+    "image",
+    "thumbnail",
+    "description",
+    "shorts",
+    "review",
+    // A Library prompt that writes a post for another site (`slices/social`).
+    "post",
+];
+// What fills a keyword: facts copied when the run starts, the release date read when the step
+// runs, the article's chapter titles, the finished length, the shared digest call, the scenes
+// call and the appearance lookup.
+export const fillerKinds = [
+    "facts",
+    "release",
+    "chapters",
+    "duration",
+    "digest",
+    "scenes",
+    "appearance",
+];
+// Free, or part of one AI call per run (shared by every keyword with the same cost).
+export const keywordCosts = ["free", "digest", "scenes", "appearance"];
+export const reservedPrefix = "Slopify_";
+// The whole prefix is Slopify's, whatever its case, so a near miss never turns into a field
+// that a later keyword would take over.
+export function isReserved(name) {
+    return name.toLowerCase().startsWith(reservedPrefix.toLowerCase());
+}
+// What a keyword's cost says in the Insert bar.
+export function costLabel(cost) {
+    switch (cost) {
+        case "free":
+            return "Free: no AI call.";
+        case "digest":
+            return "Part of one AI call per run: the keyword digest, shared by every digest keyword.";
+        case "scenes":
+            return "Part of one AI call per run: the scenes call, shared by every picture.";
+        case "appearance":
+            return "Part of one AI call per run: the appearance lookup, with web search.";
+    }
+}
+// How the editor names a place: the prompt kinds and the two entry categories.
+export const placeLabels = {
+    title: "Title",
+    article: "Article",
+    script: "Script",
+    narration: "Narration",
+    intro: "Intro",
+    outro: "Outro",
+    image: "Image",
+    thumbnail: "Thumbnail",
+    description: "Description",
+    shorts: "Shorts",
+    review: "Review",
+    post: "Post",
+};
+// "A, B and C".
+export function listOf(words) {
+    if (words.length <= 1)
+        return words.join("");
+    return `${words.slice(0, -1).join(", ")} and ${words.at(-1) ?? ""}`;
+}