@gentbajko/slopify 3.25.8 → 4.0.0

package/dist/slices/template-studio/anatomy-view.js

@@ -0,0 +1,118 @@
+import { projectExists } from "../admission/repo.js";
+import { templateById } from "../project-templates/repo.js";
+import { currentRevisionId } from "../revisions/repo.js";
+import { getRevisionView } from "../revisions/view.js";
+import { promptAnatomy } from "./anatomy.js";
+import { resolveSampleRun } from "./quote.js";
+import { sampleOf } from "./repo.js";
+import { sampleArticleInstruction, sampleDocument } from "./scope.js";
+import { defaultSampleTopic } from "./service.js";
+// The section a prompt is sent from, by its key in the run's rendered prompts.
+export function sectionOfPrompt(key) {
+    if (key === "article" || key === "intro" || key === "outro")
+        return "script";
+    if (key === "narration")
+        return "voice";
+    if (key.startsWith("imagePrompts.") || key === "referencePrompt")
+        return "pictures";
+    if (key.startsWith("thumbnail"))
+        return "thumbnail";
+    if (key === "description")
+        return "upload";
+    if (key === "shorts" || key === "shortsImage")
+        return "shorts";
+    if (key.startsWith("review."))
+        return "reviews";
+    return undefined;
+}
+function labelOf(key, names) {
+    if (key === "article")
+        return "Article prompt";
+    if (key === "intro")
+        return "Intro";
+    if (key === "outro")
+        return "Outro";
+    if (key === "narration")
+        return "Narration prompt";
+    if (key === "referencePrompt")
+        return "Establishing image prompt";
+    if (key.startsWith("imagePrompts.")) {
+        const index = Number(key.slice("imagePrompts.".length));
+        return `Image prompt ${names[index] ?? String(index + 1)}`;
+    }
+    if (key.startsWith("thumbnail"))
+        return "Thumbnail prompt";
+    if (key === "description")
+        return "YouTube description prompt";
+    if (key === "shorts")
+        return "Shorts prompt";
+    if (key === "shortsImage")
+        return "Shorts picture prompt";
+    if (key.startsWith("review."))
+        return `Review prompt (${key.slice("review.".length)})`;
+    return key;
+}
+export async function getAnatomy(deps, id, section, item) {
+    const template = templateById(deps.db, id);
+    if (template === undefined)
+        return {
+            ok: false,
+            reason: "not-found",
+            message: "This template no longer exists; it may have been deleted. Go to Library → Templates to see your templates.",
+        };
+    const record = sampleOf(deps.db, id);
+    const fullScript = record?.fullScript ?? false;
+    const resolved = await resolveSampleRun(deps.review, sampleDocument(template.document, {
+        topic: record?.topic ?? defaultSampleTopic(deps.db),
+        fullScript,
+    }), fullScript);
+    const empty = (problem) => ({
+        ok: true,
+        value: { section, items: [], item: null, segments: [], fromSample: false, problem },
+    });
+    if (!resolved.ok)
+        return empty(resolved.problem);
+    const { run } = resolved;
+    const names = template.document.form.imagePrompts.map((prompt) => prompt.name);
+    const items = Object.keys(run.templates)
+        .filter((key) => sectionOfPrompt(key) === section)
+        .map((key) => ({ key, label: labelOf(key, names) }));
+    const chosen = items.find((one) => one.key === item) ?? items[0];
+    if (chosen === undefined)
+        return empty(null);
+    const body = run.templates[chosen.key] ?? "";
+    // What the sample sent, when its project still runs this very body.
+    let sent;
+    if (record !== undefined && projectExists(deps.db, record.projectId)) {
+        const revisionId = currentRevisionId(deps.db, record.projectId);
+        const view = revisionId === undefined
+            ? undefined
+            : getRevisionView({
+                db: deps.db,
+                paths: deps.paths,
+                log: deps.log,
+                ids: { next: () => "" },
+                clock: { now: () => new Date(), sleep: async () => undefined },
+            }, record.projectId, revisionId);
+        if (view?.revision.content.promptTemplates[chosen.key] === body)
+            sent = view.revision.config.rendered[chosen.key];
+    }
+    return {
+        ok: true,
+        value: {
+            section,
+            items,
+            item: chosen.key,
+            segments: promptAnatomy({
+                body,
+                sent: sent ?? run.rendered[chosen.key],
+                values: run.draft.values,
+                appended: chosen.key === "article" && !fullScript
+                    ? [{ text: sampleArticleInstruction, by: "slopify" }]
+                    : [],
+            }),
+            fromSample: sent !== undefined,
+            problem: null,
+        },
+    };
+}

package/dist/slices/template-studio/anatomy.js

@@ -0,0 +1,73 @@
+import { filledKeywords } from "../admission/substitute.js";
+const slot = /\{\{([^{}\n]*)\}\}/gu;
+function partsOf(body) {
+    const parts = [];
+    let last = 0;
+    for (const match of body.matchAll(slot)) {
+        const at = match.index;
+        if (at > last)
+            parts.push({ literal: body.slice(last, at) });
+        const name = (match[1] ?? "").trim();
+        parts.push(name === "" ? { literal: match[0] } : { name });
+        last = at + match[0].length;
+    }
+    if (last < body.length)
+        parts.push({ literal: body.slice(last) });
+    return parts;
+}
+const escapeRegex = (text) => text.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+// Each keyword's value as the sent prompt shows it: the body's own text around the slots is
+// matched in the sent text, and what lies between is the value. Undefined when the sent prompt
+// isn't this body filled in (the prompt was edited by hand, or it is another version's).
+export function sentValues(body, sent) {
+    const parts = partsOf(body);
+    const names = [];
+    const pattern = parts
+        .map((part) => {
+        if (part.name === undefined)
+            return escapeRegex(part.literal ?? "");
+        names.push(part.name);
+        return "([\\s\\S]*?)";
+    })
+        .join("");
+    const match = new RegExp(`^${pattern}$`, "u").exec(sent);
+    if (match === null)
+        return undefined;
+    const values = Object.create(null);
+    names.forEach((name, index) => {
+        const value = match[index + 1] ?? "";
+        if (!Object.hasOwn(values, name))
+            values[name] = value;
+    });
+    return values;
+}
+export function promptAnatomy(input) {
+    const filled = input.filled ?? filledKeywords;
+    const read = input.sent === undefined ? undefined : sentValues(input.body, input.sent);
+    const filledValue = (name) => {
+        const shown = read?.[name];
+        // A slot the sent prompt still shows as written was never filled.
+        if (shown !== undefined && shown !== `{{${name}}}`)
+            return shown;
+        return Object.hasOwn(input.values, name) && input.values[name] !== ""
+            ? input.values[name]
+            : undefined;
+    };
+    const segments = [];
+    for (const part of partsOf(input.body)) {
+        if (part.name === undefined) {
+            const text = part.literal ?? "";
+            if (text !== "")
+                segments.push({ origin: "yours", text });
+            continue;
+        }
+        const value = filledValue(part.name);
+        const origin = filled.includes(part.name) ? "slopify" : "keyword";
+        segments.push(value === undefined
+            ? { origin, name: part.name, text: `{{${part.name}}}`, unfilled: true }
+            : { origin, name: part.name, text: value });
+    }
+    for (const extra of input.appended ?? [])
+        segments.push({ origin: extra.by, text: `\n\n${extra.text}` });
+    return segments;
+}

package/dist/slices/template-studio/bakeoff-make.js

@@ -0,0 +1,225 @@
+import { internalError } from "../../kernel/errors.js";
+import { derive } from "../../kernel/runner/graph.js";
+import { projectExists, projectPaused, stagesOf } from "../admission/repo.js";
+import { copyProject } from "../onboarding/copy.js";
+import { templateById } from "../project-templates/repo.js";
+import { previewRebuild, startRebuild } from "../rebuild/service.js";
+import { saveRevision } from "../revisions/mutations.js";
+import { currentRevisionId } from "../revisions/repo.js";
+import { getRevisionView } from "../revisions/view.js";
+import { withModel } from "./bakeoff.js";
+import { bakeoffOf, clonesOf, setBakeoff, setClone, } from "./bakeoff-repo.js";
+import { budgetRoom, budgetWords, fitsBudget } from "./budget.js";
+import { sampleEdit } from "./edit.js";
+import { removeHiddenProject } from "./hidden.js";
+import { sectionLabel } from "./model.js";
+import { refused, settled, studioWords } from "./paid.js";
+import { resolveSampleRun } from "./quote.js";
+import { sampleOf } from "./repo.js";
+import { exceedsAcknowledged } from "./save.js";
+import { sampleDocument } from "./scope.js";
+import { sectionOfWork } from "./sections.js";
+const money = (value) => `$${value.toFixed(2)}`;
+export async function makeBakeoff(deps, job, signal) {
+    const { db } = deps.start;
+    const at = () => deps.start.clock.now().toISOString();
+    const row = bakeoffOf(db, job.templateId);
+    if (row === undefined || (row.state !== "queued" && row.state !== "making"))
+        return;
+    const stop = (state, sentence) => setBakeoff(db, row.id, state, sentence, at());
+    const template = templateById(db, row.templateId);
+    if (template === undefined)
+        return;
+    if (template.version !== row.templateVersion) {
+        stop("failed", "The template was saved again since the bake-off was priced, so it wasn't made and nothing was spent. Compare again on the new version.");
+        return;
+    }
+    const sample = sampleOf(db, row.templateId);
+    if (sample === undefined || !projectExists(db, sample.projectId)) {
+        stop("failed", "The template's sample is gone, so there is nothing to compare on. Press Make sample, then compare again.");
+        return;
+    }
+    // The copies are taken once the sample's own work has finished.
+    await settled(deps, sample.projectId, signal);
+    setBakeoff(db, row.id, "making", null, at());
+    const clones = clonesOf(db, row.id);
+    const prepared = [];
+    for (const clone of clones) {
+        if (signal.aborted)
+            return;
+        if (clone.state === "making" || clone.state === "done" || clone.state === "failed")
+            continue;
+        const ready = await prepare(deps, row, clone, sample, signal);
+        if (typeof ready === "string") {
+            setClone(db, row.id, clone.slot, { state: "failed", failure: ready, finishedAt: at() });
+            continue;
+        }
+        prepared.push(ready);
+    }
+    // The whole bake-off is held against what the person accepted, before anything starts.
+    if (prepared.length > 0) {
+        const high = prepared.reduce((sum, one) => sum + Math.max(one.high, one.clone.quotedHigh ?? 0), 0);
+        const unknown = prepared.reduce((sum, one) => sum + one.unknown, 0);
+        const usesPlan = prepared.some((one) => one.usesPlan);
+        const room = budgetRoom(db, deps.start.clock.now(), deps.timeZone);
+        const waiting = exceedsAcknowledged(high, row.ackHigh)
+            ? `Waiting: comparing now costs about ${money(high)}, more than the ${money(row.ackHigh)} you saw. Press Compare again to accept the new price.`
+            : unknown > 0 && !row.ackUnknown
+                ? `Waiting: ${String(unknown)} ${unknown === 1 ? "step has" : "steps have"} no known price. Press Compare again to accept that.`
+                : !fitsBudget(room, high, usesPlan)
+                    ? `Waiting: ${budgetWords(room, { high, usesPlan }, "comparing")}, or compare tomorrow.`
+                    : undefined;
+        if (waiting !== undefined) {
+            for (const one of prepared) {
+                // A copy that stays keeps its row, so it stays hidden and Discard removes it later.
+                if (removeHiddenProject(deps.rebuild, one.projectId).ok)
+                    setClone(db, row.id, one.clone.slot, { state: "queued", projectId: null });
+                else
+                    setClone(db, row.id, one.clone.slot, {
+                        state: "failed",
+                        failure: "This model's copy couldn't be removed while the bake-off waited, because its files are busy or in use. Press Discard in the bake-off once nothing uses Slopify's files, then Compare again.",
+                        finishedAt: at(),
+                    });
+            }
+            stop("held", waiting);
+            return;
+        }
+    }
+    for (const one of prepared) {
+        if (signal.aborted)
+            return;
+        const started = await startRebuild(deps.rebuild, {
+            projectId: one.projectId,
+            baseRevisionId: one.revisionId,
+            idempotencyKey: deps.start.uuid(),
+            previewId: one.previewId,
+            acknowledgeUnknownCosts: one.unknown === 0 || row.ackUnknown,
+            confirmedProvidedWorkKeys: one.provided,
+        });
+        if (!started.ok) {
+            setClone(db, row.id, one.clone.slot, {
+                state: "failed",
+                failure: refused(started.reason, started.fields),
+                finishedAt: at(),
+            });
+            continue;
+        }
+        setClone(db, row.id, one.clone.slot, { state: "making", startedAt: at() });
+    }
+    // Each copy finishes on its own; the slower ones are waited for in turn.
+    for (const clone of clonesOf(db, row.id)) {
+        if (clone.state !== "making" || clone.projectId === null)
+            continue;
+        await settled(deps, clone.projectId, signal);
+        const failure = failureOf(deps, clone.projectId);
+        setClone(db, row.id, clone.slot, {
+            state: failure === null ? "done" : "failed",
+            failure,
+            finishedAt: at(),
+        });
+    }
+    const finished = clonesOf(db, row.id);
+    setBakeoff(db, row.id, finished.some((clone) => clone.state === "done") ? "done" : "failed", finished.some((clone) => clone.state === "done")
+        ? null
+        : "No other model could make the sample: each one says why. Fix it, or pick other models, and compare again.", at());
+}
+// A copy of the sample with the model switched, priced for the section's own work. A string
+// says why this model can't be compared.
+async function prepare(deps, row, clone, sample, signal) {
+    const { db } = deps.start;
+    const template = templateById(db, row.templateId, row.templateVersion);
+    if (template === undefined)
+        return "The template's version is gone.";
+    const catalogue = deps.rebuild.catalogue.read();
+    const document = withModel(template.document, row.section, clone, catalogue);
+    const resolved = await resolveSampleRun(deps.start, sampleDocument(document, { topic: sample.topic, fullScript: sample.fullScript }), sample.fullScript);
+    if (!resolved.ok)
+        return resolved.problem;
+    if (signal.aborted)
+        return "Slopify stopped before this model's copy was made.";
+    let projectId = clone.projectId;
+    if (projectId === null || !projectExists(db, projectId)) {
+        // The copy's row names its project before the project exists, so it is hidden, and its
+        // folder kept in the data dir, from its very first file.
+        const reserved = deps.start.ids.next();
+        let given = false;
+        const ids = {
+            next: () => {
+                if (given)
+                    return deps.start.ids.next();
+                given = true;
+                return reserved;
+            },
+        };
+        setClone(db, row.id, clone.slot, { projectId: reserved });
+        try {
+            const copied = copyProject({ ...deps.rebuild, ids, catalogue }, sample.projectId, `Bake-off: ${clone.model}`);
+            if (copied.projectId !== reserved)
+                throw new Error(internalError("the bake-off copy got another id than its row", "Compare again"));
+        }
+        catch (error) {
+            setClone(db, row.id, clone.slot, { projectId: null });
+            return `The sample couldn't be copied for ${clone.model}: ${error instanceof Error ? error.message : String(error)}`;
+        }
+        projectId = reserved;
+        // The copy's own spending only: the sample's calls it was copied with are the sample's.
+        db.prepare("DELETE FROM provider_usage WHERE project_id=?").run(projectId);
+        db.prepare("DELETE FROM plan_limit_readings WHERE project_id=?").run(projectId);
+    }
+    const base = getRevisionView(deps.rebuild, projectId, currentRevisionId(db, projectId) ?? "");
+    if (base === undefined)
+        return "The copy of the sample has no version to change.";
+    const saved = await saveRevision(deps.rebuild, {
+        projectId,
+        baseRevisionId: base.revision.id,
+        idempotencyKey: deps.start.uuid(),
+        edit: sampleEdit(deps.rebuild, base, resolved.run),
+    });
+    if (!saved.ok)
+        return refused(saved.reason, saved.fields);
+    const revisionId = saved.view.revision.id;
+    const all = await previewRebuild(deps.rebuild, {
+        projectId,
+        baseRevisionId: revisionId,
+        request: { kind: "allAffected" },
+    });
+    if (!all.ok)
+        return refused(all.reason, all.fields);
+    const keys = all.value.work
+        .filter((work) => (work.disposition === "generate" || work.disposition === "local") &&
+        sectionOfWork(work.key) === row.section)
+        .map((work) => work.key);
+    if (keys.length === 0)
+        return `Nothing in ${sectionLabel[row.section]} changes with ${clone.model}, so there is nothing to compare.`;
+    const preview = await previewRebuild(deps.rebuild, {
+        projectId,
+        baseRevisionId: revisionId,
+        request: { kind: "selected", workKeys: keys },
+    });
+    if (!preview.ok)
+        return refused(preview.reason, preview.fields);
+    return {
+        clone,
+        projectId,
+        revisionId,
+        previewId: preview.value.id,
+        high: preview.value.costs.high,
+        unknown: preview.value.costs.unknown,
+        usesPlan: preview.value.costs.rows.some((one) => one.onPlan === true),
+        provided: preview.value.providedReuseRequired,
+    };
+}
+// The failed step's own sentence, or null when the copy's work finished.
+function failureOf(deps, projectId) {
+    const stages = stagesOf(deps.start.db, projectId);
+    const state = derive(stages, projectPaused(deps.start.db, projectId));
+    if (state === "failed") {
+        const reason = stages.find((stage) => stage.state === "failed")?.failureReason;
+        return reason === undefined || reason === null
+            ? "A step of this model's copy failed without saying why. Compare again; if it fails again, use Download diagnostics in Settings and report it."
+            : studioWords(reason, "Compare again", "");
+    }
+    if (state === "canceled" || state === "paused")
+        return "This model's copy stopped before it finished. Compare again to make it.";
+    return null;
+}

package/dist/slices/template-studio/bakeoff-repo.js

@@ -0,0 +1,83 @@
+import { z } from "zod";
+// The bake-off's rows (`0074-template-bakeoffs.sql`): one per template, and one copy per model.
+export const bakeoffSections = ["script", "voice", "pictures"];
+export const bakeoffStates = ["queued", "making", "done", "held", "failed"];
+export const cloneStates = ["queued", "making", "done", "failed"];
+const bakeoffRow = z.object({
+    id: z.string(),
+    templateId: z.string(),
+    templateVersion: z.number().int().positive(),
+    section: z.enum(bakeoffSections),
+    ackHigh: z.number(),
+    ackUnknown: z.number(),
+    state: z.enum(bakeoffStates),
+    sentence: z.string().nullable(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+});
+const cloneRow = z.object({
+    slot: z.number().int(),
+    provider: z.string(),
+    model: z.string(),
+    projectId: z.string().nullable(),
+    state: z.enum(cloneStates),
+    quotedHigh: z.number().nullable(),
+    failure: z.string().nullable(),
+    startedAt: z.string().nullable(),
+    finishedAt: z.string().nullable(),
+});
+export function bakeoffOf(db, templateId) {
+    const row = db
+        .prepare(`SELECT id,template_id AS templateId,template_version AS templateVersion,section,ack_high AS ackHigh,
+         ack_unknown AS ackUnknown,state,sentence,created_at AS createdAt,updated_at AS updatedAt
+       FROM template_bakeoffs WHERE template_id=?`)
+        .get(templateId);
+    if (row === undefined)
+        return undefined;
+    const parsed = bakeoffRow.parse(row);
+    return { ...parsed, ackUnknown: parsed.ackUnknown === 1 };
+}
+export function clonesOf(db, bakeoffId) {
+    return db
+        .prepare(`SELECT slot,provider,model,project_id AS projectId,state,quoted_high AS quotedHigh,failure,
+         started_at AS startedAt,finished_at AS finishedAt
+       FROM template_bakeoff_clones WHERE bakeoff_id=? ORDER BY slot`)
+        .all(bakeoffId)
+        .map((row) => cloneRow.parse(row));
+}
+export function insertBakeoff(db, row, clones) {
+    db.prepare(`INSERT INTO template_bakeoffs (id,template_id,template_version,section,ack_high,ack_unknown,state,sentence,created_at,updated_at)
+     VALUES (?,?,?,?,?,?,'queued',NULL,?,?)`).run(row.id, row.templateId, row.templateVersion, row.section, row.ackHigh, row.ackUnknown ? 1 : 0, row.createdAt, row.createdAt);
+    const insert = db.prepare("INSERT INTO template_bakeoff_clones (bakeoff_id,slot,provider,model,state,quoted_high) VALUES (?,?,?,?,'queued',?)");
+    clones.forEach((clone, slot) => {
+        insert.run(row.id, slot, clone.provider, clone.model, clone.quotedHigh);
+    });
+}
+export function setBakeoff(db, id, state, sentence, at) {
+    db.prepare("UPDATE template_bakeoffs SET state=?,sentence=?,updated_at=? WHERE id=?").run(state, sentence, at, id);
+}
+// Records what one copy is now. A field left out keeps what it was.
+export function setClone(db, bakeoffId, slot, change) {
+    const columns = {
+        state: change.state,
+        project_id: change.projectId,
+        quoted_high: change.quotedHigh,
+        failure: change.failure,
+        started_at: change.startedAt,
+        finished_at: change.finishedAt,
+    };
+    const set = Object.entries(columns).filter(([, value]) => value !== undefined);
+    if (set.length === 0)
+        return;
+    db.prepare(`UPDATE template_bakeoff_clones SET ${set.map(([column]) => `${column}=?`).join(",")} WHERE bakeoff_id=? AND slot=?`).run(...set.map(([, value]) => value ?? null), bakeoffId, slot);
+}
+export function deleteBakeoffRow(db, id) {
+    db.prepare("DELETE FROM template_bakeoffs WHERE id=?").run(id);
+}
+// A newer Save, topic or full script takes the place of a bake-off still waiting to start: the
+// bake-off was priced on the version before it.
+export function supersedeQueuedBakeoff(db, templateId, at) {
+    db.prepare(`UPDATE template_bakeoffs SET state='failed',updated_at=?,
+       sentence='A newer Save took its place before it started, so nothing was spent on it. Start the bake-off again on the new version.'
+     WHERE template_id=? AND state='queued'`).run(at, templateId);
+}