@gentbajko/slopify 2.4.0 → 3.0.0

package/dist/slices/run-cost/panel.js

@@ -0,0 +1,234 @@
+import { z } from "zod";
+import { stageKinds } from "../../kernel/pipeline.js";
+import { planAccountNames, planAccountOf, planAccounts, } from "../../kernel/ports/plan-limits.js";
+const usageRow = z.object({
+    stage: z.enum(stageKinds),
+    kind: z.enum(["llm", "tts", "image", "video"]),
+    provider: z.string(),
+    model: z.string(),
+    tokens_in: z.number().nullable(),
+    tokens_out: z.number().nullable(),
+    tokens_cached: z.number().nullable(),
+    characters: z.number().nullable(),
+    images: z.number().nullable(),
+    seconds: z.number().nullable(),
+    on_plan: z.number(),
+    cost: z.number().nullable(),
+    api_model: z.string().nullable(),
+    api_cost: z.number().nullable(),
+    price_json: z.string().nullable(),
+});
+const windowSchema = z.object({
+    kind: z.enum(["five_hour", "weekly", "other"]),
+    usedPercent: z.number(),
+    resetsAt: z.string().nullable(),
+});
+const readingSchema = z.object({
+    before: z.array(windowSchema).optional(),
+    after: z.array(windowSchema).optional(),
+});
+const emptyTotals = {
+    tokensIn: 0,
+    tokensOut: 0,
+    cachedTokens: 0,
+    characters: 0,
+    images: 0,
+    seconds: 0,
+};
+const emptyLine = {
+    calls: 0,
+    cost: 0,
+    unpriced: 0,
+    apiEquivalent: null,
+    apiUnpriced: 0,
+};
+function add(into, row) {
+    const onPlan = row.on_plan === 1;
+    return {
+        ...into,
+        calls: into.calls + 1,
+        cost: into.cost + (row.cost ?? 0),
+        unpriced: into.unpriced + (row.cost === null ? 1 : 0),
+        apiEquivalent: onPlan ? (into.apiEquivalent ?? 0) + (row.api_cost ?? 0) : into.apiEquivalent,
+        apiUnpriced: into.apiUnpriced + (onPlan && row.api_cost === null ? 1 : 0),
+        tokensIn: into.tokensIn + (row.tokens_in ?? 0),
+        tokensOut: into.tokensOut + (row.tokens_out ?? 0),
+        cachedTokens: into.cachedTokens + (row.tokens_cached ?? 0),
+        characters: into.characters + (row.characters ?? 0),
+        images: into.images + (row.images ?? 0),
+        seconds: into.seconds + (row.seconds ?? 0),
+    };
+}
+export function runCostOf(db, projectId) {
+    const rows = db
+        .prepare("SELECT stage, kind, provider, model, tokens_in, tokens_out, tokens_cached, characters, images, seconds, on_plan, cost, api_model, api_cost, price_json FROM provider_usage WHERE project_id = ? ORDER BY created_at, rowid")
+        .all(projectId)
+        .map((row) => usageRow.parse(row));
+    const walls = stageWalls(db, projectId);
+    const stages = new Map();
+    const models = new Map();
+    let total = { ...emptyLine, ...emptyTotals };
+    let catalogueDate = null;
+    for (const row of rows) {
+        total = add(total, row);
+        stages.set(row.stage, add(stages.get(row.stage) ?? {
+            stage: row.stage,
+            wallMs: walls.get(row.stage) ?? null,
+            ...emptyLine,
+            ...emptyTotals,
+        }, row));
+        const key = JSON.stringify([row.provider, row.model, row.kind]);
+        models.set(key, add(models.get(key) ?? {
+            provider: row.provider,
+            model: row.model,
+            kind: row.kind,
+            onPlan: row.on_plan === 1,
+            apiModel: row.api_model,
+            ...emptyLine,
+            ...emptyTotals,
+        }, row));
+        catalogueDate = catalogueOf(row.price_json) ?? catalogueDate;
+    }
+    // A stage that ran with no provider call (a render, a document) still has its time.
+    for (const [stage, wallMs] of walls)
+        if (!stages.has(stage))
+            stages.set(stage, { stage, wallMs, ...emptyLine, ...emptyTotals });
+    const plans = planUses(db, projectId, rows);
+    return {
+        currency: "USD",
+        ...total,
+        totals: {
+            tokensIn: total.tokensIn,
+            tokensOut: total.tokensOut,
+            cachedTokens: total.cachedTokens,
+            characters: total.characters,
+            images: total.images,
+            seconds: total.seconds,
+            wallMs: [...walls.values()].reduce((sum, ms) => sum + ms, 0),
+        },
+        byStage: stageKinds.flatMap((kind) => {
+            const found = stages.get(kind);
+            return found === undefined ? [] : [found];
+        }),
+        byModel: [...models.values()].toSorted((left, right) => right.cost - left.cost ||
+            (right.apiEquivalent ?? 0) - (left.apiEquivalent ?? 0) ||
+            left.provider.localeCompare(right.provider) ||
+            left.model.localeCompare(right.model)),
+        plans,
+        waits: limitWaitsOf(db, projectId),
+        catalogueDate,
+    };
+}
+function catalogueOf(json) {
+    if (json === null)
+        return null;
+    const parsed = z.object({ catalogue: z.string() }).safeParse(JSON.parse(json));
+    return parsed.success ? parsed.data.catalogue : null;
+}
+function stageWalls(db, projectId) {
+    const walls = new Map();
+    for (const raw of db
+        .prepare("SELECT kind, started_at, finished_at FROM stages WHERE project_id = ?")
+        .all(projectId)) {
+        const row = z
+            .object({
+            kind: z.enum(stageKinds),
+            started_at: z.string().nullable(),
+            finished_at: z.string().nullable(),
+        })
+            .parse(raw);
+        if (row.started_at === null || row.finished_at === null)
+            continue;
+        const ms = Date.parse(row.finished_at) - Date.parse(row.started_at);
+        if (Number.isFinite(ms) && ms >= 0)
+            walls.set(row.kind, ms);
+    }
+    return walls;
+}
+// Two readings belong to the same window when their resets agree to within a few minutes;
+// a reset moving on means the window rolled over between them.
+const sameWindowMs = 5 * 60_000;
+export function windowUse(readings) {
+    const byKind = new Map();
+    for (const reading of readings)
+        for (const window of reading)
+            byKind.set(window.kind, [...(byKind.get(window.kind) ?? []), window]);
+    const uses = [];
+    for (const [kind, seen] of byKind) {
+        let used = 0;
+        for (let at = 1; at < seen.length; at += 1) {
+            const previous = seen[at - 1];
+            const current = seen[at];
+            if (previous === undefined || current === undefined)
+                continue;
+            const same = previous.resetsAt === current.resetsAt ||
+                (previous.resetsAt !== null &&
+                    current.resetsAt !== null &&
+                    Math.abs(Date.parse(previous.resetsAt) - Date.parse(current.resetsAt)) < sameWindowMs);
+            used += same ? Math.max(0, current.usedPercent - previous.usedPercent) : current.usedPercent;
+        }
+        const last = seen.at(-1);
+        if (last !== undefined)
+            uses.push({ kind, usedPercent: used, nowPercent: last.usedPercent, resetsAt: last.resetsAt });
+    }
+    const order = ["five_hour", "weekly", "other"];
+    return uses.toSorted((left, right) => order.indexOf(left.kind) - order.indexOf(right.kind));
+}
+function planUses(db, projectId, rows) {
+    const readings = db
+        .prepare("SELECT account, reading_json FROM plan_limit_readings WHERE project_id = ? ORDER BY created_at, rowid")
+        .all(projectId)
+        .map((row) => z.object({ account: z.string(), reading_json: z.string() }).parse(row));
+    return planAccounts.flatMap((account) => {
+        const calls = rows.filter((row) => planAccountOf(row.provider) === account).length;
+        if (calls === 0)
+            return [];
+        const sequence = [];
+        for (const row of readings) {
+            if (row.account !== account)
+                continue;
+            const parsed = readingSchema.safeParse(JSON.parse(row.reading_json));
+            if (!parsed.success)
+                continue;
+            if (parsed.data.before?.length)
+                sequence.push(parsed.data.before);
+            if (parsed.data.after?.length)
+                sequence.push(parsed.data.after);
+        }
+        return [
+            {
+                account,
+                name: planAccountNames[account],
+                calls,
+                reported: sequence.length > 0,
+                windows: windowUse(sequence),
+            },
+        ];
+    });
+}
+export function limitWaitsOf(db, projectId) {
+    // Only a stage still running is waiting: a row left by a cancel or pause is not shown.
+    return db
+        .prepare(`SELECT w.account, w.stage, l.resets_at, l.retry_at FROM plan_limit_waiters w
+       JOIN plan_limit_waits l ON l.account = w.account
+       JOIN stages s ON s.project_id = w.project_id AND s.kind = w.stage AND s.state = 'running'
+       WHERE w.project_id = ? ORDER BY w.since`)
+        .all(projectId)
+        .map((raw) => {
+        const row = z
+            .object({
+            account: z.enum(planAccounts),
+            stage: z.enum(stageKinds),
+            resets_at: z.string().nullable(),
+            retry_at: z.string(),
+        })
+            .parse(raw);
+        return {
+            account: row.account,
+            name: planAccountNames[row.account],
+            stage: row.stage,
+            resetsAt: row.resets_at,
+            retryAt: row.retry_at,
+        };
+    });
+}

package/dist/slices/run-cost/pricing.js

@@ -0,0 +1,92 @@
+import { isLocalCliProvider } from "../settings/model.js";
+// Per million tokens; cached input at its own rate when the catalogue gives one.
+export function tokenCost(rates, tokensIn, tokensOut, cachedTokens = 0) {
+    if (rates.inputPerMillionTokens === undefined || rates.outputPerMillionTokens === undefined)
+        return null;
+    const cached = Math.min(Math.max(0, cachedTokens), tokensIn);
+    return (((tokensIn - cached) * rates.inputPerMillionTokens +
+        cached * (rates.cachedInputPerMillionTokens ?? rates.inputPerMillionTokens) +
+        tokensOut * rates.outputPerMillionTokens) /
+        1_000_000);
+}
+// The API model a CLI's model is billed as when it is called through a key: Claude Code's
+// models are Anthropic's, Codex's are OpenAI's and Gemini's are Google's, all listed in the
+// catalogue under OpenRouter. A version the catalogue does not list has no API price.
+export function apiEquivalentOf(provider, model, catalogue) {
+    const listed = (id) => catalogue.llm.find((entry) => entry.provider === "openrouter" && entry.id === id);
+    // Context sizes ("[1m]") and dated snapshots ("-20251001") price as the model itself.
+    const bare = model
+        .replace(/\[[^\]]*\]/g, "")
+        .replace(/-\d{8}$/, "")
+        .trim();
+    if (provider === "claude-code") {
+        const family = /^(?:claude-)?(opus|sonnet|haiku|fable)(?:-(\d+)(?:-(\d{1,2}))?)?$/i.exec(bare);
+        if (family === null)
+            return undefined;
+        const name = (family[1] ?? "").toLowerCase();
+        if (family[2] !== undefined)
+            return listed(`anthropic/claude-${name}-${family[2]}${family[3] ? `.${family[3]}` : ""}`);
+        // An alias ("sonnet") is the newest of that family the catalogue lists.
+        return catalogue.llm
+            .filter((entry) => entry.provider === "openrouter" && entry.id.startsWith(`anthropic/claude-${name}-`))
+            .toSorted((left, right) => right.id.localeCompare(left.id, "en", { numeric: true }))[0];
+    }
+    if (bare === "" || bare === "codex-imagegen")
+        return undefined;
+    if (provider === "codex" || provider === "codex-image")
+        return listed(`openai/${bare}`);
+    if (provider === "gemini")
+        return listed(`google/${bare}`);
+    return undefined;
+}
+export function priceCall(call, catalogue) {
+    const date = catalogue.updatedAt;
+    if (isLocalCliProvider(call.provider)) {
+        // Only text is priced through the API: what a Codex image would cost there depends on
+        // how many drafts the agent drew, which the CLI does not say.
+        const api = call.kind === "llm" ? apiEquivalentOf(call.provider, call.model, catalogue) : undefined;
+        const apiCost = api === undefined || call.tokensIn === undefined || call.tokensOut === undefined
+            ? null
+            : tokenCost(api.pricing, call.tokensIn, call.tokensOut, call.cachedTokens);
+        return {
+            onPlan: true,
+            cost: 0,
+            apiModel: api?.id ?? null,
+            apiCost,
+            price: api === undefined ? null : { catalogue: date, model: api.id, ...api.pricing },
+        };
+    }
+    const family = call.kind === "video" ? "image" : call.kind;
+    const entry = catalogue[family].find((model) => model.provider === call.provider && model.id === call.model);
+    const rates = entry?.pricing;
+    let cost = null;
+    if (rates !== undefined)
+        switch (call.kind) {
+            case "llm":
+                cost =
+                    call.tokensIn === undefined || call.tokensOut === undefined
+                        ? null
+                        : tokenCost(rates, call.tokensIn, call.tokensOut, call.cachedTokens);
+                break;
+            case "tts":
+                // ceiling: a per-minute voice is left unpriced rather than guessed from characters;
+                // the narration's measured length is known only after the stage writes the file.
+                cost =
+                    rates.perMillionCharacters === undefined || call.characters === undefined
+                        ? null
+                        : (call.characters / 1_000_000) * rates.perMillionCharacters;
+                break;
+            case "image":
+            case "video":
+                // An image-to-video model's perImage is the price of one clip.
+                cost = rates.perImage === undefined ? null : rates.perImage * (call.images ?? 1);
+                break;
+        }
+    return {
+        onPlan: false,
+        cost,
+        apiModel: null,
+        apiCost: null,
+        price: rates === undefined ? null : { catalogue: date, model: call.model, ...rates },
+    };
+}

package/dist/slices/run-cost/week.js

@@ -0,0 +1,108 @@
+import { z } from "zod";
+import { planAccountNames, planAccounts, } from "../../kernel/ports/plan-limits.js";
+import { defaultChannelId } from "../channels/model.js";
+import { projectChannels } from "../channels/repo.js";
+const usageRow = z.object({
+    project_id: z.string(),
+    on_plan: z.number(),
+    cost: z.number().nullable(),
+    api_cost: z.number().nullable(),
+});
+const standaloneRow = z.object({
+    channel_id: z.string(),
+    on_plan: z.number(),
+    cost: z.number().nullable(),
+    api_cost: z.number().nullable(),
+});
+const windowSchema = z.object({
+    kind: z.enum(["five_hour", "weekly", "other"]),
+    usedPercent: z.number(),
+    resetsAt: z.string().nullable(),
+});
+const readingSchema = z.object({
+    before: z.array(windowSchema).optional(),
+    after: z.array(windowSchema).optional(),
+});
+// `channelId` narrows the counts to one channel: its projects, and the calls made for its
+// schedules and itself. Plan standings are the account's whole allowance, which every channel
+// shares, so they are never narrowed.
+export function weekSummary(db, since, channelId) {
+    const known = channelId === undefined ? undefined : knownChannels(db);
+    const channels = channelId === undefined ? undefined : projectChannels(db);
+    const projectInScope = (projectId) => channels === undefined || (channels.get(projectId) ?? defaultChannelId) === channelId;
+    let calls = 0;
+    let cost = 0;
+    let unpriced = 0;
+    let apiEquivalent = null;
+    const count = (row) => {
+        calls += 1;
+        cost += row.cost ?? 0;
+        if (row.cost === null)
+            unpriced += 1;
+        if (row.on_plan === 1)
+            apiEquivalent = (apiEquivalent ?? 0) + (row.api_cost ?? 0);
+    };
+    for (const raw of db
+        .prepare("SELECT project_id, on_plan, cost, api_cost FROM provider_usage WHERE created_at >= ?")
+        .all(since)) {
+        const row = usageRow.parse(raw);
+        if (projectInScope(row.project_id))
+            count(row);
+    }
+    for (const raw of db
+        .prepare("SELECT channel_id, on_plan, cost, api_cost FROM standalone_usage WHERE created_at >= ?")
+        .all(since)) {
+        const row = standaloneRow.parse(raw);
+        // A channel deleted since counts under the default channel, as its projects do.
+        const channel = known === undefined || known.has(row.channel_id) ? row.channel_id : defaultChannelId;
+        if (channelId === undefined || channel === channelId)
+            count(row);
+    }
+    // A video is made when its file lands; a remade video counts again, as it was made again.
+    const videos = db
+        .prepare("SELECT project_id FROM outputs WHERE role = 'video' AND created_at >= ?")
+        .all(since)
+        .filter((row) => projectInScope(String(row.project_id))).length;
+    return { since, videos, calls, cost, unpriced, apiEquivalent, plans: planStandings(db) };
+}
+function knownChannels(db) {
+    return new Set(db
+        .prepare("SELECT id FROM channels")
+        .all()
+        .map((row) => String(row.id)));
+}
+function planStandings(db) {
+    return planAccounts.flatMap((account) => {
+        const rows = db
+            .prepare(`SELECT reading_json, created_at FROM (
+           SELECT reading_json, created_at, rowid AS n, 0 AS source FROM plan_limit_readings WHERE account = ?
+           UNION ALL
+           SELECT reading_json, created_at, rowid AS n, 1 AS source FROM standalone_usage WHERE account = ? AND reading_json IS NOT NULL
+         ) ORDER BY created_at DESC, source DESC, n DESC LIMIT 20`)
+            .all(account, account);
+        for (const raw of rows) {
+            const row = z.object({ reading_json: z.string(), created_at: z.string() }).parse(raw);
+            const parsed = readingSchema.safeParse(JSON.parse(row.reading_json));
+            if (!parsed.success)
+                continue;
+            const windows = parsed.data.after?.length
+                ? parsed.data.after
+                : (parsed.data.before ?? []);
+            if (windows.length === 0)
+                continue;
+            const weekly = windows.find((window) => window.kind === "weekly");
+            const fiveHour = windows.find((window) => window.kind === "five_hour");
+            return [
+                {
+                    account,
+                    name: planAccountNames[account],
+                    weeklyPercent: weekly?.usedPercent ?? null,
+                    fiveHourPercent: fiveHour?.usedPercent ?? null,
+                    weeklyResetsAt: weekly?.resetsAt ?? null,
+                    readAt: row.created_at,
+                },
+            ];
+        }
+        return [];
+    });
+}

package/dist/slices/schedules/agenda.js

@@ -0,0 +1,158 @@
+import { z } from "zod";
+import { derive } from "../../kernel/runner/graph.js";
+import { liveProject, projectPaused, stageStandingsByProject } from "../admission/repo.js";
+import { queueEntries } from "../batch/index.js";
+import { nextOccurrence } from "./calendar.js";
+import { scheduleRows } from "./repo.js";
+import { calendarMaxDays, } from "./schema.js";
+import { renderedTitle } from "./topic-list.js";
+// Enough for a run every day of the longest range, with room for a queue.
+const occurrencesMax = 1000;
+const dayMs = 24 * 60 * 60_000;
+// Everything the coming weeks hold between `from` and `to`: every run a live schedule will
+// make, with the topic it will use; every project running in the range or finished in it; and
+// every batch item still waiting its turn.
+export function calendarRange(deps, from, to) {
+    if (Number.isNaN(from.valueOf()) ||
+        Number.isNaN(to.valueOf()) ||
+        to <= from ||
+        to.valueOf() - from.valueOf() > calendarMaxDays * dayMs)
+        return { ok: false, reason: "invalid-input" };
+    const now = deps.clock.now();
+    const runs = scheduleRows(deps.db)
+        .flatMap((schedule) => upcomingRuns(deps, schedule, now, from, to))
+        .sort((a, b) => a.at.localeCompare(b.at) || a.scheduleName.localeCompare(b.scheduleName));
+    return {
+        ok: true,
+        value: {
+            from: from.toISOString(),
+            to: to.toISOString(),
+            runs,
+            projects: projectsIn(deps, from, to),
+            queued: queued(deps),
+        },
+    };
+}
+// Run k from now uses the k-th queued topic. A schedule that does not find its own topics
+// completes when its queue empties, so its runs stop there; one with no queue at all runs the
+// template as saved every time.
+function upcomingRuns(deps, schedule, now, from, to) {
+    if (schedule.deletedAt !== null)
+        return [];
+    if (schedule.status !== "active" && schedule.status !== "paused")
+        return [];
+    const paused = schedule.status === "paused";
+    // A paused schedule resumes from the next occurrence after the moment Resume is pressed.
+    let at = schedule.nextRunAt === null
+        ? null
+        : paused
+            ? nextOccurrence(schedule.cadence, schedule.timezone, now)
+            : new Date(schedule.nextRunAt);
+    const template = deps.template(schedule.templateId, schedule.templateVersion);
+    const templateName = template?.name ?? null;
+    const form = template?.document.form;
+    const { items } = schedule;
+    const generation = schedule.topicGeneration.mode;
+    const held = generation === "hold" ? schedule.topics.held : 0;
+    const runs = [];
+    for (let k = 0; at !== null && at < to && k < occurrencesMax; k++) {
+        if (generation === "off" && items.length > 0 && k >= items.length)
+            break;
+        const queuedTopic = items[k];
+        // Known for a queued topic, and for a run of the template as saved; a held or generated
+        // topic has no text yet.
+        const known = queuedTopic !== undefined || generation === "off";
+        if (at >= from)
+            runs.push({
+                at: at.toISOString(),
+                scheduleId: schedule.id,
+                scheduleName: schedule.name,
+                scheduleVersion: schedule.version,
+                paused,
+                templateId: schedule.templateId,
+                templateVersion: schedule.templateVersion,
+                templateName,
+                index: queuedTopic === undefined ? null : k,
+                topic: queuedTopic?.title ?? null,
+                topicSource: queuedTopic !== undefined
+                    ? "queued"
+                    : generation === "off"
+                        ? "template"
+                        : k < items.length + held
+                            ? "held"
+                            : "generated",
+                renderedTitle: form !== undefined && known ? renderedTitle(form, schedule, queuedTopic) : null,
+            });
+        if (schedule.cadence.kind === "once")
+            break;
+        at = nextOccurrence(schedule.cadence, schedule.timezone, new Date(at.valueOf() + 1000));
+    }
+    return runs;
+}
+const projectRow = z.object({
+    id: z.string(),
+    title: z.string(),
+    created_at: z.string(),
+    finished_at: z.string().nullable(),
+});
+// Running (or waiting) projects made before `to`, and finished ones whose last stage ended in
+// the range.
+function projectsIn(deps, from, to) {
+    const standings = stageStandingsByProject(deps.db);
+    const fromSchedule = new Map();
+    for (const row of deps.db
+        .prepare(`SELECT DISTINCT admitted.value AS project_id, schedule_runs.schedule_id
+       FROM schedule_runs, json_each(schedule_runs.project_ids_json) AS admitted`)
+        .all()) {
+        const parsed = z.object({ project_id: z.string(), schedule_id: z.string() }).parse(row);
+        fromSchedule.set(parsed.project_id, parsed.schedule_id);
+    }
+    return deps.db
+        .prepare(`SELECT projects.id,projects.title,projects.created_at,max(stages.finished_at) AS finished_at
+       FROM projects LEFT JOIN stages ON stages.project_id=projects.id
+       WHERE projects.created_at<? AND ${liveProject()} GROUP BY projects.id ORDER BY projects.created_at,projects.id`)
+        .all(to.toISOString())
+        .flatMap((row) => {
+        const project = projectRow.parse(row);
+        const state = derive(standings.get(project.id) ?? [], projectPaused(deps.db, project.id));
+        const terminal = state === "done" || state === "partial" || state === "failed" || state === "canceled";
+        if (terminal) {
+            const ended = project.finished_at ?? project.created_at;
+            if (ended < from.toISOString() || ended >= to.toISOString())
+                return [];
+        }
+        return [
+            {
+                id: project.id,
+                title: project.title,
+                state,
+                createdAt: project.created_at,
+                finishedAt: terminal ? (project.finished_at ?? project.created_at) : null,
+                scheduleId: fromSchedule.get(project.id) ?? null,
+            },
+        ];
+    });
+}
+function queued(deps) {
+    return queueEntries(deps.db).flatMap((entry) => {
+        if (entry.state === "finished")
+            return [];
+        const row = deps.db
+            .prepare(`SELECT projects.title, batches.created_at FROM projects, batches
+         WHERE projects.id=? AND batches.id=? AND ${liveProject()}`)
+            .get(entry.projectId, entry.batchId);
+        if (row === undefined)
+            return [];
+        const parsed = z.object({ title: z.string(), created_at: z.string() }).parse(row);
+        return [
+            {
+                projectId: entry.projectId,
+                title: parsed.title,
+                batchId: entry.batchId,
+                position: entry.position,
+                state: entry.state,
+                queuedAt: parsed.created_at,
+            },
+        ];
+    });
+}