mulmocast 0.0.1 → 0.0.2

package/lib/types/schema.js

@@ -1,89 +1,100 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.urlsSchema = exports.mulmoScriptTemplateSchema = exports.mulmoStudioSchema = exports.mulmoStudioBeatSchema = exports.mulmoScriptSchema = exports.mulmoSpeechParamsSchema = exports.mulmoCastCreditSchema = exports.mulmoDimensionSchema = exports.mulmoBeatSchema = exports.videoParamsSchema = exports.textSlideParamsSchema = exports.mulmoImageParamsSchema = exports.mulmoAudioAssetSchema = exports.mulmoMediaSchema = exports.speakerDictionarySchema = exports.speechOptionsSchema = exports.multiLingualTextsSchema = exports.localizedTextSchema = exports.langSchema = void 0;
-const zod_1 = require("zod");
-exports.langSchema = zod_1.z.string();
-const URLStringSchema = zod_1.z.string().url();
-exports.localizedTextSchema = zod_1.z
-    .object({
-    text: zod_1.z.string(),
-    lang: zod_1.z.string(),
+import { z } from "zod";
+export const langSchema = z.string();
+const URLStringSchema = z.string().url();
+export const localizedTextSchema = z
+    .object({
+    text: z.string(),
+    lang: z.string(),
     // caption: z.string(),
-    texts: zod_1.z.array(zod_1.z.string()).optional(),
-    ttsTexts: zod_1.z.array(zod_1.z.string()).optional(),
-    duration: zod_1.z.number().optional(), // generated // video duration time(ms)
+    texts: z.array(z.string()).optional(),
+    ttsTexts: z.array(z.string()).optional(),
+    duration: z.number().optional(), // generated // video duration time(ms)
     // filename: z.string().optional(), // generated //
 })
     .strict();
-exports.multiLingualTextsSchema = zod_1.z.record(exports.langSchema, exports.localizedTextSchema);
-exports.speechOptionsSchema = zod_1.z
+export const multiLingualTextsSchema = z.record(langSchema, localizedTextSchema);
+export const speechOptionsSchema = z
     .object({
-    speed: zod_1.z.number().optional(), // default: 1.0
-    instruction: zod_1.z.string().optional(),
+    speed: z.number().optional(), // default: 1.0
+    instruction: z.string().optional(),
 })
     .strict();
-const speakerIdSchema = zod_1.z.string();
-const speakerDataSchema = zod_1.z
+const speakerIdSchema = z.string();
+const speakerDataSchema = z
     .object({
-    displayName: zod_1.z.record(exports.langSchema, zod_1.z.string()),
-    voiceId: zod_1.z.string(),
-    speechOptions: exports.speechOptionsSchema.optional(),
+    displayName: z.record(langSchema, z.string()),
+    voiceId: z.string(),
+    speechOptions: speechOptionsSchema.optional(),
 })
     .strict();
-exports.speakerDictionarySchema = zod_1.z.record(speakerIdSchema, speakerDataSchema);
-const mediaSourceSchema = zod_1.z.discriminatedUnion("kind", [
-    zod_1.z.object({ kind: zod_1.z.literal("url"), url: URLStringSchema }).strict(), // https://example.com/foo.pdf
-    zod_1.z.object({ kind: zod_1.z.literal("data"), data: zod_1.z.string() }).strict(), // base64
-    zod_1.z.object({ kind: zod_1.z.literal("path"), path: zod_1.z.string() }).strict(), // foo.pdf
+export const speakerDictionarySchema = z.record(speakerIdSchema, speakerDataSchema);
+const mediaSourceSchema = z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("url"), url: URLStringSchema }).strict(), // https://example.com/foo.pdf
+    z.object({ kind: z.literal("data"), data: z.string() }).strict(), // base64
+    z.object({ kind: z.literal("path"), path: z.string() }).strict(), // foo.pdf
 ]);
 // String is easier for AI, string array is easier for human
-const stringOrStringArray = zod_1.z.union([zod_1.z.string(), zod_1.z.array(zod_1.z.string())]);
-const MulmoMarkdownMediaSchema = zod_1.z
+const stringOrStringArray = z.union([z.string(), z.array(z.string())]);
+const MulmoMarkdownMediaSchema = z
     .object({
-    type: zod_1.z.literal("markdown"),
+    type: z.literal("markdown"),
     markdown: stringOrStringArray,
 })
     .strict();
-const MulmoWebMediaSchema = zod_1.z
+const MulmoWebMediaSchema = z
     .object({
-    type: zod_1.z.literal("web"),
+    type: z.literal("web"),
     url: URLStringSchema,
 })
     .strict();
-const MulmoPdfMediaSchema = zod_1.z
+const MulmoPdfMediaSchema = z
     .object({
-    type: zod_1.z.literal("pdf"),
+    type: z.literal("pdf"),
     source: mediaSourceSchema,
 })
     .strict();
-const MulmoImageMediaSchema = zod_1.z
+const MulmoImageMediaSchema = z
     .object({
-    type: zod_1.z.literal("image"),
+    type: z.literal("image"),
     source: mediaSourceSchema,
 })
     .strict();
-const MulmoSvgMediaSchema = zod_1.z
+const MulmoSvgMediaSchema = z
     .object({
-    type: zod_1.z.literal("svg"),
+    type: z.literal("svg"),
     source: mediaSourceSchema,
 })
     .strict();
-const MulmoMovieMediaSchema = zod_1.z
+const MulmoMovieMediaSchema = z
     .object({
-    type: zod_1.z.literal("movie"),
+    type: z.literal("movie"),
     source: mediaSourceSchema,
 })
     .strict();
-const MulmoTextSlideMediaSchema = zod_1.z
+const MulmoTextSlideMediaSchema = z
     .object({
-    type: zod_1.z.literal("textSlide"),
-    slide: zod_1.z.object({
-        title: zod_1.z.string(),
-        bullets: zod_1.z.array(zod_1.z.string()),
+    type: z.literal("textSlide"),
+    slide: z.object({
+        title: z.string(),
+        bullets: z.array(z.string()),
     }),
 })
     .strict();
-exports.mulmoMediaSchema = zod_1.z.union([
+const MulmoChartMediaSchema = z
+    .object({
+    type: z.literal("chart"),
+    title: z.string(),
+    chartData: z.record(z.any()),
+})
+    .strict();
+const MulmoMermaidMediaSchema = z
+    .object({
+    type: z.literal("mermaid"),
+    title: z.string().describe("The title of the diagram"),
+    code: z.string().describe("The code of the mermaid diagram"),
+})
+    .strict();
+export const mulmoImageAssetSchema = z.union([
     MulmoMarkdownMediaSchema,
     MulmoWebMediaSchema,
     MulmoPdfMediaSchema,
@@ -91,117 +102,121 @@ exports.mulmoMediaSchema = zod_1.z.union([
     MulmoSvgMediaSchema,
     MulmoMovieMediaSchema,
     MulmoTextSlideMediaSchema,
+    MulmoChartMediaSchema,
+    MulmoMermaidMediaSchema,
 ]);
-const MulmoAudioMediaSchema = zod_1.z
+const MulmoAudioMediaSchema = z
     .object({
-    type: zod_1.z.literal("audio"),
+    type: z.literal("audio"),
     source: mediaSourceSchema,
 })
     .strict();
-const MulmoMidiMediaSchema = zod_1.z
+const MulmoMidiMediaSchema = z
     .object({
-    type: zod_1.z.literal("midi"),
-    source: zod_1.z.string(), // TODO: define it later
+    type: z.literal("midi"),
+    source: z.string(), // TODO: define it later
 })
     .strict();
-exports.mulmoAudioAssetSchema = zod_1.z.union([MulmoAudioMediaSchema, MulmoMidiMediaSchema]);
-exports.mulmoImageParamsSchema = zod_1.z
+export const mulmoAudioAssetSchema = z.union([MulmoAudioMediaSchema, MulmoMidiMediaSchema]);
+export const mulmoImageParamsSchema = z
     .object({
-    model: zod_1.z.string().optional(), // default: provider specific
-    size: zod_1.z.string().optional(), // default: provider specific
-    style: zod_1.z.string().optional(), // optional image style
-    moderation: zod_1.z.string().optional(), // optional image style
+    model: z.string().optional(), // default: provider specific
+    size: z.string().optional(), // default: provider specific
+    style: z.string().optional(), // optional image style
+    moderation: z.string().optional(), // optional image style
 })
     .strict();
-exports.textSlideParamsSchema = zod_1.z
+export const textSlideParamsSchema = z
     .object({
-    cssStyles: zod_1.z.array(zod_1.z.string()),
+    cssStyles: z.array(z.string()),
 })
     .strict();
-exports.videoParamsSchema = zod_1.z
+export const videoParamsSchema = z
     .object({
-    padding: zod_1.z.number().optional(), // msec
+    padding: z.number().optional(), // msec
 })
     .strict();
-exports.mulmoBeatSchema = zod_1.z
+export const mulmoBeatSchema = z
     .object({
     speaker: speakerIdSchema,
-    text: zod_1.z.string(),
-    image: exports.mulmoMediaSchema.optional(),
-    audio: exports.mulmoAudioAssetSchema.optional(),
-    imageParams: exports.mulmoImageParamsSchema.optional(), // beat specific parameters
-    speechOptions: exports.speechOptionsSchema.optional(),
-    textSlideParams: exports.textSlideParamsSchema.optional(),
-    imagePrompt: zod_1.z.string().optional(), // specified or inserted by preprocessor
+    text: z.string(),
+    image: mulmoImageAssetSchema.optional(),
+    audio: mulmoAudioAssetSchema.optional(),
+    imageParams: mulmoImageParamsSchema.optional(), // beat specific parameters
+    speechOptions: speechOptionsSchema.optional(),
+    textSlideParams: textSlideParamsSchema.optional(),
+    imagePrompt: z.string().optional(), // specified or inserted by preprocessor
 })
     .strict();
-exports.mulmoDimensionSchema = zod_1.z
+export const mulmoCanvasDimensionSchema = z
     .object({
-    width: zod_1.z.number(),
-    height: zod_1.z.number(),
+    width: z.number(),
+    height: z.number(),
 })
-    .strict();
+    .default({ width: 1280, height: 720 });
 // export const voiceMapSchema = z.record(speakerIdSchema, z.string())
-exports.mulmoCastCreditSchema = zod_1.z
+export const mulmoCastCreditSchema = z
     .object({
-    version: zod_1.z.literal("1.0"),
-    credit: zod_1.z.literal("closing").optional(),
+    version: z.literal("1.0"),
+    credit: z.literal("closing").optional(),
 })
     .strict();
-exports.mulmoSpeechParamsSchema = zod_1.z
+export const text2SpeechProviderSchema = z.union([z.literal("openai"), z.literal("nijivoice")]).default("openai");
+export const mulmoSpeechParamsSchema = z
     .object({
-    provider: zod_1.z.string().optional(),
-    speakers: exports.speakerDictionarySchema,
+    provider: text2SpeechProviderSchema, // has default value
+    speakers: speakerDictionarySchema,
 })
     .strict();
-exports.mulmoScriptSchema = zod_1.z
+export const text2ImageProviderSchema = z.union([z.literal("openai"), z.literal("google")]).default("openai");
+export const mulmoScriptSchema = z
     .object({
     // global settings
-    $mulmocast: exports.mulmoCastCreditSchema,
-    title: zod_1.z.string(),
-    description: zod_1.z.string().optional(),
-    reference: zod_1.z.string().optional(),
-    lang: exports.langSchema.optional(), // default "en"
-    canvasSize: exports.mulmoDimensionSchema.optional(),
-    beats: zod_1.z.array(exports.mulmoBeatSchema),
-    speechParams: exports.mulmoSpeechParamsSchema,
-    imageParams: exports.mulmoImageParamsSchema
+    $mulmocast: mulmoCastCreditSchema,
+    title: z.string(),
+    description: z.string().optional(),
+    reference: z.string().optional(),
+    lang: langSchema.optional(), // default "en"
+    canvasSize: mulmoCanvasDimensionSchema, // has default value
+    beats: z.array(mulmoBeatSchema),
+    speechParams: mulmoSpeechParamsSchema,
+    imageParams: mulmoImageParamsSchema
         .extend({
-        provider: zod_1.z.string().optional(),
+        provider: text2ImageProviderSchema, // has default value
     })
         .optional(),
     // for textSlides
-    textSlideParams: exports.textSlideParamsSchema.optional(),
-    videoParams: exports.videoParamsSchema.optional(),
+    textSlideParams: textSlideParamsSchema.optional(),
+    videoParams: videoParamsSchema.optional(),
     // images: ImageInfo[] // generated
-    imagePath: zod_1.z.string().optional(), // for keynote images movie ??
-    omitCaptions: zod_1.z.boolean().optional(), // default is false
+    imagePath: z.string().optional(), // for keynote images movie ??
+    omitCaptions: z.boolean().optional(), // default is false
     // for debugging
-    __test_invalid__: zod_1.z.boolean().optional(),
+    __test_invalid__: z.boolean().optional(),
 })
     .strict();
-exports.mulmoStudioBeatSchema = exports.mulmoBeatSchema
+export const mulmoStudioBeatSchema = mulmoBeatSchema
     .extend({
-    multiLingualTexts: exports.multiLingualTextsSchema.optional(),
-    hash: zod_1.z.string().optional(),
-    duration: zod_1.z.number().optional(),
-    audioFile: zod_1.z.string().optional(),
-    imageFile: zod_1.z.string().optional(), // path to the image
+    multiLingualTexts: multiLingualTextsSchema.optional(),
+    hash: z.string().optional(),
+    duration: z.number().optional(),
+    audioFile: z.string().optional(),
+    imageFile: z.string().optional(), // path to the image
 })
     .strict();
-exports.mulmoStudioSchema = zod_1.z
+export const mulmoStudioSchema = z
     .object({
-    script: exports.mulmoScriptSchema,
-    filename: zod_1.z.string(),
-    beats: zod_1.z.array(exports.mulmoStudioBeatSchema),
+    script: mulmoScriptSchema,
+    filename: z.string(),
+    beats: z.array(mulmoStudioBeatSchema),
 })
     .strict();
-exports.mulmoScriptTemplateSchema = zod_1.z
+export const mulmoScriptTemplateSchema = z
     .object({
-    title: zod_1.z.string(),
-    description: zod_1.z.string(),
-    systemPrompt: zod_1.z.string(),
-    script: exports.mulmoScriptSchema.optional(),
+    title: z.string(),
+    description: z.string(),
+    systemPrompt: z.string(),
+    script: mulmoScriptSchema.optional(),
 })
     .strict();
-exports.urlsSchema = zod_1.z.array(zod_1.z.string().url({ message: "Invalid URL format" }));
+export const urlsSchema = z.array(z.string().url({ message: "Invalid URL format" }));

package/lib/types/type.d.ts

@@ -1,4 +1,4 @@
-import { langSchema, localizedTextSchema, mulmoBeatSchema, mulmoScriptSchema, mulmoStudioSchema, mulmoStudioBeatSchema, speakerDictionarySchema, mulmoImageParamsSchema, mulmoSpeechParamsSchema, textSlideParamsSchema, speechOptionsSchema, mulmoDimensionSchema, mulmoScriptTemplateSchema } from "./schema";
+import { langSchema, localizedTextSchema, mulmoBeatSchema, mulmoScriptSchema, mulmoStudioSchema, mulmoStudioBeatSchema, speakerDictionarySchema, mulmoImageParamsSchema, mulmoSpeechParamsSchema, textSlideParamsSchema, speechOptionsSchema, mulmoCanvasDimensionSchema, mulmoScriptTemplateSchema, text2ImageProviderSchema, text2SpeechProviderSchema } from "./schema.js";
 import { z } from "zod";
 export type LANG = z.infer<typeof langSchema>;
 export type MulmoBeat = z.infer<typeof mulmoBeatSchema>;
@@ -7,9 +7,11 @@ export type MulmoSpeechParams = z.infer<typeof mulmoSpeechParamsSchema>;
 export type SpeechOptions = z.infer<typeof speechOptionsSchema>;
 export type MulmoImageParams = z.infer<typeof mulmoImageParamsSchema>;
 export type TextSlideParams = z.infer<typeof textSlideParamsSchema>;
+export type Text2ImageProvider = z.infer<typeof text2ImageProviderSchema>;
+export type Text2SpeechProvider = z.infer<typeof text2SpeechProviderSchema>;
 export type LocalizedText = z.infer<typeof localizedTextSchema>;
 export type MulmoScript = z.infer<typeof mulmoScriptSchema>;
-export type MulmoDimension = z.infer<typeof mulmoDimensionSchema>;
+export type MulmoCanvasDimension = z.infer<typeof mulmoCanvasDimensionSchema>;
 export type MulmoStudioBeat = z.infer<typeof mulmoStudioBeatSchema>;
 export type MulmoStudio = z.infer<typeof mulmoStudioSchema>;
 export type MulmoScriptTemplate = z.infer<typeof mulmoScriptTemplateSchema>;
@@ -19,15 +21,17 @@ export type FileDirs = {
     baseDirPath: string;
     outDirPath: string;
     imageDirPath: string;
-    scratchpadDirPath: string;
+    audioDirPath: string;
 };
 export type MulmoStudioContext = {
     fileDirs: FileDirs;
     studio: MulmoStudio;
+    force: boolean;
 };
 export type ScriptingParams = {
     urls: string[];
     outDirPath: string;
+    cacheDirPath: string;
     templateName: string;
     filename: string;
 };

package/lib/types/type.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/lib/utils/const.d.ts

@@ -1,3 +1,4 @@
 export declare const outDirName = "output";
-export declare const scratchpadDirName = "scratchpad";
+export declare const audioDirName = "audio";
 export declare const imageDirName = "images";
+export declare const cacheDirName = "cache";

package/lib/utils/const.js

@@ -1,6 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.imageDirName = exports.scratchpadDirName = exports.outDirName = void 0;
-exports.outDirName = "output";
-exports.scratchpadDirName = "scratchpad";
-exports.imageDirName = "images";
+export const outDirName = "output";
+export const audioDirName = "audio";
+export const imageDirName = "images";
+export const cacheDirName = "cache";

package/lib/utils/file.d.ts

@@ -1,4 +1,4 @@
-import { MulmoScript, MulmoScriptTemplate } from "../types";
+import { MulmoScript, MulmoScriptTemplate } from "../types/index.js";
 export declare function readMulmoScriptFile<T = MulmoScript>(path: string, errorMessage: string): {
     mulmoData: T;
     mulmoDataPath: string;
@@ -9,16 +9,31 @@ export declare function readMulmoScriptFile<T = MulmoScript>(path: string): {
     mulmoDataPath: string;
     fileName: string;
 } | null;
+export declare const fetchMulmoScriptFile: (url: string) => Promise<{
+    result: boolean;
+    status: number;
+    script?: undefined;
+} | {
+    result: boolean;
+    script: any;
+    status?: undefined;
+} | {
+    result: boolean;
+    status: string;
+    script?: undefined;
+}>;
 export declare const getOutputStudioFilePath: (outDirPath: string, fileName: string) => string;
-export declare const getOutputBGMFilePath: (outDirPath: string, fileName: string) => string;
+export declare const getAudioSegmentDirPath: (audioDirPath: string, studioFileName: string) => string;
+export declare const getAudioSegmentFilePath: (audioDirPath: string, studioFileName: string, fileName: string) => string;
+export declare const getAudioCombinedFilePath: (audioDirPath: string, fileName: string) => string;
+export declare const getAudioArtifactFilePath: (outDirPath: string, fileName: string) => string;
 export declare const getOutputVideoFilePath: (outDirPath: string, fileName: string) => string;
-export declare const getOutputAudioFilePath: (outDirPath: string, fileName: string) => string;
-export declare const getScratchpadFilePath: (scratchpadDirName: string, fileName: string) => string;
 export declare const getTemplateFilePath: (templateName: string) => string;
 export declare const mkdir: (dirPath: string) => void;
 export declare const silentPath: string;
 export declare const silentLastPath: string;
 export declare const defaultBGMPath: string;
+export declare const getHTMLFile: (filename: string) => string;
 export declare const getBaseDirPath: (basedir?: string) => string;
 export declare const getFullPath: (baseDirPath: string | undefined, file: string) => string;
 export declare const readTemplatePrompt: (templateName: string) => string;

package/lib/utils/file.js

@@ -1,112 +1,119 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.writingMessage = exports.getAvailableTemplates = exports.readTemplatePrompt = exports.getFullPath = exports.getBaseDirPath = exports.defaultBGMPath = exports.silentLastPath = exports.silentPath = exports.mkdir = exports.getTemplateFilePath = exports.getScratchpadFilePath = exports.getOutputAudioFilePath = exports.getOutputVideoFilePath = exports.getOutputBGMFilePath = exports.getOutputStudioFilePath = void 0;
-exports.readMulmoScriptFile = readMulmoScriptFile;
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const graphai_1 = require("graphai");
-const mulmo_script_template_1 = require("../methods/mulmo_script_template");
-const schema_1 = require("../types/schema");
-function readMulmoScriptFile(arg2, errorMessage) {
-    const scriptPath = path_1.default.resolve(arg2);
-    if (!fs_1.default.existsSync(scriptPath)) {
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { GraphAILogger } from "graphai";
+import { MulmoScriptTemplateMethods } from "../methods/mulmo_script_template.js";
+import { mulmoScriptTemplateSchema } from "../types/schema.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export function readMulmoScriptFile(arg2, errorMessage) {
+    const scriptPath = path.resolve(arg2);
+    if (!fs.existsSync(scriptPath)) {
         if (errorMessage) {
-            console.error(errorMessage);
+            GraphAILogger.info(errorMessage);
             process.exit(1);
         }
         return null;
     }
-    const scriptData = fs_1.default.readFileSync(scriptPath, "utf-8");
+    const scriptData = fs.readFileSync(scriptPath, "utf-8");
     const script = JSON.parse(scriptData);
-    const parsedPath = path_1.default.parse(scriptPath);
+    const parsedPath = path.parse(scriptPath);
     return {
         mulmoData: script,
         mulmoDataPath: scriptPath,
         fileName: parsedPath.name,
     };
 }
-const getOutputStudioFilePath = (outDirPath, fileName) => {
-    return path_1.default.resolve(outDirPath, fileName + "_studio.json");
+export const fetchMulmoScriptFile = async (url) => {
+    try {
+        const res = await fetch(url);
+        if (!res.ok) {
+            return { result: false, status: res.status };
+        }
+        const script = await res.json();
+        return {
+            result: true,
+            script,
+        };
+    }
+    catch {
+        return { result: false, status: "unknown" };
+    }
+};
+export const getOutputStudioFilePath = (outDirPath, fileName) => {
+    return path.resolve(outDirPath, fileName + "_studio.json");
 };
-exports.getOutputStudioFilePath = getOutputStudioFilePath;
-const getOutputBGMFilePath = (outDirPath, fileName) => {
-    return path_1.default.resolve(outDirPath, fileName + "_bgm.mp3");
+export const getAudioSegmentDirPath = (audioDirPath, studioFileName) => {
+    return path.resolve(audioDirPath, studioFileName);
 };
-exports.getOutputBGMFilePath = getOutputBGMFilePath;
-const getOutputVideoFilePath = (outDirPath, fileName) => {
-    return path_1.default.resolve(outDirPath, fileName + ".mp4");
+export const getAudioSegmentFilePath = (audioDirPath, studioFileName, fileName) => {
+    return path.resolve(getAudioSegmentDirPath(audioDirPath, studioFileName), fileName + ".mp3");
 };
-exports.getOutputVideoFilePath = getOutputVideoFilePath;
-const getOutputAudioFilePath = (outDirPath, fileName) => {
-    return path_1.default.resolve(outDirPath, fileName + ".mp3");
+export const getAudioCombinedFilePath = (audioDirPath, fileName) => {
+    return path.resolve(audioDirPath, fileName, fileName + ".mp3");
 };
-exports.getOutputAudioFilePath = getOutputAudioFilePath;
-const getScratchpadFilePath = (scratchpadDirName, fileName) => {
-    return path_1.default.resolve(scratchpadDirName, fileName + ".mp3");
+export const getAudioArtifactFilePath = (outDirPath, fileName) => {
+    return path.resolve(outDirPath, fileName + ".mp3");
 };
-exports.getScratchpadFilePath = getScratchpadFilePath;
-const getTemplateFilePath = (templateName) => {
-    return path_1.default.resolve(__dirname, "../../assets/templates/" + templateName + ".json");
+export const getOutputVideoFilePath = (outDirPath, fileName) => {
+    return path.resolve(outDirPath, fileName + ".mp4");
 };
-exports.getTemplateFilePath = getTemplateFilePath;
-const mkdir = (dirPath) => {
-    if (!fs_1.default.existsSync(dirPath)) {
-        console.info("mkdir: " + dirPath);
-        fs_1.default.mkdirSync(dirPath, { recursive: true });
+export const getTemplateFilePath = (templateName) => {
+    return path.resolve(__dirname, "../../assets/templates/" + templateName + ".json");
+};
+export const mkdir = (dirPath) => {
+    if (!fs.existsSync(dirPath)) {
+        GraphAILogger.info("mkdir: " + dirPath);
+        fs.mkdirSync(dirPath, { recursive: true });
     }
 };
-exports.mkdir = mkdir;
-exports.silentPath = path_1.default.resolve(__dirname, "../../assets/audio/silent300.mp3");
-exports.silentLastPath = path_1.default.resolve(__dirname, "../../assets/audio/silent800.mp3");
-exports.defaultBGMPath = path_1.default.resolve(__dirname, "../../assets/music/StarsBeyondEx.mp3");
+export const silentPath = path.resolve(__dirname, "../../assets/audio/silent300.mp3");
+export const silentLastPath = path.resolve(__dirname, "../../assets/audio/silent800.mp3");
+export const defaultBGMPath = path.resolve(__dirname, "../../assets/music/StarsBeyondEx.mp3");
+export const getHTMLFile = (filename) => {
+    const htmlPath = path.resolve(__dirname, `../../assets/html/${filename}.html`);
+    return fs.readFileSync(htmlPath, "utf-8");
+};
 // for cli
-const getBaseDirPath = (basedir) => {
+export const getBaseDirPath = (basedir) => {
     if (!basedir) {
         return process.cwd();
     }
-    if (path_1.default.isAbsolute(basedir)) {
-        return path_1.default.normalize(basedir);
+    if (path.isAbsolute(basedir)) {
+        return path.normalize(basedir);
     }
-    return path_1.default.resolve(process.cwd(), basedir);
+    return path.resolve(process.cwd(), basedir);
 };
-exports.getBaseDirPath = getBaseDirPath;
-const getFullPath = (baseDirPath, file) => {
-    if (path_1.default.isAbsolute(file)) {
-        return path_1.default.normalize(file);
+export const getFullPath = (baseDirPath, file) => {
+    if (path.isAbsolute(file)) {
+        return path.normalize(file);
     }
     if (baseDirPath) {
-        return path_1.default.resolve(baseDirPath, file);
+        return path.resolve(baseDirPath, file);
     }
-    return path_1.default.resolve(file);
+    return path.resolve(file);
 };
-exports.getFullPath = getFullPath;
-const readTemplatePrompt = (templateName) => {
-    const templatePath = (0, exports.getTemplateFilePath)(templateName);
-    const scriptData = fs_1.default.readFileSync(templatePath, "utf-8");
-    const template = schema_1.mulmoScriptTemplateSchema.parse(JSON.parse(scriptData));
-    const prompt = mulmo_script_template_1.MulmoScriptTemplateMethods.getSystemPrompt(template);
+export const readTemplatePrompt = (templateName) => {
+    const templatePath = getTemplateFilePath(templateName);
+    const scriptData = fs.readFileSync(templatePath, "utf-8");
+    const template = mulmoScriptTemplateSchema.parse(JSON.parse(scriptData));
+    const prompt = MulmoScriptTemplateMethods.getSystemPrompt(template);
     return prompt;
 };
-exports.readTemplatePrompt = readTemplatePrompt;
-const getAvailableTemplates = () => {
-    const templatesDir = path_1.default.resolve(__dirname, "../../assets/templates");
-    if (!fs_1.default.existsSync(templatesDir)) {
+export const getAvailableTemplates = () => {
+    const templatesDir = path.resolve(__dirname, "../../assets/templates");
+    if (!fs.existsSync(templatesDir)) {
         return [];
     }
-    const files = fs_1.default.readdirSync(templatesDir);
+    const files = fs.readdirSync(templatesDir);
     return files.map((file) => {
-        const template = JSON.parse(fs_1.default.readFileSync(path_1.default.resolve(templatesDir, file), "utf-8"));
+        const template = JSON.parse(fs.readFileSync(path.resolve(templatesDir, file), "utf-8"));
         return {
-            ...schema_1.mulmoScriptTemplateSchema.parse(template),
+            ...mulmoScriptTemplateSchema.parse(template),
             filename: file.replace(/\.json$/, ""),
         };
     });
 };
-exports.getAvailableTemplates = getAvailableTemplates;
-const writingMessage = (filePath) => {
-    graphai_1.GraphAILogger.info(`writing: ${filePath}`);
+export const writingMessage = (filePath) => {
+    GraphAILogger.info(`writing: ${filePath}`);
 };
-exports.writingMessage = writingMessage;

package/lib/utils/filters.d.ts

@@ -1,3 +1,4 @@
 import "dotenv/config";
 import type { AgentFilterFunction } from "graphai";
 export declare const fileCacheAgentFilter: AgentFilterFunction;
+export declare const browserlessCacheGenerator: (cacheDir: string) => AgentFilterFunction;