@gentbajko/slopify 0.5.1 → 0.6.1

package/dist/adapters/alignment/text.js

@@ -0,0 +1,61 @@
+import { cardinal, numberForms } from "./numbers.js";
+// Original display words remain intact; only acoustic matching uses normalized English.
+export function speechWords(text, observed = "") {
+    const words = [];
+    for (const textWord of text.trim().split(/\s+/)) {
+        const forms = wordForms(textWord);
+        const spoken = forms.find((form) => form !== "" && ` ${observed} `.includes(` ${form} `)) ?? forms[0] ?? "";
+        if (spoken === "") {
+            const previous = words.at(-1);
+            if (previous !== undefined)
+                previous.text += ` ${textWord}`;
+            continue;
+        }
+        words.push({ text: textWord, spoken });
+    }
+    if (words.length === 0)
+        throw new Error("Local subtitles currently require an English transcript with spoken words.");
+    return words;
+}
+function wordForms(raw) {
+    const plain = raw.normalize("NFKD").replace(/\p{M}/gu, "").replace(/[‘’]/g, "'");
+    if (/\p{L}/u.test(plain.replace(/[A-Za-z]/g, "")))
+        throw new Error("Local subtitles currently support English speech and Latin-script names only.");
+    const core = plain.replace(/^[^\p{L}\p{N}$£€]+|[^\p{L}\p{N}%]+$/gu, "");
+    if (core === "")
+        return [];
+    const currency = core.startsWith("$")
+        ? "DOLLARS"
+        : core.startsWith("£")
+            ? "POUNDS"
+            : core.startsWith("€")
+                ? "EUROS"
+                : "";
+    const percent = core.endsWith("%") ? "PERCENT" : "";
+    const clean = core.replace(/^[$£€]/, "").replace(/%$/, "");
+    let forms;
+    if (/^\d[\d,.]*(?:s|st|nd|rd|th)?$/i.test(clean)) {
+        forms = numberForms(clean);
+    }
+    else {
+        const expanded = clean
+            .replaceAll("&", " AND ")
+            .replaceAll("+", " PLUS ")
+            .replace(/\d+/g, (digits) => numberForms(digits)[0] ?? digits);
+        const normal = expanded
+            .toUpperCase()
+            .replace(/[^A-Z']/g, " ")
+            .replace(/\s+/g, " ")
+            .trim();
+        forms = /^[A-Z]{2,8}$/.test(clean) ? [normal, clean.split("").join(" ")] : [normal];
+    }
+    const result = forms.map((form) => [form, currency, percent].filter(Boolean).join(" "));
+    const money = /^(\d[\d,]*)\.(\d{2})$/.exec(clean);
+    if (currency !== "" && money !== null) {
+        const whole = cardinal(Number((money[1] ?? "").replaceAll(",", "")));
+        const fraction = cardinal(Number(money[2]));
+        const unit = currency === "POUNDS" ? "PENCE" : "CENTS";
+        result.push(`${whole} ${currency} AND ${fraction} ${unit}`, `${whole} ${currency} ${fraction}`, `${whole} ${fraction}`);
+    }
+    return result;
+}

package/dist/adapters/alignment/vocabulary.js

@@ -0,0 +1,69 @@
+// The vocabulary belongs to the pinned wav2vec2-base-960h model.
+export const vocabulary = {
+    "<pad>": 0,
+    "<s>": 1,
+    "</s>": 2,
+    "<unk>": 3,
+    "|": 4,
+    E: 5,
+    T: 6,
+    A: 7,
+    O: 8,
+    N: 9,
+    I: 10,
+    H: 11,
+    S: 12,
+    R: 13,
+    D: 14,
+    L: 15,
+    U: 16,
+    M: 17,
+    W: 18,
+    C: 19,
+    F: 20,
+    G: 21,
+    Y: 22,
+    P: 23,
+    B: 24,
+    V: 25,
+    K: 26,
+    "'": 27,
+    X: 28,
+    J: 29,
+    Q: 30,
+    Z: 31,
+};
+export const letters = [
+    "",
+    "",
+    "",
+    "",
+    " ",
+    "E",
+    "T",
+    "A",
+    "O",
+    "N",
+    "I",
+    "H",
+    "S",
+    "R",
+    "D",
+    "L",
+    "U",
+    "M",
+    "W",
+    "C",
+    "F",
+    "G",
+    "Y",
+    "P",
+    "B",
+    "V",
+    "K",
+    "'",
+    "X",
+    "J",
+    "Q",
+    "Z",
+];

package/dist/adapters/alignment/worker.js

@@ -0,0 +1,163 @@
+import { open, readFile, stat } from "node:fs/promises";
+import * as ort from "onnxruntime-web/wasm";
+import { alignWindow, frameSeconds, mismatch } from "./ctc.js";
+import { workerInput } from "./protocol.js";
+import { agreesWithSpeech } from "./quality.js";
+import { speechWords } from "./text.js";
+import { letters } from "./vocabulary.js";
+const sampleRate = 16000;
+const windowSeconds = 12;
+const overlapSeconds = 2;
+process.once("message", (raw) => {
+    const input = workerInput.safeParse(raw);
+    if (!input.success) {
+        send({ type: "error", message: "The subtitle worker received an invalid request." });
+        return;
+    }
+    run(input.data).then((words) => send({ type: "done", words }), (error) => send({ type: "error", message: error instanceof Error ? error.message : String(error) }));
+});
+function send(message) {
+    process.send?.(message);
+}
+async function run(input) {
+    ort.env.wasm.numThreads = 1;
+    const model = new Uint8Array(await readFile(input.modelPath));
+    const session = await ort.InferenceSession.create(model, { executionProviders: ["wasm"] });
+    const file = await open(input.pcmPath, "r");
+    try {
+        const totalSamples = (await stat(input.pcmPath)).size / 4;
+        if (!Number.isInteger(totalSamples) || totalSamples < sampleRate / 10)
+            throw new Error("The narration is too short to align subtitles.");
+        const source = speechWords(input.text);
+        const output = [];
+        let cursor = 0;
+        let sampleAt = 0;
+        while (sampleAt < totalSamples && cursor < source.length) {
+            const count = Math.min(windowSeconds * sampleRate, totalSamples - sampleAt);
+            const buffer = Buffer.alloc(count * 4);
+            await file.read(buffer, 0, buffer.length, sampleAt * 4);
+            const audio = new Float32Array(buffer.buffer, buffer.byteOffset, count);
+            const normalized = normalize(audio);
+            if (normalized === undefined) {
+                sampleAt += count;
+                continue;
+            }
+            const result = await session.run({
+                input_values: new ort.Tensor("float32", normalized, [1, count]),
+            });
+            const logits = result.logits;
+            if (logits === undefined ||
+                !(logits.data instanceof Float32Array) ||
+                logits.dims.length !== 3 ||
+                logits.dims[2] !== 32)
+                throw new Error("The local subtitle model returned an unsupported result.");
+            const frames = logits.dims[1] ?? 0;
+            const observed = greedy(logits.data, frames);
+            if (observed.replace(/[^A-Z]/g, "").length === 0) {
+                sampleAt += count;
+                for (const tensor of Object.values(result))
+                    tensor.dispose();
+                continue;
+            }
+            const candidate = candidates(source, cursor, observed);
+            const finalWindow = sampleAt + count >= totalSamples;
+            const complete = finalWindow && cursor + candidate.length === source.length;
+            const aligned = alignWindow(logits.data, frames, candidate, complete).words;
+            const cutoff = finalWindow ? count / sampleRate : count / sampleRate - overlapSeconds;
+            const accepted = aligned.filter((word) => word.end <= cutoff);
+            const last = accepted.at(-1);
+            if (last === undefined)
+                throw new Error(mismatch);
+            const heard = greedy(logits.data, Math.min(frames, Math.ceil(last.end / frameSeconds)));
+            if (!agreesWithSpeech(candidate
+                .slice(0, accepted.length)
+                .map((word) => word.spoken)
+                .join(" "), heard))
+                throw new Error(mismatch);
+            const offset = sampleAt / sampleRate;
+            output.push(...accepted.map((word) => ({
+                ...word,
+                start: offset + word.start,
+                end: offset + word.end,
+            })));
+            cursor += accepted.length;
+            send({ type: "progress", current: cursor, total: source.length });
+            // Keep a small leading silence margin but never re-use speech already captioned.
+            sampleAt += Math.max(1, Math.floor(last.end * sampleRate));
+            for (const tensor of Object.values(result))
+                tensor.dispose();
+        }
+        if (cursor !== source.length || output.length === 0)
+            throw new Error(mismatch);
+        // A substantial spoken tail absent from the transcript is a mismatch too.
+        while (sampleAt + sampleRate < totalSamples) {
+            const count = Math.min(windowSeconds * sampleRate, totalSamples - sampleAt);
+            const buffer = Buffer.alloc(count * 4);
+            await file.read(buffer, 0, buffer.length, sampleAt * 4);
+            const audio = normalize(new Float32Array(buffer.buffer, buffer.byteOffset, count));
+            if (audio !== undefined) {
+                const result = await session.run({
+                    input_values: new ort.Tensor("float32", audio, [1, count]),
+                });
+                const logits = result.logits;
+                if (logits !== undefined &&
+                    logits.data instanceof Float32Array &&
+                    greedy(logits.data, logits.dims[1] ?? 0).replace(/[^A-Z]/g, "").length > 8)
+                    throw new Error(mismatch);
+                for (const tensor of Object.values(result))
+                    tensor.dispose();
+            }
+            sampleAt += count;
+        }
+        return output;
+    }
+    finally {
+        await file.close();
+        await session.release();
+    }
+}
+function candidates(source, cursor, observed) {
+    const selected = [];
+    let length = 0;
+    for (let index = cursor; index < source.length; index += 1) {
+        const word = source[index];
+        if (word === undefined)
+            break;
+        const normalized = speechWords(word.text, observed)[0];
+        if (normalized === undefined)
+            continue;
+        if (length + normalized.spoken.length + 1 > 900)
+            break;
+        selected.push(normalized);
+        length += normalized.spoken.length + 1;
+    }
+    return selected;
+}
+function normalize(audio) {
+    let mean = 0;
+    for (const value of audio)
+        mean += value;
+    mean /= audio.length;
+    let variance = 0;
+    for (const value of audio)
+        variance += (value - mean) ** 2;
+    variance /= audio.length;
+    if (variance < 1e-10)
+        return undefined;
+    const divisor = Math.sqrt(variance + 1e-7);
+    return Float32Array.from(audio, (value) => (value - mean) / divisor);
+}
+function greedy(logits, frames) {
+    let previous = -1;
+    let text = "";
+    for (let frame = 0; frame < frames; frame += 1) {
+        let best = 0;
+        for (let label = 1; label < 32; label += 1)
+            if ((logits[frame * 32 + label] ?? -Infinity) > (logits[frame * 32 + best] ?? -Infinity))
+                best = label;
+        if (best !== previous && best !== 0)
+            text += letters[best] ?? "";
+        previous = best;
+    }
+    return text.trim().replace(/\s+/g, " ");
+}

package/dist/adapters/llm/claude-code.js

@@ -37,6 +37,7 @@ export function claudeCodeArgs(req) {
         "stream-json",
         // stream-json output is refused without it.
         "--verbose",
+        "--include-partial-messages",
         // `claude --help` 2.1.263: safe mode excludes CLAUDE.md, output styles, skills and
         // hooks while retaining login and managed policy. --bare would discard OAuth.
         "--safe-mode",
@@ -82,6 +83,10 @@ export function claudeCodeLlm(deps) {
                     continue;
                 }
                 const event = cliEvent(binary, line);
+                // Partial text/thinking and tool events are a heartbeat. Full assistant
+                // messages remain the sole prose source so text is never appended twice.
+                yield { type: "activity" };
+                req.signal.throwIfAborted();
                 if (event.type === "assistant") {
                     for (const block of cliShaped(binary, assistantEvent, event.value).message.content) {
                         // A turn also carries `thinking` and `tool_use` blocks; only the prose is the
@@ -133,9 +138,7 @@ export function claudeCodeLlm(deps) {
     }
     return {
         id: "claude-code",
-        // Whole assistant turns rather than token deltas, still enough for the idle timeout to
-        // see life on the stream. ceiling: `--include-partial-messages` would give per-token
-        // deltas for the streamed article; it is the upgrade when the page needs finer text.
+        // Partial messages keep the deadline alive; complete assistant turns supply prose.
         capabilities: { streams: true, reportsUsage: true, webSearch: true },
         models: () => Promise.resolve(claudeCodeModels),
         complete,

package/dist/adapters/llm/codex.js

@@ -59,6 +59,8 @@ export function codexLlm(deps) {
                     continue;
                 }
                 const event = cliEvent(binary, line);
+                yield { type: "activity" };
+                req.signal.throwIfAborted();
                 if (event.type === "item.completed") {
                     const { item } = cliShaped(binary, itemCompleted, event.value);
                     // A turn also completes `reasoning`, `web_search`, `command_execution` and
@@ -111,8 +113,7 @@ export function codexLlm(deps) {
     }
     return {
         id: "codex",
-        // ceiling: one `item.completed` per whole message rather than per token, same as the
-        // other CLI. Enough for the idle timeout to see life on the stream.
+        // Prose arrives as whole messages; other JSONL events carry activity separately.
         capabilities: { streams: true, reportsUsage: true, webSearch: true },
         models: () => Promise.resolve(codexModels),
         complete,

package/dist/adapters/llm/gemini-workspace.js

@@ -0,0 +1,70 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+// Gemini 0.16 supports stream-json and tools.core, but headless default mode still
+// exposes file-reading tools. Isolate each writing call while retaining ~/.gemini
+// authentication. Nothing is written into the user's settings or project.
+export function geminiWorkspace(webSearch) {
+    const directory = mkdtempSync(join(tmpdir(), "slopify-gemini-"));
+    try {
+        const settings = join(directory, "settings.json");
+        const system = join(directory, "writing.md");
+        const trust = join(directory, "trusted-folders.json");
+        const mcpAllowlist = `slopify-disabled-${directory.split(/[\\/]/).at(-1)}`;
+        writeFileSync(settings, JSON.stringify({
+            tools: {
+                core: webSearch ? ["google_web_search"] : [],
+                allowed: webSearch ? ["google_web_search"] : [],
+                discoveryCommand: "",
+                callCommand: "",
+                enableHooks: false,
+            },
+            mcp: { allowed: [mcpAllowlist], serverCommand: "" },
+            context: {
+                fileName: "SLOPIFY_NO_CONTEXT.md",
+                includeDirectories: [],
+                loadMemoryFromIncludeDirectories: false,
+            },
+            experimental: { codebaseInvestigatorSettings: { enabled: false } },
+            hooks: { enabled: false },
+            skills: { enabled: false },
+            ide: { enabled: false },
+            telemetry: { enabled: false },
+            privacy: { usageStatisticsEnabled: false },
+            advanced: { autoConfigureMemory: false },
+        }), { mode: 0o600 });
+        writeFileSync(system, "You are the writing and research component of Slopify, a video creation app. " +
+            "Write the requested articles, narration, research notes or image prompts. " +
+            "Follow the topic, language, tone, length and format. Return only the requested content. " +
+            "Use web search only when available and useful. Never read or modify local files. " +
+            "A backslash immediately before @ escapes a literal @ in the supplied text.\n", { mode: 0o600 });
+        // Gemini CONCAT-merges includeDirectories (even a null value). Reset the
+        // whole context object at workspace scope before the system context above.
+        // Trust only this new private workspace, leaving the user's trust file untouched.
+        mkdirSync(join(directory, ".gemini"), { mode: 0o700 });
+        writeFileSync(join(directory, ".gemini", "settings.json"), JSON.stringify({ context: null }), {
+            mode: 0o600,
+        });
+        writeFileSync(trust, JSON.stringify({ [directory]: "TRUST_FOLDER" }), { mode: 0o600 });
+        return {
+            mcpAllowlist,
+            options: {
+                cwd: directory,
+                env: {
+                    ...process.env,
+                    GEMINI_CLI_SYSTEM_SETTINGS_PATH: settings,
+                    GEMINI_CLI_TRUSTED_FOLDERS_PATH: trust,
+                    NO_BROWSER: "true",
+                    GEMINI_SYSTEM_MD: system,
+                    GEMINI_WRITE_SYSTEM_MD: "false",
+                    GEMINI_CLI_NO_RELAUNCH: "true",
+                },
+            },
+            remove: () => rmSync(directory, { recursive: true, force: true }),
+        };
+    }
+    catch (error) {
+        rmSync(directory, { recursive: true, force: true });
+        throw error;
+    }
+}

package/dist/adapters/llm/gemini.js

@@ -0,0 +1,141 @@
+import { z } from "zod";
+import { redact } from "../../kernel/log.js";
+import { providerError } from "../../kernel/ports/model.js";
+import { geminiWorkspace } from "./gemini-workspace.js";
+import { cliEvent, cliShaped, endedWithout, promptOf } from "./run-cli.js";
+import { lines } from "./sse-lines.js";
+export const geminiBinary = "gemini";
+export const geminiModels = [
+    { id: "gemini-2.5-pro", name: "Gemini 2.5 Pro" },
+    { id: "gemini-2.5-flash", name: "Gemini 2.5 Flash" },
+    { id: "gemini-2.5-flash-lite", name: "Gemini 2.5 Flash-Lite" },
+];
+// Verified against installed Gemini CLI 0.16.0's config/nonInteractiveCli sources.
+// Its --allowed-tools flag bypasses approval; tools.core in the isolated settings
+// actually restricts discovery. Never request yolo/auto_edit.
+export function geminiArgs(req, mcpAllowlist) {
+    return [
+        "--output-format",
+        "stream-json",
+        "--approval-mode",
+        "default",
+        "--extensions",
+        "none",
+        "--allowed-mcp-server-names",
+        mcpAllowlist,
+        ...(req.webSearch === true ? ["--allowed-tools", "google_web_search"] : []),
+        ...(req.model === "" ? [] : ["--model", req.model]),
+        "-p",
+        // The prefix prevents slash-command dispatch; escaping @ prevents Gemini's
+        // input preprocessor from reading files even when read tools are disabled.
+        `Produce the requested content from this conversation:\n\n${promptOf(req.messages).replaceAll("@", "\\@")}`,
+    ];
+}
+const messageSchema = z.object({
+    role: z.string(),
+    content: z.string(),
+    delta: z.boolean().optional(),
+});
+const errorSchema = z.object({ severity: z.string(), message: z.string() });
+const resultSchema = z.object({
+    status: z.string(),
+    error: z.object({ message: z.string(), type: z.string().optional() }).optional(),
+    stats: z.object({ input_tokens: z.number(), output_tokens: z.number() }).optional(),
+});
+export function geminiLlm(deps) {
+    const binary = deps.binary ?? geminiBinary;
+    async function* complete(req) {
+        req.signal.throwIfAborted();
+        const workspace = geminiWorkspace(req.webSearch === true);
+        let run;
+        try {
+            run = deps.run(binary, geminiArgs(req, workspace.mcpAllowlist), req.signal, workspace.options);
+            for await (const line of lines(authChecked(run.stdout), req.signal)) {
+                if (line.trim() === "")
+                    continue;
+                const event = cliEvent(binary, line);
+                yield { type: "activity" };
+                req.signal.throwIfAborted();
+                if (event.type === "message") {
+                    const message = cliShaped(binary, messageSchema, event.value);
+                    if (message.role === "assistant" && message.content !== "")
+                        yield { type: "delta", text: message.content };
+                }
+                else if (event.type === "error") {
+                    const error = cliShaped(binary, errorSchema, event.value);
+                    if (error.severity !== "warning")
+                        throw failure(error.message);
+                }
+                else if (event.type === "result") {
+                    const result = cliShaped(binary, resultSchema, event.value);
+                    if (result.status !== "success")
+                        throw failure(result.error?.message ?? result.status);
+                    yield {
+                        type: "done",
+                        usage: result.stats === undefined
+                            ? null
+                            : {
+                                inputTokens: result.stats.input_tokens,
+                                outputTokens: result.stats.output_tokens,
+                            },
+                        finishReason: null,
+                    };
+                    return;
+                }
+            }
+            req.signal.throwIfAborted();
+            const ended = await run.ended;
+            if (authRequired(run.stderr()))
+                throw authFailure();
+            throw failure(endedWithout(binary, ended, run.stderr()));
+        }
+        catch (error) {
+            req.signal.throwIfAborted();
+            throw error;
+        }
+        finally {
+            run?.kill();
+            if (run !== undefined)
+                await run.ended;
+            workspace.remove();
+        }
+    }
+    return {
+        id: "gemini",
+        capabilities: { streams: true, reportsUsage: true, webSearch: true },
+        models: () => Promise.resolve(geminiModels),
+        complete,
+    };
+}
+function failure(message) {
+    if (/(?:#?3501\b|do not have a valid licen[cs]e of this product)/i.test(message)) {
+        return providerError({
+            kind: "unsupported",
+            message: "Gemini CLI access was denied by Google's license check (#3501). Update Gemini CLI and sign in again. For a managed account, contact your administrator to request a license.",
+        });
+    }
+    return authRequired(message)
+        ? authFailure()
+        : providerError({ kind: "other", message: redact(message) });
+}
+function authRequired(message) {
+    return /Code Assist login required|authorize the application|authorization code|Please set an Auth method|re-authenticate|reauthenticate/i.test(message);
+}
+function authFailure() {
+    return providerError({
+        kind: "missing_key",
+        message: "Gemini CLI needs sign-in. Run gemini in your terminal, complete login, then retry in Slopify.",
+    });
+}
+async function* authChecked(source) {
+    const decoder = new TextDecoder();
+    let tail = "";
+    for await (const bytes of source) {
+        tail = (tail + decoder.decode(bytes, { stream: true })).slice(-8192);
+        // NO_BROWSER prevents opening OAuth. A logged-out CLI instead writes this
+        // non-JSON prompt without a newline; fail before lines() waits for user input.
+        if (/^(?:Enter the authorization code:|Please visit the following URL to authorize)/m.test(tail))
+            throw authFailure();
+        yield bytes;
+    }
+}

package/dist/adapters/llm/run-cli.js

@@ -1,5 +1,6 @@
 import { spawn } from "node:child_process";
 import { z } from "zod";
+import { cliCommand } from "../../kernel/cli-command.js";
 import { redact } from "../../kernel/log.js";
 import { providerError } from "../../kernel/ports/model.js";
 // ceiling: the last 8 KiB of stderr is kept. A CLI that writes megabytes of progress there
@@ -7,16 +8,18 @@ import { providerError } from "../../kernel/ports/model.js";
 // says why it stopped. Streaming stderr to the log is the upgrade if a provider ever
 // buries its reason in the first line of a long report.
 export const stderrMax = 8192;
-export function nodeRunCli(binary, args, signal) {
+export function nodeRunCli(binary, args, signal, options) {
     // An argument array, never a shell string: a prompt carrying backticks, `$(...)`, quotes or
     // newlines is one argv element and nothing in it can become a command. stdin is /dev/null
     // because `codex exec` appends piped stdin to the prompt, and a pipe nobody closes would
     // leave it waiting for an EOF that never comes. `signal` is how the child dies: Node sends it
     // SIGTERM when the stage is cancelled, so no agent session outlives the run that started it.
-    const child = spawn(binary, [...args], {
+    const command = cliCommand(binary);
+    const child = spawn(command.file, [...command.args, ...args], {
         signal,
         stdio: ["ignore", "pipe", "pipe"],
         windowsHide: true,
+        ...options,
     });
     let stderr = "";
     const errorStream = child.stderr;
@@ -38,13 +41,7 @@ export function nodeRunCli(binary, args, signal) {
             resolve({ code, error: spawnError });
         };
         child.once("close", settle);
-        // `close` follows `error` when the streams were opened; this is the belt for the case
-        // where they were not.
-        child.once("error", () => {
-            setImmediate(() => {
-                settle(null);
-            });
-        });
+        // Close follows an error too; waiting for it keeps cleanup behind process exit.
     });
     return {
         pid: child.pid,