videobook 0.0.0-stage → 0.2.0

package/dist/tools/read-asset-metadata.js

@@ -0,0 +1,26 @@
+import { z } from "zod";
+export function readAssetMetadataDef(engine) {
+    return {
+        name: "read_asset_metadata",
+        description: "Read native artifact metadata at the current Dolt revision. " +
+            "Returns the parsed value or an error if the key is missing.",
+        schema: {
+            asset_id: z.string().describe("Asset ID (e.g. script-desc-*)"),
+            name: z.string().describe("Metadata key without dot/extension (e.g. \"original\")"),
+            book_id: z.string().describe("Book id"),
+        },
+        handler: async (args) => {
+            const { asset_id, name, book_id: _book_id } = args;
+            const result = await engine.metadata.artifacts.read(asset_id, name);
+            if (!result.ok) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: result.error.message }],
+                };
+            }
+            return {
+                content: [{ type: "text", text: JSON.stringify(result.value) }],
+            };
+        },
+    };
+}

package/dist/tools/read-file-at-commit.js

@@ -0,0 +1,29 @@
+import { z } from "zod";
+export function readFileAtCommitDef(engine) {
+    return {
+        name: "read_file_at_commit",
+        description: "Read a file's contents from a specific immutable revision for a given asset. " +
+            "Non-destructive — used to preview an old version of a script/prompt without restoring it.",
+        schema: {
+            asset_id: z.string().describe("Asset ID (e.g. script-desc-*)"),
+            filename: z.string().describe("Filename within the asset directory (e.g. original.md)"),
+            commit_hash: z.string().describe("DoltLite revision hash"),
+            book_id: z.string().describe("Book id"),
+        },
+        handler: async (args) => {
+            const { asset_id, filename, commit_hash } = args;
+            const artifact = engine.artifacts.get(asset_id);
+            const artifactId = artifact.ok ? artifact.value.artifactId : asset_id;
+            const result = await engine.files.readAtRevision(artifactId, filename, commit_hash);
+            if (!result.ok) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: result.error.message }],
+                };
+            }
+            return {
+                content: [{ type: "text", text: result.value.toString() }],
+            };
+        },
+    };
+}

package/dist/tools/read-transcript.js

@@ -0,0 +1,41 @@
+import { z } from "zod";
+import { readAssetTranscript, readTranscriptSidecarText, } from "../transcript-projection.js";
+export function readTranscriptDef(engine) {
+    return {
+        name: "read_transcript",
+        description: "Read a video or audio asset's transcript: timed per-word cues when available, otherwise plain text; kind reports timed, plain, silence or missing. raw returns the stored file unparsed.",
+        schema: {
+            asset_id: z.string().describe("Asset ID (e.g. vid-my-clip)"),
+            book_id: z.string().describe("Book id"),
+            raw: z.boolean().optional().describe("Return the untouched sidecar file text instead of the parsed projection"),
+            source: z.enum(["elevenlabs", "plain"]).optional().describe("Which sidecar to read when raw=true; defaults to elevenlabs then plain"),
+        },
+        handler: async (args) => {
+            const { asset_id, raw, source } = args;
+            if (raw) {
+                const sidecar = await readTranscriptSidecarText(engine, asset_id, source);
+                const payload = sidecar ?? { kind: "missing" };
+                return {
+                    content: [{ type: "text", text: JSON.stringify(payload) }],
+                };
+            }
+            const transcript = await readAssetTranscript(engine, asset_id);
+            const payload = transcript.kind === "timed"
+                ? {
+                    kind: "timed",
+                    language_code: transcript.languageCode,
+                    text: transcript.text,
+                    words: transcript.words.map((word) => ({
+                        text: word.text,
+                        start: word.start,
+                        end: word.end,
+                        ...(word.speakerId ? { speaker_id: word.speakerId } : {}),
+                    })),
+                }
+                : transcript;
+            return {
+                content: [{ type: "text", text: JSON.stringify(payload) }],
+            };
+        },
+    };
+}