mulmocast 0.0.1 → 0.0.3

package/lib/utils/file.js

@@ -1,112 +1,133 @@
-"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 { parse as yamlParse } from "yaml";
+import { fileURLToPath } from "url";
+import { GraphAILogger } from "graphai";
+import { MulmoScriptTemplateMethods } from "../methods/mulmo_script_template.js";
+import { MulmoStudioContextMethods } from "../methods/index.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 script = JSON.parse(scriptData);
-    const parsedPath = path_1.default.parse(scriptPath);
+    const scriptData = fs.readFileSync(scriptPath, "utf-8");
+    const script = ([".yaml", ".yml"].includes(path.extname(scriptPath).toLowerCase()) ? yamlParse(scriptData) : JSON.parse(scriptData));
+    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");
-};
-exports.getOutputStudioFilePath = getOutputStudioFilePath;
-const getOutputBGMFilePath = (outDirPath, fileName) => {
-    return path_1.default.resolve(outDirPath, fileName + "_bgm.mp3");
-};
-exports.getOutputBGMFilePath = getOutputBGMFilePath;
-const getOutputVideoFilePath = (outDirPath, fileName) => {
-    return path_1.default.resolve(outDirPath, fileName + ".mp4");
-};
-exports.getOutputVideoFilePath = getOutputVideoFilePath;
-const getOutputAudioFilePath = (outDirPath, fileName) => {
-    return path_1.default.resolve(outDirPath, fileName + ".mp3");
-};
-exports.getOutputAudioFilePath = getOutputAudioFilePath;
-const getScratchpadFilePath = (scratchpadDirName, fileName) => {
-    return path_1.default.resolve(scratchpadDirName, fileName + ".mp3");
-};
-exports.getScratchpadFilePath = getScratchpadFilePath;
-const getTemplateFilePath = (templateName) => {
-    return path_1.default.resolve(__dirname, "../../assets/templates/" + templateName + ".json");
-};
-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 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");
+};
+export const getAudioSegmentDirPath = (audioDirPath, studioFileName) => {
+    return path.resolve(audioDirPath, studioFileName);
+};
+export const getAudioSegmentFilePath = (audioDirPath, studioFileName, fileName) => {
+    return path.resolve(getAudioSegmentDirPath(audioDirPath, studioFileName), fileName + ".mp3");
+};
+export const getAudioCombinedFilePath = (audioDirPath, fileName) => {
+    return path.resolve(audioDirPath, fileName, fileName + ".mp3");
+};
+export const getAudioArtifactFilePath = (outDirPath, fileName) => {
+    return path.resolve(outDirPath, fileName + ".mp3");
+};
+export const getOutputVideoFilePath = (outDirPath, fileName) => {
+    return path.resolve(outDirPath, fileName + ".mp4");
+};
+export const getOutputPdfFilePath = (outDirPath, fileName, pdfMode) => {
+    return path.resolve(outDirPath, fileName + "_" + pdfMode + ".pdf");
+};
+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 });
+    }
+};
+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");
 };
-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");
 // 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);
-};
-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);
+    return path.resolve(file);
+};
+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}`);
+};
+export const resolveMediaSource = (source, context) => {
+    if (source.kind === "path") {
+        return MulmoStudioContextMethods.resolveAssetPath(context, source.path);
+    }
+    if (source.kind === "url") {
+        return source.url;
+    }
+    return null;
 };
-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;

package/lib/utils/filters.js

@@ -1,32 +1,53 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fileCacheAgentFilter = void 0;
-require("dotenv/config");
-const promises_1 = __importDefault(require("fs/promises"));
-const graphai_1 = require("graphai");
-const file_1 = require("./file");
-const fileCacheAgentFilter = async (context, next) => {
+import "dotenv/config";
+import fs from "fs";
+import path from "path";
+import fsPromise from "fs/promises";
+import { GraphAILogger } from "graphai";
+import { writingMessage } from "./file.js";
+import { text2hash } from "./utils.js";
+export const fileCacheAgentFilter = async (context, next) => {
     const { namedInputs } = context;
-    const { file, text } = namedInputs;
-    try {
-        await promises_1.default.access(file);
+    const { file, text, force } = namedInputs;
+    const shouldUseCache = async () => {
+        if (force) {
+            return false;
+        }
+        try {
+            await fsPromise.access(file);
+            return true;
+        }
+        catch (__e) {
+            return false;
+        }
+    };
+    if (await shouldUseCache()) {
         const elements = file.split("/");
-        graphai_1.GraphAILogger.info("cache hit: " + elements[elements.length - 1], text.slice(0, 10));
+        GraphAILogger.info("cache hit: " + elements[elements.length - 1], text.slice(0, 10));
         return true;
     }
-    catch (__e) {
-        const output = (await next(context));
-        const buffer = output ? output["buffer"] : undefined;
-        if (buffer) {
-            (0, file_1.writingMessage)(file);
-            await promises_1.default.writeFile(file, buffer);
-            return true;
-        }
-        graphai_1.GraphAILogger.log("no cache, no buffer: " + file);
-        return false;
+    const output = (await next(context));
+    const buffer = output ? output["buffer"] : undefined;
+    if (buffer) {
+        writingMessage(file);
+        await fsPromise.writeFile(file, buffer);
+        return true;
     }
+    GraphAILogger.log("no cache, no buffer: " + file);
+    return false;
+};
+export const browserlessCacheGenerator = (cacheDir) => {
+    const browserlessCache = async (context, next) => {
+        const cacheKey = text2hash(context?.namedInputs?.url);
+        const cachePath = path.resolve(cacheDir, cacheKey + ".txt");
+        if (fs.existsSync(cachePath)) {
+            // console.log("cache hit!!");
+            const text = fs.readFileSync(cachePath, "utf-8");
+            return { text };
+        }
+        // console.log("cache not hit!!");
+        const result = (await next(context));
+        fs.writeFileSync(cachePath, result?.text, "utf8");
+        return result;
+    };
+    return browserlessCache;
 };
-exports.fileCacheAgentFilter = fileCacheAgentFilter;

package/lib/utils/image_plugins/chart.d.ts

@@ -0,0 +1,3 @@
+import { ImageProcessorParams } from "../../types/index.js";
+export declare const imageType = "chart";
+export declare const process: (params: ImageProcessorParams) => Promise<string | undefined>;

package/lib/utils/image_plugins/chart.js

@@ -0,0 +1,18 @@
+import { getHTMLFile } from "../file.js";
+import { renderHTMLToImage, interpolate } from "../markdown.js";
+export const imageType = "chart";
+const processChart = async (params) => {
+    const { beat, imagePath, canvasSize, textSlideStyle } = params;
+    if (!beat.image || beat.image.type !== imageType)
+        return;
+    const template = getHTMLFile("chart");
+    const htmlData = interpolate(template, {
+        title: beat.image.title,
+        style: textSlideStyle,
+        width: Math.round(canvasSize.width * 0.625).toString(),
+        chart_data: JSON.stringify(beat.image.chartData),
+    });
+    await renderHTMLToImage(htmlData, imagePath, canvasSize.width, canvasSize.height);
+    return imagePath;
+};
+export const process = processChart;

package/lib/utils/image_plugins/image.d.ts

@@ -0,0 +1,2 @@
+export declare const imageType = "image";
+export declare const process: (params: import("../../types/type.js").ImageProcessorParams) => string | undefined;

package/lib/utils/image_plugins/image.js

@@ -0,0 +1,3 @@
+import { processSource } from "./source.js";
+export const imageType = "image";
+export const process = processSource(imageType);

package/lib/utils/image_plugins/index.d.ts

@@ -0,0 +1,7 @@
+import * as pluginTextSlide from "./text_slide.js";
+import * as pluginMarkdown from "./markdown.js";
+import * as pluginImage from "./image.js";
+import * as pluginChart from "./chart.js";
+import * as pluginMermaid from "./mermaid.js";
+import * as pluginMovie from "./movie.js";
+export declare const imagePlugins: (typeof pluginTextSlide | typeof pluginMarkdown | typeof pluginImage | typeof pluginChart | typeof pluginMermaid | typeof pluginMovie)[];

package/lib/utils/image_plugins/index.js

@@ -0,0 +1,7 @@
+import * as pluginTextSlide from "./text_slide.js";
+import * as pluginMarkdown from "./markdown.js";
+import * as pluginImage from "./image.js";
+import * as pluginChart from "./chart.js";
+import * as pluginMermaid from "./mermaid.js";
+import * as pluginMovie from "./movie.js";
+export const imagePlugins = [pluginTextSlide, pluginMarkdown, pluginImage, pluginChart, pluginMermaid, pluginMovie];

package/lib/utils/image_plugins/markdown.d.ts

@@ -0,0 +1,3 @@
+import { ImageProcessorParams } from "../../types/index.js";
+export declare const imageType = "markdown";
+export declare const process: (params: ImageProcessorParams) => Promise<string | undefined>;

package/lib/utils/image_plugins/markdown.js

@@ -0,0 +1,11 @@
+import { renderMarkdownToImage } from "../markdown.js";
+export const imageType = "markdown";
+const processMarkdown = async (params) => {
+    const { beat, imagePath, textSlideStyle, canvasSize } = params;
+    if (!beat.image || beat.image.type !== imageType)
+        return;
+    const markdown = Array.isArray(beat.image.markdown) ? beat.image.markdown.join("\n") : beat.image.markdown;
+    await renderMarkdownToImage(markdown, textSlideStyle, imagePath, canvasSize.width, canvasSize.height);
+    return imagePath;
+};
+export const process = processMarkdown;

package/lib/utils/image_plugins/mermaid.d.ts

@@ -0,0 +1,3 @@
+import { ImageProcessorParams } from "../../types/index.js";
+export declare const imageType = "mermaid";
+export declare const process: (params: ImageProcessorParams) => Promise<string | undefined>;

package/lib/utils/image_plugins/mermaid.js

@@ -0,0 +1,21 @@
+import { MulmoMediaSourceMethods } from "../../methods/index.js";
+import { getHTMLFile } from "../file.js";
+import { renderHTMLToImage, interpolate } from "../markdown.js";
+export const imageType = "mermaid";
+const processMermaid = async (params) => {
+    const { beat, imagePath, canvasSize, context, textSlideStyle } = params;
+    if (!beat.image || beat.image.type !== imageType)
+        return;
+    const template = getHTMLFile("mermaid");
+    const diagram_code = await MulmoMediaSourceMethods.getText(beat.image.code, context);
+    if (diagram_code) {
+        const htmlData = interpolate(template, {
+            title: beat.image.title,
+            style: textSlideStyle,
+            diagram_code: `${diagram_code}\n${beat.image.appendix?.join("\n") ?? ""}`,
+        });
+        await renderHTMLToImage(htmlData, imagePath, canvasSize.width, canvasSize.height);
+    }
+    return imagePath;
+};
+export const process = processMermaid;

package/lib/utils/image_plugins/movie.d.ts

@@ -0,0 +1,2 @@
+export declare const imageType = "movie";
+export declare const process: (params: import("../../types/type.js").ImageProcessorParams) => string | undefined;

package/lib/utils/image_plugins/movie.js

@@ -0,0 +1,3 @@
+import { processSource } from "./source.js";
+export const imageType = "movie";
+export const process = processSource(imageType);

package/lib/utils/image_plugins/source.d.ts

@@ -0,0 +1,4 @@
+import { ImageProcessorParams } from "../../types/index.js";
+type ImageType = "image" | "movie";
+export declare const processSource: (imageType: ImageType) => (params: ImageProcessorParams) => string | undefined;
+export {};

package/lib/utils/image_plugins/source.js

@@ -0,0 +1,15 @@
+import { GraphAILogger } from "graphai";
+import { resolveMediaSource } from "../../utils/file.js";
+export const processSource = (imageType) => {
+    return (params) => {
+        const { beat, context } = params;
+        if (!beat.image || beat.image.type !== imageType)
+            return;
+        const path = resolveMediaSource(beat.image.source, context);
+        if (path) {
+            return path;
+        }
+        GraphAILogger.error(`Image Plugin unknown ${imageType} source type:`, beat.image);
+        throw new Error(`ERROR: unknown ${imageType} source type`);
+    };
+};

package/lib/utils/image_plugins/text_slide.d.ts

@@ -0,0 +1,3 @@
+import { ImageProcessorParams } from "../../types/index.js";
+export declare const imageType = "textSlide";
+export declare const process: (params: ImageProcessorParams) => Promise<string | undefined>;

package/lib/utils/image_plugins/text_slide.js

@@ -0,0 +1,12 @@
+import { renderMarkdownToImage } from "../markdown.js";
+export const imageType = "textSlide";
+const processTextSlide = async (params) => {
+    const { beat, imagePath, textSlideStyle, canvasSize } = params;
+    if (!beat.image || beat.image.type !== imageType)
+        return;
+    const slide = beat.image.slide;
+    const markdown = `# ${slide.title}\n` + slide.bullets.map((text) => `- ${text}`).join("\n");
+    await renderMarkdownToImage(markdown, textSlideStyle, imagePath, canvasSize.width, canvasSize.height);
+    return imagePath;
+};
+export const process = processTextSlide;

package/lib/utils/image_plugins/type_guards.d.ts

@@ -0,0 +1,6 @@
+import { MulmoTextSlideMedia, MulmoMarkdownMedia, MulmoImageMedia, MulmoChartMedia, MulmoMermaidMedia } from "../../types/index.js";
+export declare const isMulmoImageTextSlide: (value: unknown) => value is MulmoTextSlideMedia;
+export declare const isMulmoImageMarkdown: (value: unknown) => value is MulmoMarkdownMedia;
+export declare const isMulmoImageImage: (value: unknown) => value is MulmoImageMedia;
+export declare const isMulmoImageChart: (value: unknown) => value is MulmoChartMedia;
+export declare const isMulmoImageMermaild: (value: unknown) => value is MulmoMermaidMedia;

package/lib/utils/image_plugins/type_guards.js

@@ -0,0 +1,21 @@
+import { mulmoTextSlideMediaSchema, mulmoMarkdownMediaSchema, mulmoImageMediaSchema, mulmoChartMediaSchema, mulmoMermaidMediaSchema, } from "../../types/index.js";
+export const isMulmoImageTextSlide = (value) => {
+    const result = mulmoTextSlideMediaSchema.safeParse(value);
+    return result.success;
+};
+export const isMulmoImageMarkdown = (value) => {
+    const result = mulmoMarkdownMediaSchema.safeParse(value);
+    return result.success;
+};
+export const isMulmoImageImage = (value) => {
+    const result = mulmoImageMediaSchema.safeParse(value);
+    return result.success;
+};
+export const isMulmoImageChart = (value) => {
+    const result = mulmoChartMediaSchema.safeParse(value);
+    return result.success;
+};
+export const isMulmoImageMermaild = (value) => {
+    const result = mulmoMermaidMediaSchema.safeParse(value);
+    return result.success;
+};

package/lib/utils/image_preprocess.d.ts

@@ -0,0 +1,14 @@
+import { MulmoStudioBeat, MulmoStudioContext, MulmoCanvasDimension } from "../types/index.js";
+type ImageProcessorParams = {
+    beat: MulmoStudioBeat;
+    context: MulmoStudioContext;
+    imagePath: string;
+    textSlideStyle: string;
+    canvasSize: MulmoCanvasDimension;
+};
+export declare const processTextSlide: (params: ImageProcessorParams) => Promise<void>;
+export declare const processMarkdown: (params: ImageProcessorParams) => Promise<void>;
+export declare const processImage: (params: ImageProcessorParams) => string | undefined;
+export declare const processChart: (params: ImageProcessorParams) => Promise<void>;
+export declare const processMermaid: (params: ImageProcessorParams) => Promise<void>;
+export {};

package/lib/utils/image_preprocess.js

@@ -0,0 +1,52 @@
+import { MulmoStudioContextMethods } from "../methods/index.js";
+import { getHTMLFile } from "./file.js";
+import { renderMarkdownToImage, renderHTMLToImage, interpolate } from "./markdown.js";
+export const processTextSlide = async (params) => {
+    const { beat, imagePath, textSlideStyle, canvasSize } = params;
+    if (!beat.image || beat.image.type !== "textSlide")
+        return;
+    const slide = beat.image.slide;
+    const markdown = `# ${slide.title}\n` + slide.bullets.map((text) => `- ${text}`).join("\n");
+    await renderMarkdownToImage(markdown, textSlideStyle, imagePath, canvasSize.width, canvasSize.height);
+};
+export const processMarkdown = async (params) => {
+    const { beat, imagePath, textSlideStyle, canvasSize } = params;
+    if (!beat.image || beat.image.type !== "markdown")
+        return;
+    const markdown = Array.isArray(beat.image.markdown) ? beat.image.markdown.join("\n") : beat.image.markdown;
+    await renderMarkdownToImage(markdown, textSlideStyle, imagePath, canvasSize.width, canvasSize.height);
+};
+export const processImage = (params) => {
+    const { beat, context } = params;
+    if (!beat.image || beat.image.type !== "image")
+        return;
+    if (beat.image.source.kind === "url") {
+        return beat.image.source.url;
+    }
+    else if (beat.image.source.kind === "path") {
+        return MulmoStudioContextMethods.resolveAssetPath(context, beat.image.source.path);
+    }
+};
+export const processChart = async (params) => {
+    const { beat, imagePath, canvasSize } = params;
+    if (!beat.image || beat.image.type !== "chart")
+        return;
+    const template = getHTMLFile("chart");
+    const htmlData = interpolate(template, {
+        title: beat.image.title,
+        width: Math.round(canvasSize.width * 0.625).toString(),
+        chart_data: JSON.stringify(beat.image.chartData),
+    });
+    await renderHTMLToImage(htmlData, imagePath, canvasSize.width, canvasSize.height);
+};
+export const processMermaid = async (params) => {
+    const { beat, imagePath, canvasSize } = params;
+    if (!beat.image || beat.image.type !== "mermaid")
+        return;
+    const template = getHTMLFile("mermaid");
+    const htmlData = interpolate(template, {
+        title: beat.image.title,
+        diagram_code: beat.image.code,
+    });
+    await renderHTMLToImage(htmlData, imagePath, canvasSize.width, canvasSize.height);
+};

package/lib/utils/inquirer.d.ts

@@ -0,0 +1,2 @@
+export declare const selectTemplate: () => Promise<string>;
+export declare const getUrlsIfNeeded: (urls: string[]) => Promise<string[]>;

package/lib/utils/inquirer.js

@@ -0,0 +1,33 @@
+import inquirer from "inquirer";
+import { getAvailableTemplates } from "./file.js";
+export const selectTemplate = async () => {
+    const availableTemplates = getAvailableTemplates();
+    const answers = await inquirer.prompt([
+        {
+            type: "list",
+            name: "templateName",
+            message: "Select a template to use",
+            choices: availableTemplates.map((t) => ({
+                name: `${t.filename} - ${t.description}`,
+                value: t.filename,
+            })),
+        },
+    ]);
+    return answers.templateName;
+};
+export const getUrlsIfNeeded = async (urls) => {
+    if (urls && urls.length > 0)
+        return urls;
+    const answers = await inquirer.prompt([
+        {
+            type: "input",
+            name: "urls",
+            message: "Enter URLs for scripting references (comma separated):",
+            validate: (input) => input.trim().length > 0 || "At least one URL is required",
+        },
+    ]);
+    return answers.urls
+        .split(",")
+        .map((u) => u.trim())
+        .filter((u) => u.length > 0);
+};

package/lib/utils/markdown.d.ts

@@ -1 +1,3 @@
-export declare const convertMarkdownToImage: (markdown: string, style: string, outputPath: string) => Promise<void>;
+export declare const renderHTMLToImage: (html: string, outputPath: string, width: number, height: number) => Promise<void>;
+export declare const renderMarkdownToImage: (markdown: string, style: string, outputPath: string, width: number, height: number) => Promise<void>;
+export declare const interpolate: (template: string, data: Record<string, string>) => string;