@gentbajko/slopify 2.5.0 → 3.0.1

package/dist/slices/model-upkeep/switch.js

@@ -0,0 +1,217 @@
+import { transact } from "../../kernel/db/tx.js";
+import { projectById, stagesOf, updateProjectConfig } from "../admission/repo.js";
+import { draftRow } from "../play-drafts/repo.js";
+import { documentOf, saveDraft } from "../play-drafts/service.js";
+import { templateById } from "../project-templates/repo.js";
+import { updateTemplate } from "../project-templates/service.js";
+import { ensureBaseline, saveRevision } from "../revisions/index.js";
+import { currentRevisionId } from "../revisions/repo.js";
+import { configChoices, formChoices, retiredModelUsage, retiredStatus, } from "./usage.js";
+function keepThinking(catalogue, provider, model, thinking) {
+    if (thinking === undefined)
+        return {};
+    const row = catalogue.llm.find((entry) => entry.provider === provider && entry.id === model);
+    return row?.llm.thinking?.[thinking] === undefined ? {} : { thinking };
+}
+function matches(choice, from) {
+    return choice !== undefined && choice.provider === from.provider && choice.model === from.model;
+}
+// The form with one model choice replaced, or undefined when the form no longer picks `from`
+// there (it was changed meanwhile, so there is nothing to switch).
+export function switchForm(form, catalogue, request) {
+    if (!matches(formChoices(form)[request.slot], request.from))
+        return undefined;
+    const { to } = request;
+    switch (request.slot) {
+        case "llm": {
+            const { thinking, ...rest } = form.llm;
+            return {
+                ...form,
+                llm: { ...rest, model: to, ...keepThinking(catalogue, rest.provider, to, thinking) },
+            };
+        }
+        case "audio":
+            return { ...form, audio: { ...form.audio, model: to } };
+        case "images":
+            return { ...form, images: { ...form.images, model: to } };
+        case "animate":
+            return form.videoEdit === undefined
+                ? undefined
+                : { ...form, videoEdit: { ...form.videoEdit, animateModel: to } };
+    }
+}
+export function switchConfig(config, catalogue, request) {
+    if (!matches(configChoices(config)[request.slot], request.from))
+        return undefined;
+    const { to } = request;
+    switch (request.slot) {
+        case "llm": {
+            if (config.llm === undefined)
+                return undefined;
+            const { thinking, ...rest } = config.llm;
+            return {
+                ...config,
+                llm: { ...rest, model: to, ...keepThinking(catalogue, rest.provider, to, thinking) },
+            };
+        }
+        case "audio":
+            return config.audio === undefined
+                ? undefined
+                : { ...config, audio: { ...config.audio, model: to } };
+        case "images":
+            return config.images === undefined
+                ? undefined
+                : { ...config, images: { ...config.images, model: to } };
+        case "animate":
+            return config.videoEdit === undefined
+                ? undefined
+                : { ...config, videoEdit: { ...config.videoEdit, animateModel: to } };
+    }
+}
+const changedMeanwhile = "This changed while you were looking at it. Reload Settings → Models to see what still uses a retired model.";
+// One click on "Switch to <model>": changes that one choice and nothing else. A template gets a
+// new version, and the schedules that ran its latest version follow it to the new one.
+export async function switchRetiredModel(deps, catalogue, request) {
+    if (retiredStatus(catalogue, request.slot, {
+        provider: request.from.provider,
+        model: request.to,
+    }) !== null)
+        return {
+            ok: false,
+            message: `${request.to} is not an active model of this provider. Reload Settings → Models and use the suggested switch, or choose a model yourself in the ${request.kind}.`,
+        };
+    switch (request.kind) {
+        case "template":
+            return switchTemplate(deps, catalogue, request, request.id);
+        case "schedule": {
+            const row = deps.db
+                .prepare("SELECT s.template_id AS templateId,s.template_version AS version,t.head_version AS head FROM schedules s JOIN project_templates t ON t.id=s.template_id WHERE s.id=? AND s.deleted_at IS NULL")
+                .get(request.id);
+            if (row === undefined)
+                return { ok: false, message: changedMeanwhile };
+            if (row.version !== row.head)
+                return {
+                    ok: false,
+                    message: "This schedule runs an older version of its template. In Library → Schedules, choose Edit, pick the template again so it runs the latest version, then save.",
+                };
+            return switchTemplate(deps, catalogue, request, String(row.templateId));
+        }
+        case "draft":
+            return switchDraft(deps, catalogue, request);
+        case "project":
+            return switchProject(deps, catalogue, request);
+    }
+}
+function switchTemplate(deps, catalogue, request, templateId) {
+    return transact(deps.db, () => {
+        const template = templateById(deps.db, templateId);
+        if (template === undefined)
+            return { ok: false, message: changedMeanwhile };
+        const form = switchForm(template.document.form, catalogue, request);
+        if (form === undefined)
+            return { ok: true, changed: false };
+        const saved = updateTemplate(deps, {
+            id: template.id,
+            name: template.name,
+            document: { ...template.document, form },
+            baseVersion: template.version,
+            mutationId: deps.uuid(),
+        });
+        if (!saved.ok)
+            return {
+                ok: false,
+                message: saved.reason === "missing-prompt"
+                    ? `The template "${template.name}" uses a prompt or intro/outro that was deleted, so it cannot be saved. Open it in Library → Templates, choose another, and save.`
+                    : changedMeanwhile,
+            };
+        deps.db
+            .prepare("UPDATE schedules SET template_version=?,version=version+1,updated_at=? WHERE template_id=? AND template_version=? AND deleted_at IS NULL AND status IN ('active','paused')")
+            .run(saved.value.version, deps.clock.now().toISOString(), template.id, template.version);
+        return { ok: true, changed: true };
+    });
+}
+function switchDraft(deps, catalogue, request) {
+    const row = draftRow(deps.db, request.id);
+    const document = row === undefined ? null : documentOf(row);
+    if (row === undefined || document === null || row.state !== "active")
+        return { ok: false, message: changedMeanwhile };
+    const form = switchForm(document.form, catalogue, request);
+    if (form === undefined)
+        return { ok: true, changed: false };
+    const saved = saveDraft({ ...deps, uuid: deps.uuid }, {
+        id: row.id,
+        baseVersion: row.version,
+        mutationId: deps.uuid(),
+        document: { ...document, form },
+    });
+    return saved.ok ? { ok: true, changed: true } : { ok: false, message: changedMeanwhile };
+}
+async function switchProject(deps, catalogue, request) {
+    const project = projectById(deps.db, request.id);
+    if (project === undefined)
+        return { ok: false, message: changedMeanwhile };
+    if (stagesOf(deps.db, project.id).some((stage) => stage.state === "running"))
+        return {
+            ok: false,
+            message: "This project is running. Wait for it to finish or pause it, then switch.",
+        };
+    if (currentRevisionId(deps.db, project.id) === undefined) {
+        // A project never edited has no saved versions yet: its configuration is the run itself.
+        const config = switchConfig(project.config, catalogue, request);
+        if (config === undefined)
+            return { ok: true, changed: false };
+        updateProjectConfig(deps.db, project.id, config, deps.clock.now().toISOString());
+        return { ok: true, changed: true };
+    }
+    const baseline = await ensureBaseline(deps, project.id);
+    if (!baseline.ok)
+        return { ok: false, message: changedMeanwhile };
+    const { revision } = baseline.view;
+    const config = switchConfig(revision.config, catalogue, request);
+    if (config === undefined)
+        return { ok: true, changed: false };
+    // The same save Edit project makes: a new version with only the model changed.
+    const saved = await saveRevision(deps, {
+        projectId: project.id,
+        baseRevisionId: revision.id,
+        idempotencyKey: deps.uuid(),
+        edit: { config, content: revision.content },
+    });
+    return saved.ok
+        ? { ok: true, changed: true }
+        : {
+            ok: false,
+            message: `Slopify could not save the new model on "${project.title}"${saved.reason === "conflict"
+                ? " because the project changed meanwhile"
+                : "fields" in saved && saved.fields?.[0] !== undefined
+                    ? ` (${saved.fields[0].message})`
+                    : ""}. Open the project, choose Edit project and change it under Providers.`,
+        };
+}
+// "Switch all": every listed use that has a suggestion and no reason to hold back, one by one.
+export async function switchAllRetired(deps, catalogue) {
+    let switched = 0;
+    const failed = [];
+    // Templates first: switching one also moves the schedules that follow it.
+    const order = ["template", "schedule", "draft", "project"];
+    const usages = [...retiredModelUsage(deps.db, catalogue)].sort((a, b) => order.indexOf(a.kind) - order.indexOf(b.kind));
+    for (const usage of usages) {
+        if (usage.blocked !== null || usage.replacement === null)
+            continue;
+        const result = await switchRetiredModel(deps, catalogue, requestOf(usage));
+        if (!result.ok)
+            failed.push({ key: usage.key, message: result.message });
+        else if (result.changed)
+            switched++;
+    }
+    return { switched, failed };
+}
+export function requestOf(usage) {
+    return {
+        kind: usage.kind,
+        id: usage.id,
+        slot: usage.slot,
+        from: { provider: usage.provider, model: usage.model },
+        to: usage.replacement?.id ?? "",
+    };
+}

package/dist/slices/model-upkeep/usage.js

@@ -0,0 +1,185 @@
+import { z } from "zod";
+import { isVideoModel } from "../../catalog/schema.js";
+import { listProjects, stagesOf } from "../admission/repo.js";
+import { draftRows } from "../play-drafts/repo.js";
+import { documentOf } from "../play-drafts/service.js";
+import { templateById } from "../project-templates/repo.js";
+import { currentRevisionId, revisionById } from "../revisions/repo.js";
+import { isUncataloguedProvider } from "../settings/model.js";
+import { usageSlots } from "./model.js";
+export { slotLabels, usageKinds, usageSlots } from "./model.js";
+function familyOf(slot) {
+    return slot === "llm" ? "llm" : slot === "audio" ? "tts" : "image";
+}
+// The model choices a Play form (a draft or a template) makes.
+export function formChoices(form) {
+    const edit = form.videoEdit;
+    return {
+        llm: form.llm,
+        audio: form.audio,
+        images: form.images,
+        ...(edit !== undefined && edit.animate !== "off"
+            ? { animate: { provider: form.images.provider, model: edit.animateModel } }
+            : {}),
+    };
+}
+// The same for a project's run configuration.
+export function configChoices(config) {
+    const edit = config.videoEdit;
+    return {
+        ...(config.llm === undefined ? {} : { llm: config.llm }),
+        ...(config.audio === undefined ? {} : { audio: config.audio }),
+        ...(config.images === undefined ? {} : { images: config.images }),
+        ...(edit !== undefined && edit.animate !== "off" && config.images !== undefined
+            ? { animate: { provider: config.images.provider, model: edit.animateModel } }
+            : {}),
+    };
+}
+// Whether a choice names a catalogued model that is no longer offered. Command-line tools
+// list their own models and are checked by the health check instead.
+export function retiredStatus(catalogue, slot, choice) {
+    if (choice.provider === "" ||
+        choice.model.trim() === "" ||
+        isUncataloguedProvider(choice.provider))
+        return null;
+    const row = catalogue[familyOf(slot)].find((model) => model.provider === choice.provider &&
+        model.id === choice.model &&
+        isVideoModel(model) === (slot === "animate"));
+    if (row === undefined)
+        return "unlisted";
+    if (row.deprecated)
+        return "retired";
+    return row.enabled ? null : "unlisted";
+}
+// The closest active model from the same provider and list: the one sharing the longest
+// start of its ID (a newer version of the same line), the catalogue's order breaking ties.
+export function suggestReplacement(catalogue, slot, choice) {
+    let best = null;
+    for (const row of catalogue[familyOf(slot)]) {
+        if (row.provider !== choice.provider ||
+            row.id === choice.model ||
+            !row.enabled ||
+            row.deprecated ||
+            isVideoModel(row) !== (slot === "animate"))
+            continue;
+        const score = sharedStart(row.id.toLowerCase(), choice.model.toLowerCase());
+        if (best === null || score > best.score)
+            best = { id: row.id, name: row.name, score };
+    }
+    return best === null ? null : { id: best.id, name: best.name };
+}
+function sharedStart(a, b) {
+    let index = 0;
+    while (index < a.length && index < b.length && a[index] === b[index])
+        index++;
+    return index;
+}
+function usagesOf(catalogue, base, choices, blocked) {
+    const found = [];
+    for (const slot of usageSlots) {
+        const choice = choices[slot];
+        if (choice === undefined)
+            continue;
+        const why = retiredStatus(catalogue, slot, choice);
+        if (why === null)
+            continue;
+        const replacement = suggestReplacement(catalogue, slot, choice);
+        found.push({
+            ...base,
+            key: `${base.kind}:${base.id}:${slot}`,
+            slot,
+            provider: choice.provider,
+            model: choice.model,
+            why,
+            replacement,
+            blocked: blocked ??
+                (replacement === null
+                    ? "This provider has no other model to switch to. Choose another provider for this step and save."
+                    : null),
+        });
+    }
+    return found;
+}
+const scheduleRow = z.object({
+    id: z.string(),
+    name: z.string(),
+    template_id: z.string(),
+    template_version: z.number(),
+});
+const headRow = z.object({ head_version: z.number() });
+export function choiceSites(db) {
+    const sites = [];
+    const heads = new Map();
+    for (const row of db.prepare("SELECT id FROM project_templates ORDER BY id").all()) {
+        const id = z.object({ id: z.string() }).parse(row).id;
+        const template = templateById(db, id);
+        if (template === undefined)
+            continue;
+        heads.set(id, template.version);
+        sites.push({
+            kind: "template",
+            id,
+            name: template.name,
+            choices: formChoices(template.document.form),
+            blocked: null,
+        });
+    }
+    for (const raw of db
+        .prepare("SELECT id,name,template_id,template_version FROM schedules WHERE deleted_at IS NULL AND status IN ('active','paused') ORDER BY lower(name),id")
+        .all()) {
+        const row = scheduleRow.parse(raw);
+        const template = templateById(db, row.template_id, row.template_version);
+        if (template === undefined)
+            continue;
+        const head = heads.get(row.template_id) ??
+            headRow.parse(db.prepare("SELECT head_version FROM project_templates WHERE id=?").get(row.template_id)).head_version;
+        sites.push({
+            kind: "schedule",
+            id: row.id,
+            name: row.name,
+            choices: formChoices(template.document.form),
+            blocked: head === row.template_version
+                ? null
+                : `This schedule runs an older version of the template "${template.name}". In Library → Schedules, choose Edit, pick the template again so it runs the latest version, then save.`,
+        });
+    }
+    for (const row of draftRows(db)) {
+        if (row.state !== "active")
+            continue;
+        const document = documentOf(row);
+        if (document === null)
+            continue;
+        sites.push({
+            kind: "draft",
+            id: row.id,
+            name: row.title.trim() === "" ? "Untitled draft" : row.title,
+            choices: formChoices(document.form),
+            blocked: null,
+        });
+    }
+    for (const project of listProjects(db)) {
+        const stages = stagesOf(db, project.id);
+        // Only a project with steps still to run will use its models again.
+        if (!stages.some((stage) => ["pending", "running", "failed", "canceled"].includes(stage.state)))
+            continue;
+        const revisionId = currentRevisionId(db, project.id);
+        const config = revisionId === undefined
+            ? project.config
+            : (revisionById(db, project.id, revisionId)?.config ?? project.config);
+        sites.push({
+            kind: "project",
+            id: project.id,
+            name: project.title,
+            choices: configChoices(config),
+            blocked: stages.some((stage) => stage.state === "running")
+                ? "This project is running. Wait for it to finish or pause it, then switch."
+                : null,
+        });
+    }
+    return sites;
+}
+// Every template, schedule, draft and unfinished project that still picks a retired or
+// unlisted model, with the suggested replacement. Nothing is changed here.
+export function retiredModelUsage(db, catalogue) {
+    return choiceSites(db).flatMap((site) => usagesOf(catalogue, { kind: site.kind, id: site.id, name: site.name }, site.choices, site.blocked));
+}

package/dist/slices/narration/aliases-library.js

@@ -0,0 +1,31 @@
+import { transact } from "../../kernel/db/tx.js";
+import { aliasProblems, narrationAliasSchema } from "./aliases-schema.js";
+export function listNarrationAliases(db) {
+    return db
+        .prepare("SELECT written,spoken,whole_word,case_sensitive FROM narration_aliases ORDER BY position,id")
+        .all()
+        .flatMap((row) => {
+        // A row edited by hand into something the editor can't save is left out, not fatal.
+        const parsed = narrationAliasSchema.safeParse({
+            written: row.written,
+            spoken: row.spoken,
+            wholeWord: row.whole_word === 1,
+            caseSensitive: row.case_sensitive === 1,
+        });
+        return parsed.success ? [parsed.data] : [];
+    });
+}
+export function saveNarrationAliases(deps, rows) {
+    const fields = aliasProblems(rows);
+    if (fields.length > 0)
+        return { ok: false, fields };
+    const aliases = rows.map((row) => narrationAliasSchema.parse(row));
+    const now = deps.clock.now().toISOString();
+    transact(deps.db, () => {
+        deps.db.prepare("DELETE FROM narration_aliases").run();
+        const insert = deps.db.prepare("INSERT INTO narration_aliases(id,position,written,spoken,whole_word,case_sensitive,updated_at) VALUES (?,?,?,?,?,?,?)");
+        for (const [position, alias] of aliases.entries())
+            insert.run(deps.ids.next(), position, alias.written, alias.spoken, alias.wholeWord ? 1 : 0, alias.caseSensitive ? 1 : 0, now);
+    });
+    return { ok: true, aliases };
+}

package/dist/slices/narration/aliases-schema.js

@@ -0,0 +1,53 @@
+import { z } from "zod";
+import { aliasCountMax, aliasSpokenMax, aliasWrittenMax, } from "../../kernel/ports/narration-aliases.js";
+// One alias as a project config and Library → Aliases store it.
+export const narrationAliasSchema = z
+    .object({
+    written: z.string().trim().min(1).max(aliasWrittenMax),
+    spoken: z.string().trim().min(1).max(aliasSpokenMax),
+    wholeWord: z.boolean(),
+    caseSensitive: z.boolean(),
+})
+    .strict()
+    .readonly();
+export const narrationAliasesSchema = z.array(narrationAliasSchema).max(aliasCountMax).readonly();
+export function aliasProblems(rows) {
+    const problems = [];
+    if (rows.length > aliasCountMax)
+        problems.push({
+            field: "aliases",
+            message: `Keep at most ${aliasCountMax} aliases; remove some, then Save.`,
+        });
+    const seen = new Map();
+    for (const [index, raw] of rows.entries()) {
+        const row = index + 1;
+        const parsed = narrationAliasSchema.safeParse(raw);
+        if (!parsed.success) {
+            const written = z.object({ written: z.string() }).safeParse(raw);
+            const spoken = z.object({ spoken: z.string() }).safeParse(raw);
+            problems.push({
+                field: `aliases.${index}`,
+                message: !written.success || written.data.written.trim() === ""
+                    ? `Alias ${row}: write the word or phrase as it appears in the article.`
+                    : !spoken.success || spoken.data.spoken.trim() === ""
+                        ? `Alias ${row}: write how the narrator should say it.`
+                        : `Alias ${row}: keep the written form under ${aliasWrittenMax} characters and the spoken form under ${aliasSpokenMax}.`,
+            });
+            continue;
+        }
+        const key = aliasKey(parsed.data);
+        const earlier = seen.get(key);
+        if (earlier !== undefined)
+            problems.push({
+                field: `aliases.${index}`,
+                message: `Alias ${row}: alias ${earlier} already covers the same written form; keep one of them.`,
+            });
+        else
+            seen.set(key, row);
+    }
+    return problems;
+}
+function aliasKey(alias) {
+    const written = alias.written.trim().replace(/\s+/gu, " ");
+    return alias.caseSensitive ? `=${written}` : `~${written.toLocaleLowerCase("en")}`;
+}

package/dist/slices/narration/aliases.js

@@ -0,0 +1,49 @@
+import { aliasMatches, } from "../../kernel/ports/narration-aliases.js";
+// Narration aliases ride the same rails as the Pronunciation Glossary: a span of the clean
+// narration text with what the voice gets instead. The clean text (what the transcript and
+// captions show) is untouched. A span never holds whitespace, so an alias whose written form
+// has several words puts all of the spoken form on its first word and nothing on the rest.
+export function aliasSpans(source, aliases) {
+    const spans = [];
+    for (const match of aliasMatches(source, aliases))
+        for (const [index, word] of Array.from(source.slice(match.start, match.end).matchAll(/\S+/gu)).entries()) {
+            const start = match.start + word.index;
+            spans.push({ start, end: start + word[0].length, text: index === 0 ? match.spoken : "" });
+        }
+    return spans;
+}
+// An alias wins over a glossary pronunciation of the same words: it says what to read, and the
+// glossary only how to read what is written.
+export function withAliasSpans(glossary, aliases) {
+    if (aliases.length === 0)
+        return glossary;
+    const kept = glossary.filter((span) => !aliases.some((alias) => alias.start < span.end && span.start < alias.end));
+    return [...kept, ...aliases].sort((a, b) => a.start - b.start);
+}
+// The sentences Narration Preparation reads, with the aliases already applied, so its
+// delivery cues fit what will actually be said. The sentences are cut from the clean text
+// first, so their numbers stay the ones the cues are checked and placed against.
+export function aliasedSentences(sentences, matches) {
+    if (matches.length === 0)
+        return sentences;
+    let offset = 0;
+    return sentences.map((sentence) => {
+        const start = offset;
+        const end = start + sentence.text.length;
+        offset = end;
+        let text = "";
+        let at = start;
+        for (const match of matches) {
+            if (match.end <= start || match.start >= end)
+                continue;
+            if (match.start >= at)
+                text += sentence.text.slice(at - start, match.start - start);
+            // The spoken form goes with the sentence the written form starts in.
+            if (match.start >= start)
+                text += match.spoken;
+            at = Math.max(at, Math.min(match.end, end));
+        }
+        text += sentence.text.slice(at - start);
+        return { sentence: sentence.sentence, text };
+    });
+}