videobook 0.0.0-stage → 0.2.0

package/dist/cold-open.js

@@ -0,0 +1,79 @@
+import { createHash } from "node:crypto";
+import { join } from "node:path";
+import { findPrimaryMediaFile } from "videobook-engine";
+import { notebookGridTag, notebookOccupiedSlots, NOTEBOOK_GRID_ROW_COUNT, NOTEBOOK_GRID_COLUMN_COUNT } from "videobook-engine/notebook-grid";
+import { z } from "zod";
+import { INTELLIGENCE_MODEL } from "./openai-intelligence.js";
+import { coldOpenRangeError } from "./cold-open-model.js";
+const coldOpenSuggestionSchema = z.object({
+    sourceArtifactId: z.string().uuid(),
+    sourceObjectHash: z.string().min(1),
+    durationSeconds: z.number().finite().min(0.5),
+    fps: z.number().finite().positive(),
+    startSeconds: z.number().finite().nonnegative(),
+    endSeconds: z.number().finite().positive(),
+    reason: z.string().min(1),
+    model: z.string().min(1),
+});
+export async function coldOpenSource(engine, artifactId, expectedHash) {
+    const artifact = engine.artifacts.get(artifactId);
+    if (!artifact.ok)
+        throw new Error(artifact.error.message);
+    if (!["video", "final"].includes(artifact.value.kind))
+        throw new Error("Choose a video for the cold open.");
+    const manifest = await engine.files.manifest(artifactId, { includeDotfiles: true });
+    if (!manifest.ok)
+        throw new Error(manifest.error.message);
+    const file = findPrimaryMediaFile(manifest.value.files, artifact.value.kind);
+    if (!file)
+        throw new Error("The source video is missing.");
+    if (expectedHash && file.objectHash !== expectedHash)
+        throw new Error("The source video changed. Open a new cold-open review.");
+    const streams = engine.streams.list(artifactId);
+    if (!streams.ok)
+        throw new Error(streams.error.message);
+    const video = streams.value.find(stream => stream.kind === "video" && stream.sourcePath === file.name && stream.objectHash === file.objectHash);
+    if (!video)
+        throw new Error("Wait for the video to finish processing before making a cold open.");
+    const durationSeconds = video.durationTicks * video.timeBase.numerator / video.timeBase.denominator;
+    const metadata = await engine.metadata.artifacts.read(artifactId, "original");
+    const fps = metadata.ok && metadata.value.fps && metadata.value.fps > 0 ? metadata.value.fps : 30;
+    const error = coldOpenRangeError(0, durationSeconds, durationSeconds);
+    if (error)
+        throw new Error(error);
+    return { artifact: artifact.value, file, manifest: manifest.value, path: join(manifest.value.path, file.name), durationSeconds, fps };
+}
+export function coldOpenCacheKey(source) {
+    const inputs = source.manifest.files.filter(file => ["elevenlabs.json", ".analysis.gpt4otrans.json"].includes(file.name))
+        .map(file => [file.name, file.objectHash]).sort();
+    return `cold-open.suggestion.${createHash("sha256").update(JSON.stringify([1, INTELLIGENCE_MODEL, source.artifact.artifactId, source.file.objectHash, inputs])).digest("hex")}`;
+}
+export function readColdOpenSuggestion(engine, key) {
+    const parsed = coldOpenSuggestionSchema.safeParse(engine.settings.get(key));
+    if (!parsed.success || coldOpenRangeError(parsed.data.startSeconds, parsed.data.endSeconds, parsed.data.durationSeconds))
+        return null;
+    return parsed.data;
+}
+export function coldOpenDestination(notebook, sourceArtifactId) {
+    const occupied = new Set(notebookOccupiedSlots(notebook.cells).map(notebookGridTag));
+    const source = notebook.cells.find(cell => cell.outputArtifactId === sourceArtifactId);
+    const below = source ? { row: source.slot.row + 1, column: source.slot.column } : null;
+    if (below && below.row < NOTEBOOK_GRID_ROW_COUNT && !occupied.has(notebookGridTag(below)))
+        return below;
+    for (let row = 0; row < NOTEBOOK_GRID_ROW_COUNT; row += 1) {
+        for (let column = 0; column < NOTEBOOK_GRID_COLUMN_COUNT; column += 1) {
+            const slot = { row, column };
+            if (!occupied.has(notebookGridTag(slot)))
+                return slot;
+        }
+    }
+    throw new Error("The notebook needs one empty cell for the cold-open copy.");
+}
+export function checkColdOpenNotebook(engine, notebookId, sourceArtifactId) {
+    if (!notebookId)
+        return;
+    const notebook = engine.notebooks.read(notebookId);
+    if (!notebook.ok)
+        throw new Error(notebook.error.message);
+    coldOpenDestination(notebook.value, sourceArtifactId);
+}

package/dist/command-reference.js

@@ -0,0 +1,95 @@
+import { listModels } from "./media/listing.js";
+import { buildWorkspaceActionCatalog } from "./workspace-action-catalog.js";
+import { WORKSPACE_ACTION_SURFACES } from "./workspace-action-surfaces.js";
+function oneLine(value) {
+    return value.replace(/\s+/g, " ").trim();
+}
+function escapeTable(value) {
+    return oneLine(value).replaceAll("|", "\\|");
+}
+export function renderCommandReference(tools, commands) {
+    const toolLines = [...tools]
+        .sort((a, b) => a.name.localeCompare(b.name))
+        .map((tool) => `- \`${tool.name}\` — ${oneLine(tool.description)}`);
+    const catalog = buildWorkspaceActionCatalog(tools, commands);
+    const commandLines = [...catalog.actions]
+        .sort((a, b) => a.command.localeCompare(b.command))
+        .map((command) => {
+        const aliases = command.aliases ?? [];
+        const aliasText = aliases.length > 0 ? ` (aliases: ${aliases.map((alias) => `\`${alias}\``).join(", ")})` : "";
+        const target = command.handler.kind === "tool"
+            ? `; MCP: \`${command.handler.tool}\``
+            : command.handler.kind === "ui" ? `; UI: \`${command.handler.action}\`` : "; preview or workspace operation";
+        return `- \`${command.command}\`${aliasText} — ${oneLine(command.description)}${target}`;
+    });
+    return `# Command Reference
+
+Every current MCP endpoint and discoverable action is listed once. Use the Actions button on any screen, press Ctrl+Shift+K / Cmd+Shift+K, or type a slash in chat to browse the complete catalog. Search includes aliases and descriptions. A command with missing arguments opens its form; media, notebook, entity, track and clip selectors provide targets. Advanced provider alternatives retain shared input fields and show a cost review before generation.
+
+Media commands \`/export\`, \`/delete\`, \`/reverse\` and \`/trim\` target media. Sequence operations use \`/export-sequence\`, \`/clip-delete\`, \`/clip-reverse\`, \`/clip-trim\`, and \`/clip-audio\`; clip timing uses frames and media trimming uses seconds. \`/clip-audio\` edits gain, mute, and fades on an audio-track clip. Explicit legacy clip IDs and \`/export @sequence-main\` remain accepted. Use grid addresses such as \`/crop @a1\`, \`/trim @a1 0 2\` or \`/insert @a1 0 60\`.
+
+Image, video and audio generation runs through \`generate_image\`, \`generate_video\` and \`generate_audio\` with a model id from \`list_generation_models\`; see [generation-models.md](generation-models.md). Slash aliases match their canonical action in search. The legacy \`/skeleton\` shortcut opens a reviewed AI pose-guide request. Import owns upload transport and duplicate-byte checks; it uses a native file picker. Set \`VIDEOBOOK_DOWNLOADS_DIR\` to override the server's default Downloads directory.
+
+Routine pointer actions return focus to chat. Editing fields, open dialogs, keyboard navigation and native playback retain focus. Closing a dialog restores its opener when appropriate; delayed work cannot take focus from a newer edit.
+
+## MCP endpoints (${tools.length})
+
+${toolLines.join("\n")}
+
+## Slash actions (${catalog.actions.length}; ${commands.length} dedicated command routes)
+
+${commandLines.join("\n")}
+- \`/<project-name>\` — Switch to that project; generated dynamically for each project whose name does not conflict with a command or alias.
+`;
+}
+export function renderWorkspaceActionCoverage(catalog) {
+    const rows = [...catalog.actions].sort((left, right) => left.id.localeCompare(right.id)).map((action) => {
+        const target = action.target.argument ? `${action.target.kind}${action.target.multiple ? " selection" : ""}: ${action.target.argument}` : action.target.kind;
+        const handler = action.handler.kind === "tool" ? action.handler.tool : action.handler.kind === "ui" ? action.handler.action : action.handler.command;
+        return `| \`${action.id}\` | \`${action.command}\` | ${action.aliases.join(", ")} | ${action.scope} | ${escapeTable(target)} | \`${handler}\` | ${action.surfaces.join(", ")} | ${action.focus} | ${action.confirmation} |`;
+    });
+    const surfaces = Object.entries(WORKSPACE_ACTION_SURFACES).map(([name, entry]) => `| ${name} | [${entry.component}](../${entry.component}) | ${entry.trigger} |`);
+    const workflows = catalog.tools.filter((entry) => entry.exposure === "workflow").map((entry) => `| \`${entry.tool}\` | \`${entry.actionId}\` | ${escapeTable(entry.reason)} |`);
+    return `# Workspace action coverage
+
+Generated by \`npm run docs:commands\` from the registered tools, command definitions and surface contracts. ${catalog.tools.length} active endpoints map to ${catalog.actions.length} visible actions or their owning workflows. Unknown endpoints, handlers, aliases and missing declared surfaces fail the catalog contract.
+
+The browser regression suite checks catalog equality, complete slash traversal, typed form discovery, named target selection, menu and slash parity, review and cancellation, real media mutations and focus. Provider generation, posting and OS clipboard integration require separate execution validation; opening a form never starts a paid job or publishes content.
+
+## Surface entry points
+
+| Surface | Component | Entry point |
+| --- | --- | --- |
+${surfaces.join("\n")}
+
+## Actions
+
+| Stable ID | Command | Aliases | Scope | Target | Handler | Surfaces | Focus | Review |
+| --- | --- | --- | --- | --- | --- | --- | --- | --- |
+${rows.join("\n")}
+
+## Transport and workflow ownership
+
+| Endpoint | Visible owner | Reason |
+| --- | --- | --- |
+${workflows.join("\n")}
+`;
+}
+export function renderGenerationModels() {
+    const models = listModels({ includeHidden: true });
+    const rows = models.map((model) => {
+        const refs = model.slots.map((slot) => `${slot.role} ${slot.min}-${slot.max ?? "n"}`).join(", ") || "none";
+        const modes = model.modes.length > 1 ? model.modes.map((mode) => mode.id).join(", ") : "";
+        return `| \`${escapeTable(model.id)}\` | ${escapeTable(model.title)} | ${model.media} | ${model.entry.operations.join(", ")} | ${escapeTable(refs)} | ${modes} | ${model.entry.hidden ? "hidden" : "visible"} |`;
+    });
+    return `# Generation Models
+
+Generated by \`npm run docs:commands\` from the media catalog (\`server/src/media/catalog.ts\`). Call \`generate_image\`, \`generate_video\` or \`generate_audio\` with one of these model ids; \`list_generation_models\` returns the same list with every option, enum, range and default read from the apicity schemas.
+
+- Models: ${models.length}
+
+| Model | Title | Media | Operations | Refs | Modes | Picker |
+| --- | --- | --- | --- | --- | --- | --- |
+${rows.join("\n")}
+`;
+}

package/dist/content-store.js

@@ -0,0 +1,74 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { B2Error, createB2 } from "@apicity/b2";
+function createB2ContentStore(config) {
+    const provider = createB2({
+        accessKeyId: config.accessKeyId,
+        secretAccessKey: config.secretAccessKey,
+        region: config.region,
+        ...(config.endpoint ? { endpoint: config.endpoint } : {}),
+    });
+    return {
+        head: async (key) => {
+            try {
+                const result = await provider.objects.head({
+                    bucket: config.bucket,
+                    key,
+                });
+                return {
+                    exists: true,
+                    ...(result.contentLength !== undefined
+                        ? { size: result.contentLength }
+                        : {}),
+                };
+            }
+            catch (error) {
+                if (error instanceof B2Error && error.status === 404) {
+                    return { exists: false };
+                }
+                throw error;
+            }
+        },
+        uploadFile: async (key, sourcePath) => {
+            await provider.objects.put({
+                bucket: config.bucket,
+                key,
+                body: await readFile(sourcePath),
+                contentType: "application/octet-stream",
+            });
+        },
+        downloadFile: async (key, destinationPath) => {
+            const result = await provider.objects.get({
+                bucket: config.bucket,
+                key,
+            });
+            await writeFile(destinationPath, new Uint8Array(result.body));
+        },
+        delete: async (key) => {
+            await provider.objects.del({
+                bucket: config.bucket,
+                key,
+            });
+        },
+    };
+}
+export function b2ContentStoreConfigFromEnvironment() {
+    const accessKeyId = process.env.B2_ACCESS_KEY_ID;
+    const secretAccessKey = process.env.B2_SECRET_ACCESS_KEY;
+    const region = process.env.B2_REGION;
+    const bucket = process.env.B2_BUCKET;
+    if (!accessKeyId || !secretAccessKey || !region || !bucket)
+        return undefined;
+    return {
+        accessKeyId,
+        secretAccessKey,
+        region,
+        bucket,
+        ...(process.env.B2_ENDPOINT
+            ? { endpoint: process.env.B2_ENDPOINT }
+            : {}),
+    };
+}
+export function contentStoreFromEnvironment() {
+    const config = b2ContentStoreConfigFromEnvironment();
+    return config ? createB2ContentStore(config) : undefined;
+}

package/dist/cost.js

@@ -0,0 +1,8 @@
+import { createCost } from "@apicity/cost";
+let cached = null;
+export function getCostProvider() {
+    if (cached)
+        return cached;
+    cached = createCost();
+    return cached;
+}

package/dist/crop-geometry.js

@@ -0,0 +1,23 @@
+const CANONICAL_DIMS = {
+    "16:9": [1920, 1080],
+    "9:16": [1080, 1920],
+    "1:1": [1080, 1080],
+};
+export function cropGeometry(rect, srcW, srcH, ratio, alignment) {
+    if (!Number.isFinite(srcW) || !Number.isFinite(srcH) || srcW < alignment || srcH < alignment) {
+        throw new Error("Could not probe usable source dimensions");
+    }
+    const cropW = Math.min(Math.floor(srcW / alignment) * alignment, Math.max(alignment, Math.round(rect.w * srcW / alignment) * alignment));
+    const cropH = Math.min(Math.floor(srcH / alignment) * alignment, Math.max(alignment, Math.round(rect.h * srcH / alignment) * alignment));
+    const roundOrigin = alignment === 2 ? Math.floor : Math.round;
+    const cropX = Math.min(srcW - cropW, Math.max(0, roundOrigin(rect.x * srcW / alignment) * alignment));
+    const cropY = Math.min(srcH - cropH, Math.max(0, roundOrigin(rect.y * srcH / alignment) * alignment));
+    const [outW, outH] = CANONICAL_DIMS[ratio];
+    const cropAspect = cropW / cropH;
+    const targetAspect = outW / outH;
+    const aspectError = Math.abs(cropAspect - targetAspect) / targetAspect;
+    if (aspectError > 0.02) {
+        throw new Error(`Crop rectangle aspect ${cropAspect.toFixed(4)} (${cropW}x${cropH}) does not match target ratio ${ratio} (${targetAspect.toFixed(4)}); error ${(aspectError * 100).toFixed(1)}% > 2%`);
+    }
+    return { cropX, cropY, cropW, cropH, outW, outH };
+}