@gentbajko/slopify 1.2.1 → 1.4.0

package/dist/slices/rebuild/runtime-provider.js

@@ -1,6 +1,8 @@
 import { plainText } from "../article/plain.js";
 import { splitEndMatter } from "../article/split.js";
 import { observeNarration } from "../narration/live.js";
+import { validatePreparation } from "../narration/preparation.js";
+import { prepareRequests } from "../narration/steering.js";
 import { chaptersFrom } from "../research/planner.js";
 import { sourcedAnswer } from "../research/synthesis.js";
 import { discardPreparedAssets, writeAsset } from "../storage/assets.js";
@@ -28,7 +30,7 @@ export async function executeProviderRecipe(deps, context, providers, piece) {
                 messages: input.messages,
                 webSearch: input.webSearch,
                 previewLabel: piece.key,
-                check: (value) => checkAnswer(piece, value),
+                check: (value) => checkAnswer(piece, value) ?? checkPreparation(deps, context, piece, value),
             });
         if (!answer.ok)
             return "held";
@@ -63,6 +65,7 @@ export async function executeProviderRecipe(deps, context, providers, piece) {
                         : await probeDurationMs(deps.ffmpeg, outputPath(deps.paths, context.work.projectId, asset.path), context.signal, deps.log);
             await publishResult(deps, context, piece, [], {
                 text: input.text,
+                ...(input.spokenText === undefined ? {} : { spokenText: input.spokenText }),
                 logicalKey: input.logicalKey,
                 logicalText: input.logicalText,
                 segment: input.segment,
@@ -125,6 +128,18 @@ function checkAnswer(piece, answer) {
     return undefined;
 }
 async function publishText(deps, context, piece, answer) {
+    if (piece.input.kind === "llm" && piece.input.preparation !== undefined) {
+        const checked = validatePreparation(answer.text, piece.input.preparation.source);
+        if (!checked.ok)
+            throw new Error(checked.reason);
+        await publishResult(deps, context, piece, [], {
+            text: answer.text,
+            preparation: piece.input.preparation,
+            cues: checked.cues,
+            logicalFingerprint: piece.logicalFingerprint ?? piece.fingerprint,
+        });
+        return;
+    }
     if (piece.key === "article:body") {
         const parts = splitEndMatter(answer.text);
         await publishResult(deps, context, piece, preparedTexts(deps, context, piece, [
@@ -182,3 +197,17 @@ function narrationLabel(deps, context, piece) {
     const index = parts.findIndex((recipe) => recipe.key === piece.key);
     return parts.length > 1 && index >= 0 ? `${name} part ${index + 1} of ${parts.length}` : name;
 }
+function checkPreparation(deps, context, piece, answer) {
+    if (piece.input.kind !== "llm" || piece.input.preparation === undefined)
+        return undefined;
+    const source = piece.input.preparation.source;
+    const checked = validatePreparation(answer.text, source);
+    if (!checked.ok)
+        return checked.reason;
+    const row = deps.db
+        .prepare("SELECT recipe_context FROM revision_work WHERE id=?")
+        .get(context.work.workId);
+    const model = savedCatalogue(row?.recipe_context).tts.find((model) => model.provider === "inworld" && model.id === "inworld-tts-2");
+    const prepared = prepareRequests(source, checked.cues, model?.tts.maxCharacters ?? 4000);
+    return prepared.ok ? undefined : prepared.reason;
+}

package/dist/slices/rebuild/runtime-publication.js

@@ -80,6 +80,8 @@ export async function publishResult(deps, context, piece, outputs, payload, asse
     }
 }
 function pieceKind(piece) {
+    if (piece.input.kind === "llm" && piece.input.preparation !== undefined)
+        return "prompt_written";
     if (piece.input.kind === "tts")
         return piece.input.segment === "body" ? "chunk" : "segment";
     if (piece.input.kind === "provided" && /^audio:body:.+:\d+$/.test(piece.key))
@@ -97,6 +99,10 @@ function pieceKind(piece) {
     return "article_written";
 }
 function pieceIndex(deps, context, piece) {
+    if (piece.input.kind === "llm" && piece.input.preparation?.segment === "intro")
+        return 1;
+    if (piece.input.kind === "llm" && piece.input.preparation?.segment === "outro")
+        return 2;
     // Intro and outro can resolve independently. Reserve alternating ordinals so a
     // late intro part cannot collide with an outro that was already published.
     const segment = /^audio:(intro|outro):(\d+)$/.exec(piece.key);
@@ -116,6 +122,9 @@ function pieceIndex(deps, context, piece) {
         "subtitles:files",
         "export:wav",
         "export:video",
+        "narration:files:body",
+        "narration:files:intro",
+        "narration:files:outro",
     ];
     const localIndex = localOrder.indexOf(piece.key);
     if (localIndex >= 0)
@@ -126,10 +135,13 @@ function pieceIndex(deps, context, piece) {
         .get(context.work.workId);
     if (view !== undefined && row?.recipe_context !== null && row?.recipe_context !== undefined) {
         const keys = executionPlan(deps, view, savedCatalogue(row.recipe_context)).recipes.filter((recipe) => recipe.stage === context.work.kind &&
+            (piece.input.kind !== "llm" ||
+                piece.input.preparation?.segment !== "body" ||
+                (recipe.input.kind === "llm" && recipe.input.preparation?.segment === "body")) &&
             pieceKind({ ...piece, key: recipe.key, input: recipe.input }) === pieceKind(piece));
         const index = keys.findIndex((recipe) => recipe.key === piece.key);
         if (index >= 0)
-            return index + 1;
+            return (index + (piece.input.kind === "llm" && piece.input.preparation?.segment === "body" ? 3 : 1));
     }
     const last = piece.key.split(":").at(-1);
     return last !== undefined && /^\d+$/.test(last) ? Number(last) : 1;

package/dist/slices/rebuild/runtime-store.js

@@ -26,6 +26,7 @@ export function executionStages(deps, projectId) {
         .prepare("SELECT work_key FROM revision_work_reservations WHERE revision_id=?")
         .all(head)
         .map((row) => String(row.work_key)));
+    const futureKeys = new Map();
     return rows
         .filter((row) => workPieces(deps.db, String(row.id)).some((piece) => {
         if (!keys.has(piece.key))
@@ -33,8 +34,18 @@ export function executionStages(deps, projectId) {
         if (piece.key === "subtitles:timing" && view?.revision.content.subtitleCues !== undefined)
             return false;
         if (piece.input.kind === "deferred" && piece.key.endsWith(":future")) {
-            const prefix = piece.key.slice(0, -"future".length);
-            return !rows.some((candidate) => workPieces(deps.db, String(candidate.id)).some((part) => part.input.kind === "tts" && part.key.startsWith(prefix)));
+            const cacheKey = String(row.id);
+            let deferred = futureKeys.get(cacheKey);
+            if (deferred === undefined) {
+                const origin = executionView(deps, projectId, String(row.revision_id));
+                if (origin === undefined || row.recipe_context === null)
+                    return true;
+                deferred = new Set(executionPlan(deps, origin, savedCatalogue(row.recipe_context))
+                    .recipes.filter((recipe) => recipe.deferred)
+                    .map((recipe) => recipe.key));
+                futureKeys.set(cacheKey, deferred);
+            }
+            return deferred.has(piece.key);
         }
         return true;
     }))

package/dist/slices/revisions/rules.js

@@ -79,9 +79,11 @@ export function validateNarrationIntent(base, edit) {
     });
     const keys = new Set(recipes.flatMap((row) => row.input.kind === "tts"
         ? [row.input.logicalKey]
-        : row.stage === "audio" && row.key.endsWith(":1")
-            ? [row.key.slice(0, -2)]
-            : []));
+        : row.input.kind === "llm" && row.input.preparation !== undefined
+            ? [row.input.preparation.logicalKey]
+            : row.stage === "audio" && row.key.endsWith(":1")
+                ? [row.key.slice(0, -2)]
+                : []));
     const fields = [];
     for (const [key, value] of Object.entries(edit.content.narrationOverrides))
         if (!isDeepStrictEqual(value, base.revision.content.narrationOverrides[key]) && !keys.has(key))

package/dist/slices/settings/cli-paths.js

@@ -13,11 +13,14 @@ const pathSchema = z
     .refine((value) => value === "" || (isAbsolute(value) && !/[\p{Cc}]/u.test(value)));
 const storedPathSchema = z.string().max(cliPathMaxLength).nullable();
 const saves = new WeakMap();
+function installationId(id) {
+    return id === "codex-image" ? "codex" : id;
+}
 export function cliPathStatus(db, id) {
     const provider = providerById(id);
     if (provider.auth !== "cli")
         throw new Error(`${id} is not a CLI provider`);
-    const stored = readSetting(db, `cli.path.${id}`);
+    const stored = readSetting(db, `cli.path.${installationId(id)}`);
     const configured = stored === undefined ? null : storedPathSchema.parse(JSON.parse(stored));
     return { configured, command: configured ?? provider.binary };
 }
@@ -26,22 +29,28 @@ export function cliBinary(db, id) {
     return cliPathStatus(db, id).command;
 }
 export async function saveCliPath(deps, id, raw) {
+    if (deps.hostCliStatus)
+        return {
+            ok: false,
+            message: "CLI paths are managed on the host. Rerun the Docker launcher after changing installations.",
+        };
     // A slow version probe must not overwrite a later Save or Reset from another tab.
     let queue = saves.get(deps.db);
     if (queue === undefined) {
         queue = new Map();
         saves.set(deps.db, queue);
     }
-    const previous = queue.get(id) ?? Promise.resolve();
+    const sharedId = installationId(id);
+    const previous = queue.get(sharedId) ?? Promise.resolve();
     const next = previous.then(() => save(deps, id, raw));
     const settled = next.then(() => { }, () => { });
-    queue.set(id, settled);
+    queue.set(sharedId, settled);
     try {
         return await next;
     }
     finally {
-        if (queue.get(id) === settled)
-            queue.delete(id);
+        if (queue.get(sharedId) === settled)
+            queue.delete(sharedId);
     }
 }
 async function save(deps, id, raw) {
@@ -84,7 +93,7 @@ async function save(deps, id, raw) {
             message: probed.error ??
                 `${provider.displayName} did not answer --version successfully within ${cliProbeTimeoutMs / 1000} seconds. Choose its executable file without arguments.`,
         };
-    writeSetting(deps.db, `cli.path.${id}`, JSON.stringify(configured));
+    writeSetting(deps.db, `cli.path.${installationId(id)}`, JSON.stringify(configured));
     return {
         ok: true,
         status: {

package/dist/slices/settings/cli-status.js

@@ -35,7 +35,7 @@ export function readinessFromProbe(result, provider) {
         return { kind: "cli", installed: false };
     }
     const version = versionFrom(result.stdout);
-    if (provider.id !== "codex")
+    if (provider.id !== "codex" && provider.id !== "codex-image")
         return version === undefined
             ? { kind: "cli", installed: true }
             : { kind: "cli", installed: true, version };
@@ -43,6 +43,7 @@ export function readinessFromProbe(result, provider) {
         return {
             kind: "cli",
             installed: true,
+            issueKind: "version",
             issue: `Slopify could not verify this Codex CLI version. Install Codex CLI ${minimumCodexCliVersion} or newer, then try again.`,
         };
     if (!versionAtLeast(version, minimumCodexCliVersion))
@@ -50,6 +51,7 @@ export function readinessFromProbe(result, provider) {
             kind: "cli",
             installed: true,
             version,
+            issueKind: "version",
             issue: `Codex CLI ${minimumCodexCliVersion} or newer is required; version ${version} is installed. Update Codex CLI and try again.`,
         };
     return { kind: "cli", installed: true, version };

package/dist/slices/settings/model.js

@@ -17,6 +17,7 @@ export const providerIds = [
     "replicate",
     "openai-image",
     "google-image",
+    "codex-image",
 ];
 export function isLocalCliProvider(id) {
     return id === "claude-code" || id === "codex" || id === "gemini" || id === "codex-image";
@@ -55,6 +56,14 @@ export const providers = [
     { id: "replicate", family: "image", displayName: "Replicate", auth: "key" },
     { id: "openai-image", family: "image", displayName: "OpenAI", auth: "key" },
     { id: "google-image", family: "image", displayName: "Google", auth: "key" },
+    {
+        id: "codex-image",
+        family: "image",
+        displayName: "Codex CLI",
+        auth: "cli",
+        binary: "codex",
+        versionArgs: ["--version"],
+    },
 ];
 export function providerById(id) {
     const found = providers.find((provider) => provider.id === id);

package/dist/slices/settings/readiness.js

@@ -1,21 +1,42 @@
 import { cliPathStatus } from "./cli-paths.js";
-import { cliReadiness } from "./cli-status.js";
-import { providers } from "./model.js";
+import { cliProbeTimeoutMs, readinessFromProbe } from "./cli-status.js";
+import { isLocalCliProvider, providers } from "./model.js";
 import { keyedProviders } from "./repo.js";
 // Every supported provider is listed, keyed or not, found or not, so Play can grey one out with
 // a reason instead of hiding it. A keyed provider is ready when a key is stored; a CLI provider
 // when its binary answers. Readiness is computed per request using the latest saved executable override.
 export async function providerStatuses(deps) {
     const keyed = keyedProviders(deps.db);
+    const probes = new Map();
     return await Promise.all(providers.map(async (provider) => {
         const base = { id: provider.id, family: provider.family, displayName: provider.displayName };
         if (provider.auth !== "cli")
             return { ...base, readiness: keyedReadiness(keyed, provider.id) };
+        if (deps.hostCliStatus && isLocalCliProvider(provider.id)) {
+            const status = await deps.hostCliStatus(provider.id);
+            return {
+                ...base,
+                cliPath: { configured: null, command: status.command, managedOnHost: true },
+                readiness: {
+                    kind: "cli",
+                    installed: status.installed,
+                    ...(status.version === undefined ? {} : { version: status.version }),
+                    ...(status.issueKind === undefined ? {} : { issueKind: status.issueKind }),
+                    ...(status.issue === undefined ? {} : { issue: status.issue }),
+                },
+            };
+        }
         const cliPath = cliPathStatus(deps.db, provider.id);
+        const probeKey = JSON.stringify([cliPath.command, provider.versionArgs]);
+        let result = probes.get(probeKey);
+        if (result === undefined) {
+            result = deps.probe(cliPath.command, provider.versionArgs, cliProbeTimeoutMs);
+            probes.set(probeKey, result);
+        }
         return {
             ...base,
             cliPath,
-            readiness: await cliReadiness(deps.probe, { ...provider, binary: cliPath.command }),
+            readiness: readinessFromProbe(await result, provider),
         };
     }));
 }

package/dist/slices/storage/asset-name.js

@@ -7,6 +7,9 @@
 // research and the article each store what they sent.
 export function assetOf(output) {
     const asset = output.role.replaceAll("_", "-");
+    if ((output.role === "narration_txt" || output.role === "tts_script") &&
+        output.meta.segment !== undefined)
+        return `${asset}-${output.meta.segment}`;
     if (output.role === "instructions") {
         return `${output.stageKind}-${asset}`;
     }

package/dist/slices/storage/layout.js

@@ -30,6 +30,10 @@ export function outputFileName(role, index, extension, stageKind) {
             return "article.md";
         case "article_txt":
             return "article.txt";
+        case "narration_txt":
+            return "narration.txt";
+        case "tts_script":
+            return "tts-script.txt";
         case "sources":
             return "sources.txt";
         case "glossary":

package/dist/slices/storage/model.js

@@ -6,6 +6,8 @@ export const outputRoles = [
     "notes",
     "article_md",
     "article_txt",
+    "narration_txt",
+    "tts_script",
     "sources",
     "glossary",
     "audio_body",

package/dist/slices/storage/schema.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { outputRoles, stagedFileStates, stageKinds } from "./model.js";
 export const metaSchema = z.object({
+    segment: z.enum(["body", "intro", "outro"]).optional(),
     subtitleOmissions: z
         .array(z.object({ start: z.number().finite().nonnegative(), text: z.string() }))
         .optional(),