mulmocast 0.0.1

package/lib/cli/cli.js

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("dotenv/config");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const graphai_1 = require("graphai");
+const args_1 = require("./args");
+const preprocess_1 = require("../utils/preprocess");
+const const_1 = require("../utils/const");
+const methods_1 = require("../methods");
+const translate_1 = require("../actions/translate");
+const images_1 = require("../actions/images");
+const audio_1 = require("../actions/audio");
+const movie_1 = require("../actions/movie");
+const file_1 = require("../utils/file");
+const schema_1 = require("../types/schema");
+const getFileObject = () => {
+    const { basedir, file, outdir, imagedir, scratchpaddir } = args_1.args;
+    const baseDirPath = (0, file_1.getBaseDirPath)(basedir);
+    const mulmoFilePath = (0, file_1.getFullPath)(baseDirPath, file ?? "");
+    const mulmoFileDirPath = path_1.default.dirname(mulmoFilePath);
+    const outDirPath = (0, file_1.getFullPath)(baseDirPath, outdir ?? const_1.outDirName);
+    const imageDirPath = (0, file_1.getFullPath)(baseDirPath, imagedir ?? const_1.imageDirName);
+    const scratchpadDirPath = (0, file_1.getFullPath)(baseDirPath, scratchpaddir ?? const_1.scratchpadDirName);
+    return { baseDirPath, mulmoFilePath, mulmoFileDirPath, outDirPath, imageDirPath, scratchpadDirPath };
+};
+const main = async () => {
+    const files = getFileObject();
+    const { mulmoFilePath } = files;
+    if (args_1.args.v) {
+        console.log(files);
+    }
+    else {
+        graphai_1.GraphAILogger.setLevelEnabled("error", false);
+        graphai_1.GraphAILogger.setLevelEnabled("log", false);
+        graphai_1.GraphAILogger.setLevelEnabled("warn", false);
+    }
+    if (!fs_1.default.existsSync(mulmoFilePath)) {
+        console.error("File not exists");
+        return -1;
+    }
+    // TODO some option process
+    const { action } = args_1.args;
+    const studio = (0, preprocess_1.createOrUpdateStudioData)(mulmoFilePath, files);
+    // validate mulmoStudioSchema. skip if __test_invalid__ is true
+    try {
+        if (!studio.script?.__test_invalid__) {
+            schema_1.mulmoStudioSchema.parse(studio);
+        }
+    }
+    catch (error) {
+        console.error(`Error: invalid MulmoScript Schema: ${mulmoFilePath} \n ${error}`);
+        return -1;
+    }
+    const context = {
+        studio,
+        fileDirs: files,
+    };
+    if (action === "translate") {
+        await (0, translate_1.translate)(context);
+    }
+    if (action === "audio") {
+        await (0, audio_1.audio)(context, methods_1.MulmoScriptMethods.getSpeechProvider(studio.script) === "nijivoice" ? 1 : 8);
+    }
+    if (action === "images") {
+        await (0, images_1.images)(context);
+    }
+    if (action === "movie") {
+        await (0, audio_1.audio)(context, methods_1.MulmoScriptMethods.getSpeechProvider(studio.script) === "nijivoice" ? 1 : 8);
+        await (0, images_1.images)(context);
+        await (0, movie_1.movie)(context);
+    }
+};
+main();

package/lib/cli/common.d.ts

@@ -0,0 +1,8 @@
+import type { Argv } from "yargs";
+export declare const commonOptions: (yargs: Argv) => Argv<{
+    v: boolean;
+} & {
+    o: string | undefined;
+} & {
+    b: string | undefined;
+}>;

package/lib/cli/common.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commonOptions = void 0;
+const commonOptions = (yargs) => {
+    return yargs
+        .option("v", {
+        alias: "verbose",
+        describe: "verbose log",
+        demandOption: true,
+        default: false,
+        type: "boolean",
+    })
+        .option("o", {
+        alias: "outdir",
+        description: "output dir",
+        demandOption: false,
+        type: "string",
+    })
+        .option("b", {
+        alias: "basedir",
+        description: "base dir",
+        demandOption: false,
+        type: "string",
+    });
+};
+exports.commonOptions = commonOptions;

package/lib/cli/tool-args.d.ts

@@ -0,0 +1,12 @@
+export declare const args: {
+    [x: string]: unknown;
+    v: boolean;
+    o: string | undefined;
+    b: string | undefined;
+    u: string[] | never[];
+    i: boolean | undefined;
+    t: string | undefined;
+    f: string;
+    _: (string | number)[];
+    $0: string;
+};

package/lib/cli/tool-args.js

@@ -0,0 +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.args = void 0;
+const yargs_1 = __importDefault(require("yargs"));
+const helpers_1 = require("yargs/helpers");
+const common_1 = require("./common");
+const graphai_1 = require("graphai");
+const file_1 = require("../utils/file");
+graphai_1.GraphAILogger.setLevelEnabled("error", false);
+const availableTemplateNames = (0, file_1.getAvailableTemplates)().map((template) => template.filename);
+exports.args = (0, common_1.commonOptions)((0, yargs_1.default)((0, helpers_1.hideBin)(process.argv)))
+    .scriptName("mulmocast-tool")
+    .option("u", {
+    alias: "url",
+    description: "URLs to reference (required when not in interactive mode)",
+    demandOption: false,
+    default: [],
+    type: "array",
+    string: true,
+})
+    .option("i", {
+    alias: "interactive",
+    description: "Generate script in interactive mode with user prompts",
+    demandOption: false,
+    type: "boolean",
+})
+    .option("t", {
+    alias: "template",
+    description: "Template name to use",
+    demandOption: false,
+    choices: availableTemplateNames,
+    type: "string",
+})
+    .option("f", {
+    alias: "filename",
+    description: "output filename",
+    demandOption: false,
+    default: "script",
+    type: "string",
+})
+    .command("$0 <action>", "Run mulmocast tool", (yargs) => {
+    return yargs.positional("action", {
+        describe: "action to perform",
+        choices: ["scripting", "prompt"],
+        type: "string",
+    });
+})
+    .strict()
+    .help()
+    .parseSync();

package/lib/cli/tool-cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "dotenv/config";

package/lib/cli/tool-cli.js

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("dotenv/config");
+const graphai_1 = require("graphai");
+const inquirer_1 = __importDefault(require("inquirer"));
+const tool_args_1 = require("./tool-args");
+const const_1 = require("../utils/const");
+const seed_from_url_1 = require("../tools/seed_from_url");
+const file_1 = require("../utils/file");
+const seed_1 = require("../tools/seed");
+const dump_prompt_1 = require("../tools/dump_prompt");
+const selectTemplate = async () => {
+    const availableTemplates = (0, file_1.getAvailableTemplates)();
+    const answers = await inquirer_1.default.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;
+};
+const main = async () => {
+    const { o: outdir, u: urls, b: basedir, action, v: verbose, i: interactive, f: filename } = tool_args_1.args;
+    let { t: template } = tool_args_1.args;
+    const baseDirPath = (0, file_1.getBaseDirPath)(basedir);
+    const outDirPath = (0, file_1.getFullPath)(baseDirPath, outdir ?? const_1.outDirName);
+    if (verbose) {
+        console.log("baseDirPath:", baseDirPath);
+        console.log("outDirPath:", outDirPath);
+        console.log("template:", template);
+        console.log("urls:", urls);
+        console.log("action:", action);
+        console.log("interactive:", interactive);
+        console.log("filename:", filename);
+    }
+    else {
+        graphai_1.GraphAILogger.setLevelEnabled("error", false);
+        graphai_1.GraphAILogger.setLevelEnabled("log", false);
+        graphai_1.GraphAILogger.setLevelEnabled("warn", false);
+    }
+    // If template is not specified, show the selection prompt
+    if (!template) {
+        template = await selectTemplate();
+        if (verbose) {
+            console.log("Selected template:", template);
+        }
+    }
+    if (action === "scripting") {
+        if (interactive) {
+            await (0, seed_1.createMulmoScriptWithInteractive)({ outDirPath, templateName: template, urls: urls, filename });
+        }
+        else if (urls.length > 0) {
+            await (0, seed_from_url_1.createMulmoScriptFromUrl)({ urls, templateName: template, outDirPath, filename });
+        }
+        else {
+            throw new Error("urls is required when not in interactive mode");
+        }
+    }
+    else if (action === "prompt") {
+        await (0, dump_prompt_1.dumpPromptFromTemplate)({ templateName: template });
+    }
+    else {
+        throw new Error(`Unknown or unsupported action: ${action}`);
+    }
+};
+main().catch((error) => {
+    console.error("An unexpected error occurred:", error);
+    process.exit(1);
+});

package/lib/methods/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./mulmo_script";
+export * from "./mulmo_script_template";
+export * from "./mulmo_studio_context";

package/lib/methods/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./mulmo_script"), exports);
+__exportStar(require("./mulmo_script_template"), exports);
+__exportStar(require("./mulmo_studio_context"), exports);

package/lib/methods/mulmo_script.d.ts

@@ -0,0 +1,11 @@
+import { MulmoDimension, MulmoScript, MulmoBeat, SpeechOptions } from "../types";
+export declare const MulmoScriptMethods: {
+    getPadding(script: MulmoScript): number;
+    getCanvasSize(script: MulmoScript): MulmoDimension;
+    getAspectRatio(script: MulmoScript): string;
+    getSpeechProvider(script: MulmoScript): string;
+    getImageProvider(script: MulmoScript): string;
+    getTextSlideStyle(script: MulmoScript, beat: MulmoBeat): string;
+    getSpeechOptions(script: MulmoScript, beat: MulmoBeat): SpeechOptions | undefined;
+    getText2imageAgent(script: MulmoScript): string;
+};

package/lib/methods/mulmo_script.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MulmoScriptMethods = void 0;
+const defaultTextSlideStyles = [
+    "body { margin: 40px; margin-top: 60px; color:#333; font-size: 48px }",
+    "h1 { font-size: 60px; text-align: center }",
+    "ul { margin-left: 40px } ",
+    "pre { margin-left: 40px; font-size: 32px }",
+    "p { margin-left: 40px }",
+    "table { font-size: 40px; margin: auto; border: 1px solid gray; border-collapse: collapse }",
+    "th { border-bottom: 1px solid gray }",
+    "td, th { padding: 8px }",
+    "tr:nth-child(even) { background-color: #eee }",
+];
+exports.MulmoScriptMethods = {
+    getPadding(script) {
+        return script.videoParams?.padding ?? 1000; // msec
+    },
+    getCanvasSize(script) {
+        return script.canvasSize ?? { width: 1280, height: 720 };
+    },
+    getAspectRatio(script) {
+        // Google's text2image specific parameter
+        const size = this.getCanvasSize(script);
+        return size.width > size.height ? "16:9" : "9:16";
+    },
+    getSpeechProvider(script) {
+        return script.speechParams?.provider ?? "openai";
+    },
+    getImageProvider(script) {
+        return script.imageParams?.provider ?? "openai";
+    },
+    getTextSlideStyle(script, beat) {
+        const styles = script.textSlideParams?.cssStyles ?? defaultTextSlideStyles;
+        // NOTES: Taking advantage of CSS override rule (you can redefine it to override)
+        const extraStyles = beat.textSlideParams?.cssStyles ?? [];
+        return [...styles, ...extraStyles].join("\n");
+    },
+    getSpeechOptions(script, beat) {
+        return { ...script.speechParams.speakers[beat.speaker].speechOptions, ...beat.speechOptions };
+    },
+    getText2imageAgent(script) {
+        return this.getImageProvider(script) === "google" ? "imageGoogleAgent" : "imageOpenaiAgent";
+    },
+};

package/lib/methods/mulmo_script_template.d.ts

@@ -0,0 +1,4 @@
+import { MulmoScriptTemplate } from "../types";
+export declare const MulmoScriptTemplateMethods: {
+    getSystemPrompt(template: MulmoScriptTemplate): string;
+};

package/lib/methods/mulmo_script_template.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MulmoScriptTemplateMethods = void 0;
+const zod_to_json_schema_1 = __importDefault(require("zod-to-json-schema"));
+const schema_1 = require("../types/schema");
+exports.MulmoScriptTemplateMethods = {
+    getSystemPrompt(template) {
+        // script is provided, use it as a script template
+        if (template.script) {
+            return `${template.systemPrompt}\n\`\`\`JSON\n${JSON.stringify(template.script)}\n\`\`\``;
+        }
+        // script is not provided, use the default schema
+        const defaultSchema = (0, zod_to_json_schema_1.default)(schema_1.mulmoScriptSchema, {
+            strictUnions: true,
+        });
+        const specificOutputPrompt = `The output should follow the JSON schema specified below. Please provide your response as valid JSON within \`\`\`json code blocks for clarity.`;
+        return `${template.systemPrompt}\n\n${specificOutputPrompt}\n\n\`\`\`JSON\n${JSON.stringify(defaultSchema)}\n\`\`\``;
+    },
+};

package/lib/methods/mulmo_studio_context.d.ts

@@ -0,0 +1,4 @@
+import { MulmoStudioContext } from "../types";
+export declare const MulmoStudioContextMethods: {
+    resolveAssetPath(context: MulmoStudioContext, relativePath: string): string;
+};

package/lib/methods/mulmo_studio_context.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MulmoStudioContextMethods = void 0;
+const path_1 = __importDefault(require("path"));
+exports.MulmoStudioContextMethods = {
+    resolveAssetPath(context, relativePath) {
+        return path_1.default.resolve(context.fileDirs.mulmoFileDirPath, relativePath);
+    },
+};

package/lib/tools/dump_prompt.d.ts

@@ -0,0 +1,3 @@
+export declare const dumpPromptFromTemplate: ({ templateName }: {
+    templateName: string;
+}) => Promise<void>;

package/lib/tools/dump_prompt.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dumpPromptFromTemplate = void 0;
+const file_1 = require("../utils/file");
+const dumpPromptFromTemplate = async ({ templateName }) => {
+    const prompt = (0, file_1.readTemplatePrompt)(templateName);
+    console.log(prompt);
+};
+exports.dumpPromptFromTemplate = dumpPromptFromTemplate;

package/lib/tools/prompt.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/tools/prompt.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const main = async () => {
+    const basePath = path_1.default.resolve(__dirname + "/../../prompts/");
+    const ret = {};
+    fs_1.default.readdirSync(basePath).map((file) => {
+        const key = file.split(".")[0];
+        const content = fs_1.default.readFileSync(path_1.default.resolve(basePath) + "/" + file, "utf-8");
+        ret[key] = content;
+    });
+    const code = ["// This file is auto-generated by src/tools/prompt.ts and Do not be edited manually.", `export const prompts = ${JSON.stringify(ret)};`].join("\n");
+    fs_1.default.writeFileSync(path_1.default.resolve(__dirname + "/../../src/agents/prompts_data.ts"), code, "utf8");
+    // console.log(hoge);
+};
+main();

package/lib/tools/seed.d.ts

@@ -0,0 +1,3 @@
+import "dotenv/config";
+import { ScriptingParams } from "../types";
+export declare const createMulmoScriptWithInteractive: ({ outDirPath, filename, templateName, urls }: ScriptingParams) => Promise<void>;

package/lib/tools/seed.js

@@ -0,0 +1,201 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMulmoScriptWithInteractive = void 0;
+require("dotenv/config");
+const graphai_1 = require("graphai");
+const input_agents_1 = require("@graphai/input_agents");
+const openai_agent_1 = require("@graphai/openai_agent");
+const vanilla = __importStar(require("@graphai/vanilla"));
+const vanilla_node_agents_1 = require("@graphai/vanilla_node_agents");
+const file_1 = require("../utils/file");
+const browserless_agent_1 = require("@graphai/browserless_agent");
+const agentHeader = "\x1b[34m● \x1b[0m\x1b[1mAgent\x1b[0m:\x1b[0m";
+const graphDataForScraping = {
+    version: 0.5,
+    nodes: {
+        urls: {
+            value: [],
+        },
+        fetchResults: {
+            agent: "mapAgent",
+            inputs: {
+                rows: ":urls",
+            },
+            params: {
+                compositeResult: true,
+            },
+            graph: {
+                nodes: {
+                    fetcher: {
+                        agent: "browserlessAgent",
+                        inputs: {
+                            url: ":row",
+                            text_content: true,
+                        },
+                    },
+                    copyAgent: {
+                        agent: "copyAgent",
+                        inputs: {
+                            text: '{ url: "${:row}", text: "${:fetcher.text}" }',
+                        },
+                        params: {
+                            namedKey: "text",
+                        },
+                        isResult: true,
+                    },
+                },
+            },
+        },
+        sourceText: {
+            agent: "arrayJoinAgent",
+            inputs: {
+                array: ":fetchResults.copyAgent",
+            },
+            params: {
+                separator: ",",
+            },
+            isResult: true,
+        },
+    },
+};
+const graphData = {
+    version: 0.5,
+    loop: {
+        while: ":continue",
+    },
+    nodes: {
+        fileName: {
+            update: ":fileName",
+        },
+        outdir: {
+            update: ":outdir",
+        },
+        messages: {
+            value: [],
+            update: ":llm.messages",
+        },
+        userInput: {
+            agent: "textInputAgent",
+            params: {
+                message: "You:",
+                required: true,
+            },
+        },
+        llm: {
+            agent: "openAIAgent",
+            params: {
+                model: "gpt-4o",
+            },
+            inputs: {
+                messages: ":messages",
+                prompt: ":userInput.text",
+            },
+        },
+        json: {
+            agent: "copyAgent",
+            inputs: {
+                json: ":llm.text.codeBlock().jsonParse()",
+                text: ":llm.text.codeBlock()",
+            },
+        },
+        writeJSON: {
+            if: ":json.json",
+            agent: "fileWriteAgent",
+            inputs: {
+                file: "${:outdir}/${:fileName}-${@now}.json",
+                text: ":json.text",
+            },
+        },
+        writeLog: {
+            agent: "consoleAgent",
+            inputs: {
+                text: "\n\x1b[32m🎉 Script file generated successfully! Type /bye to exit.\x1b[0m\nwriting: ${:writeJSON.path}",
+                waiting: ":writeJSON",
+            },
+        },
+        shouldResponse: {
+            agent: "compareAgent",
+            inputs: {
+                array: [[":json.json", "==", undefined], "&&", [":userInput.text", "!=", "/bye"]],
+            },
+        },
+        agentResponse: {
+            if: ":shouldResponse.result",
+            agent: "consoleAgent",
+            inputs: {
+                text: "\n" + agentHeader + " ${:llm.text}\n",
+            },
+        },
+        checkInput: {
+            agent: "compareAgent",
+            inputs: { array: [":userInput.text", "!=", "/bye"] },
+        },
+        continue: {
+            value: true,
+            update: ":checkInput.result",
+        },
+    },
+};
+const interactiveClarificationPrompt = `If there are any unclear points, be sure to ask the user questions and clarify them before generating the script.`;
+const scrapeWebContent = async (urls) => {
+    console.log(`${agentHeader} Scraping ${urls.length} URLs...\n`);
+    const graph = new graphai_1.GraphAI(graphDataForScraping, { ...vanilla, openAIAgent: openai_agent_1.openAIAgent, textInputAgent: input_agents_1.textInputAgent, fileWriteAgent: vanilla_node_agents_1.fileWriteAgent, browserlessAgent: browserless_agent_1.browserlessAgent });
+    graph.injectValue("urls", urls);
+    const result = (await graph.run());
+    if (!result?.sourceText?.text) {
+        return "";
+    }
+    const prefixPrompt = "Here is the web content that can be used as reference material for the script:";
+    return `\n\n${prefixPrompt}\n${result?.sourceText.text}`;
+};
+const createMulmoScriptWithInteractive = async ({ outDirPath, filename, templateName, urls }) => {
+    (0, file_1.mkdir)(outDirPath);
+    // if urls is not empty, scrape web content and reference it in the prompt
+    const webContentPrompt = urls.length > 0 ? await scrapeWebContent(urls) : "";
+    const graph = new graphai_1.GraphAI(graphData, { ...vanilla, openAIAgent: openai_agent_1.openAIAgent, textInputAgent: input_agents_1.textInputAgent, fileWriteAgent: vanilla_node_agents_1.fileWriteAgent });
+    const prompt = (0, file_1.readTemplatePrompt)(templateName);
+    graph.injectValue("messages", [
+        {
+            role: "system",
+            content: `${prompt}\n\n${interactiveClarificationPrompt}${webContentPrompt}`,
+        },
+    ]);
+    graph.injectValue("outdir", outDirPath);
+    graph.injectValue("fileName", filename);
+    console.log(`${agentHeader} Hi! What topic would you like me to generate about?\n`);
+    await graph.run();
+};
+exports.createMulmoScriptWithInteractive = createMulmoScriptWithInteractive;

package/lib/tools/seed_from_url.d.ts

@@ -0,0 +1,3 @@
+import "dotenv/config";
+import { ScriptingParams } from "../types";
+export declare const createMulmoScriptFromUrl: ({ urls, templateName, outDirPath, filename }: ScriptingParams) => Promise<void>;