@gentbajko/slopify 3.25.9 → 4.1.0

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) ?? ""}`;
+}

package/dist/slices/keywords/rules.js

@@ -0,0 +1,187 @@
+// What the editor and Play say about the keywords in one body: a `Slopify_` name that is no
+// keyword, a keyword where it can't be filled, and an old name that still works. Browser-safe.
+import { detectSlots } from "../admission/substitute.js";
+import { isReserved, listOf, placeLabels, reservedPrefix, } from "./model.js";
+import { keywordOf, keywordSpecs, legacyNames } from "./specs.js";
+export const keywordProblemKinds = ["unknown", "wrong-place", "legacy"];
+// The same well-formed slot the parser reads (`admission/substitute.ts`).
+const slot = /\{\{([^{}\n]*)\}\}/g;
+// Unknown names already in the stored prompt are let through, so a prompt saved before the
+// prefix was reserved still saves.
+export function keywordProblems(body, place, grandfathered = []) {
+    const problems = [];
+    for (const match of body.matchAll(slot)) {
+        const name = (match[1] ?? "").trim();
+        if (name === "")
+            continue;
+        const at = match.index;
+        const where = `{{${name}}} at ${positionOf(body, at)}`;
+        const spec = keywordOf(name);
+        if (spec === undefined) {
+            if (isReserved(name) && !grandfathered.includes(name))
+                problems.push({
+                    kind: "unknown",
+                    name,
+                    at,
+                    message: `${where} isn't a keyword Slopify fills: names starting with ${reservedPrefix} are Slopify's own. Rename it, e.g. {{${name.slice(reservedPrefix.length) || "Topic"}}}, or insert a keyword from the Insert bar above the text.`,
+                });
+            continue;
+        }
+        const legacy = spec.legacy === name;
+        if (!spec.places.includes(place)) {
+            // An old name outside the picture prompts was plain text before the keywords, and still is.
+            if (legacy)
+                continue;
+            problems.push({ kind: "wrong-place", name, at, message: wrongPlace(where, spec, place) });
+            continue;
+        }
+        if (legacy)
+            problems.push({
+                kind: "legacy",
+                name,
+                at,
+                message: `${where} is the old name of {{${spec.name}}}. It keeps working; use Update to new names in the editor to rename it.`,
+            });
+    }
+    return problems;
+}
+function wrongPlace(where, spec, place) {
+    if (place === "title")
+        return `${where} can't be used in the title: Slopify fills its keywords from the title, so the title can't use them. Remove it, or use a keyword of your own such as {{${spec.name.slice(reservedPrefix.length)}}}.`;
+    const works = listOf(spec.places.map((one) => placeLabels[one]));
+    return `${where} can't be used in ${placeName(place)}: ${why(spec, place)}. Remove it; it works in ${works}.`;
+}
+function why(spec, place) {
+    if ((place === "article" || place === "script") && spec.places.includes("narration"))
+        return "it exists once the article is written, so never in the Article or Script prompt";
+    switch (spec.filler) {
+        case "digest":
+            return place === "article" || place === "script"
+                ? "it is written from the article, which doesn't exist yet when this prompt runs"
+                : "Slopify writes it for pictures, descriptions, shorts and reviews only";
+        case "duration":
+            return "the video's length is known only once the narration is finished";
+        case "scenes":
+        case "appearance":
+            return "it describes one picture, so it works only in picture prompts";
+        default:
+            return "it describes how pictures look, so it works only in picture prompts";
+    }
+}
+function placeName(place) {
+    const label = placeLabels[place];
+    const article = /^[AEIOU]/.test(label) ? "an" : "a";
+    return place === "intro" || place === "outro"
+        ? `${article} ${label} entry`
+        : `${article} ${label} prompt`;
+}
+// The old names a body uses, in first-appearance order.
+export function usesLegacy(body) {
+    const found = [];
+    for (const match of body.matchAll(slot)) {
+        const name = (match[1] ?? "").trim();
+        if (legacyNames.includes(name) && !found.includes(name))
+            found.push(name);
+    }
+    return found;
+}
+// The body with one old name written as its new one. Appearance means the same under both
+// names; Scene's new name turns scenes on for that picture, which is why each is its own choice.
+export function upgradeLegacy(body, which) {
+    const spec = keywordOf(which);
+    if (spec === undefined || spec.legacy !== which)
+        return body;
+    return body.replace(slot, (whole, inside) => inside.trim() === which ? `{{${spec.name}}}` : whole);
+}
+// The place a rendered prompt key fills (`library/slots.ts` names them).
+export function placeOfKey(key, options = {}) {
+    if (key === "article")
+        return options.script === true ? "script" : "article";
+    if (key === "narration" || key === "intro" || key === "outro")
+        return key;
+    if (key === "description" || key === "shorts")
+        return key;
+    if (key === "shortsImage" || key === "referencePrompt" || /^imagePrompts\.\d+$/.test(key))
+        return "image";
+    if (key === "thumbnailPrompt")
+        return "thumbnail";
+    if (key.startsWith("review."))
+        return "review";
+    if (key.startsWith("social."))
+        return "post";
+    return undefined;
+}
+// The parser reports a character offset; a person editing a textarea counts lines and columns.
+export function positionOf(body, at) {
+    const before = body.slice(0, at);
+    const lastBreak = before.lastIndexOf("\n");
+    const line = before.split("\n").length;
+    const column = at - lastBreak;
+    return `line ${String(line)}, column ${String(column)}`;
+}
+// The keywords filled from the facts a run copies when it starts (`facts.ts`).
+const factNames = keywordSpecs
+    .filter((spec) => spec.filler === "facts" && spec.name !== "Slopify_Title")
+    .map((spec) => spec.name);
+// Whether any of the bodies asks for a fact Slopify copies (the title is the project's own).
+export function usesFacts(bodies) {
+    return bodies.some((body) => detectSlots(body).names.some((name) => factNames.includes(name)));
+}
+export function keywordUsesOf(bodies) {
+    let digest;
+    let chapters;
+    let scenes;
+    for (const { field, place, body } of bodies)
+        for (const name of detectSlots(body).names) {
+            const spec = keywordOf(name);
+            if (spec === undefined || spec.name !== name || !spec.places.includes(place))
+                continue;
+            if (spec.filler === "digest")
+                digest ??= field;
+            if (spec.filler === "chapters")
+                chapters ??= field;
+            if (spec.filler === "scenes")
+                scenes ??= field;
+        }
+    return {
+        ...(digest === undefined ? {} : { digest }),
+        ...(chapters === undefined ? {} : { chapters }),
+        ...(scenes === undefined ? {} : { scenes }),
+    };
+}
+// What stops a run: a keyword in a prompt that runs where it can't be filled. A name the person
+// gave a value of their own is theirs (a prompt saved before the prefix was reserved), and an
+// unknown `Slopify_` name stays an ordinary keyword to fill in.
+export function placedProblems(bodies, values) {
+    const problems = [];
+    const seen = new Set();
+    for (const { field, place, body } of bodies)
+        for (const problem of keywordProblems(body, place)) {
+            if (problem.kind !== "wrong-place" || Object.hasOwn(values, problem.name))
+                continue;
+            const key = `${field}\0${problem.name}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            problems.push({
+                field,
+                message: place === "title"
+                    ? problem.message
+                    : `${problem.message} Change the prompt in Prompts, or pick another one.`,
+            });
+        }
+    return problems;
+}
+// A Text-mode intro or outro is narrated as written, and the release date is only filled into a
+// request as it is sent to the AI model (`rebuild/runtime-keywords.ts`), so a Text entry can't
+// say it.
+export function textEntryProblems(body, category) {
+    return detectSlots(body).names.includes("Slopify_Release_Date")
+        ? [
+            {
+                field: category,
+                message: `{{Slopify_Release_Date}} can't be used in an ${category} that says these exact words: those are narrated as written, and the release date is only filled in when a step asks the AI model. In Prompts → Intros and outros, set this ${category}'s What the narrator reads to Let the AI write it from these instructions, or remove the keyword.`,
+            },
+        ]
+        : [];
+}

package/dist/slices/keywords/schema.js

@@ -0,0 +1,28 @@
+import { z } from "zod";
+// `values.ts`'s KeywordFacts, as a saved config holds it. Edit project sends it back with the
+// rest of the config, so it is bounded like any other part of a draft.
+const text = z.string().max(10_000);
+export const keywordFactsSchema = z.object({
+    channel: text.optional(),
+    series: text.optional(),
+    links: z
+        .array(z.object({ name: text, url: text }))
+        .max(200)
+        .readonly()
+        .optional(),
+    previousVideo: z.object({ title: text, url: text.optional() }).optional(),
+    nextVideo: z.object({ title: text }).optional(),
+    cast: z
+        .array(z.object({ name: text, description: text }))
+        .max(500)
+        .readonly()
+        .optional(),
+    coveredBefore: z.array(text).max(500).readonly().optional(),
+    episode: z.number().int().min(1).optional(),
+    brand: z
+        .object({
+        colours: z.array(text).max(10).readonly(),
+        fonts: z.array(text).max(10).readonly(),
+    })
+        .optional(),
+});

package/dist/slices/keywords/specs.js

@@ -0,0 +1,260 @@
+// The keywords themselves, in the order the Insert bar and the wiki list them.
+import { keywordPlaces } from "./model.js";
+const everywhere = keywordPlaces.filter((place) => place !== "title");
+const afterArticle = everywhere.filter((place) => place !== "article" && place !== "script");
+const pictures = ["image", "thumbnail"];
+const fromDigest = [
+    "image",
+    "thumbnail",
+    "description",
+    "shorts",
+    "review",
+    "post",
+];
+const atStart = "When the run starts; later changes don't change this project.";
+const digestAvailable = "Once the article is written: one shared AI call writes every digest keyword the run uses.";
+const sceneAvailable = "Once the article is written: the scenes call writes one for each picture, even with Scenes from the article off.";
+export const keywordSpecs = [
+    {
+        name: "Slopify_Title",
+        filler: "facts",
+        fills: "The video's title, with its keywords filled in.",
+        example: "How Lighthouses Were Built on Bare Rock",
+        available: atStart,
+        places: everywhere,
+        cost: "free",
+        batch: 1,
+    },
+    {
+        name: "Slopify_Channel",
+        filler: "facts",
+        fills: "The name of the project's channel.",
+        example: "Quiet Histories",
+        available: atStart,
+        places: everywhere,
+        cost: "free",
+        batch: 1,
+    },
+    {
+        name: "Slopify_Series",
+        filler: "facts",
+        fills: "The channel's series brief, from the channel's page under Name and look. A line with an empty brief is left out.",
+        example: "Calm histories of how things were made, one invention at a time.",
+        available: atStart,
+        places: everywhere,
+        cost: "free",
+        batch: 2,
+    },
+    {
+        name: "Slopify_Chapters",
+        filler: "chapters",
+        fills: "The article's chapter titles, one per line.",
+        example: "The first lamps\nBuilding on bare rock\nThe last keepers",
+        available: "Once the article is written, so never in the Article or Script prompt.",
+        places: afterArticle,
+        cost: "free",
+        batch: 1,
+    },
+    {
+        name: "Slopify_Links",
+        filler: "facts",
+        fills: "The channel's links, one per line as name and address. In a Description prompt they stay links the page fills when it shows the description.",
+        example: "Website: https://example.com\nPatreon: https://patreon.com/example",
+        available: atStart,
+        places: everywhere,
+        cost: "free",
+        batch: 1,
+    },
+    {
+        name: "Slopify_Previous_Video",
+        filler: "facts",
+        fills: "The title and link of the channel's previous video in the same series. A line with none is left out; in a Description prompt it stays the Previous video link.",
+        example: "The Canal Age – https://youtu.be/abc123",
+        available: atStart,
+        places: everywhere,
+        cost: "free",
+        batch: 1,
+    },
+    {
+        name: "Slopify_Next_Video",
+        filler: "facts",
+        fills: "The title of the next planned video in the same series and posting plan line. A line with none is left out; in a Description prompt it stays the Next video link.",
+        example: "Tea Clippers and the Race Home",
+        available: atStart,
+        places: everywhere,
+        cost: "free",
+        batch: 1,
+    },
+    {
+        name: "Slopify_Release_Date",
+        filler: "release",
+        fills: "The release date from the posting plan. A line with no date is left out; moving the date later makes nothing again.",
+        example: "Thursday 22 October 2026",
+        available: "When the step runs.",
+        places: everywhere,
+        cost: "free",
+        batch: 2,
+    },
+    {
+        name: "Slopify_Episode",
+        filler: "facts",
+        fills: "This video's number in its series on the channel.",
+        example: "7",
+        available: atStart,
+        places: everywhere,
+        cost: "free",
+        batch: 2,
+    },
+    {
+        name: "Slopify_Duration",
+        filler: "duration",
+        fills: "The finished video's length.",
+        example: "42 min 10 s",
+        available: "Once the narration is finished.",
+        places: ["description", "shorts", "review", "post"],
+        cost: "free",
+        batch: 2,
+    },
+    {
+        name: "Slopify_Cast",
+        filler: "facts",
+        fills: "The channel's cast members, each with their description. A line with no cast is left out.",
+        example: "Mira: a keeper's daughter who kept the lighthouse logbook",
+        available: atStart,
+        places: everywhere,
+        cost: "free",
+        batch: 2,
+    },
+    {
+        name: "Slopify_Covered_Before",
+        filler: "facts",
+        fills: "The titles of the videos the channel already made, so the article avoids repeating them. A line with none is left out.",
+        example: "The Canal Age\nHow Bread Was Baked in Rome",
+        available: atStart,
+        places: everywhere,
+        cost: "free",
+        batch: 2,
+    },
+    {
+        name: "Slopify_Brand",
+        filler: "facts",
+        fills: "The brand kit's caption and title colors and font names. A line with an empty kit is left out.",
+        example: "Colors: #f5c542, #101010. Fonts: Barlow Condensed",
+        available: atStart,
+        places: pictures,
+        cost: "free",
+        batch: 2,
+    },
+    {
+        name: "Slopify_Summary",
+        filler: "digest",
+        fills: "Two or three sentences on what the video covers.",
+        example: "How engineers raised towers on rocks the sea covered twice a day, and how their keepers lived.",
+        available: digestAvailable,
+        places: fromDigest,
+        cost: "digest",
+        batch: 1,
+    },
+    {
+        name: "Slopify_Hook",
+        filler: "digest",
+        fills: "The video's most click-worthy idea.",
+        example: "The rock was under water half of every day. They built on it anyway.",
+        available: digestAvailable,
+        places: fromDigest,
+        cost: "digest",
+        batch: 1,
+    },
+    {
+        name: "Slopify_Thumbnail_Text",
+        filler: "digest",
+        fills: "Two to four words to put on the thumbnail.",
+        example: "BUILT UNDER WATER",
+        available: digestAvailable,
+        places: fromDigest,
+        cost: "digest",
+        batch: 1,
+    },
+    {
+        name: "Slopify_Key_Facts",
+        filler: "digest",
+        fills: "Three to five striking facts from the article, one per line.",
+        example: "The tower stands 35 metres high.\nIts lamp was first lit in 1811.",
+        available: digestAvailable,
+        places: fromDigest,
+        cost: "digest",
+        batch: 2,
+    },
+    {
+        name: "Slopify_Quote",
+        filler: "digest",
+        fills: "One quotable line from the article.",
+        example: "A light is only as good as the person who keeps it.",
+        available: digestAvailable,
+        places: fromDigest,
+        cost: "digest",
+        batch: 2,
+    },
+    {
+        name: "Slopify_Tags",
+        filler: "digest",
+        fills: "Search terms for the video, separated by commas.",
+        example: "lighthouses, engineering history, maritime history, history for sleep",
+        available: digestAvailable,
+        places: fromDigest,
+        cost: "digest",
+        batch: 2,
+    },
+    {
+        name: "Slopify_Scene",
+        filler: "scenes",
+        fills: "What this picture shows: a moment of the article, written for each picture.",
+        example: "A keeper climbs the spiral stair at dusk, a lamp held high.",
+        available: sceneAvailable,
+        places: pictures,
+        cost: "scenes",
+        legacy: "Scene",
+        batch: 1,
+    },
+    {
+        name: "Slopify_Setting",
+        filler: "scenes",
+        fills: "The era and place of this picture's moment, so it stays period-correct.",
+        example: "A rocky Scottish coast, early 19th century, late autumn",
+        available: sceneAvailable,
+        places: pictures,
+        cost: "scenes",
+        batch: 1,
+    },
+    {
+        name: "Slopify_Mood",
+        filler: "scenes",
+        fills: "The feeling of this picture's moment, for its light and color.",
+        example: "tense",
+        available: sceneAvailable,
+        places: pictures,
+        cost: "scenes",
+        batch: 2,
+    },
+    {
+        name: "Slopify_Appearance",
+        filler: "appearance",
+        fills: "How the video's subject and the characters in this picture look, looked up on the web.",
+        example: "Mira: a tall woman in a wool coat and oilskin hat, a brass lamp at her belt.",
+        available: "Once the article is written: one AI call with web search looks them up.",
+        places: pictures,
+        cost: "appearance",
+        legacy: "Appearance",
+        batch: 1,
+    },
+];
+export const keywordNames = keywordSpecs.map((spec) => spec.name);
+export const legacyNames = keywordSpecs.flatMap((spec) => spec.legacy === undefined ? [] : [spec.legacy]);
+// The keyword a slot name stands for: its own name, or Scene's and Appearance's old ones. Names
+// are case-sensitive, like every slot name.
+export function keywordOf(name) {
+    return keywordSpecs.find((spec) => spec.name === name || spec.legacy === name);
+}
+export function keywordsFor(place) {
+    return keywordSpecs.filter((spec) => spec.places.includes(place));
+}