mulmocast 0.0.15 → 0.0.16

package/lib/tools/deep_research.js

@@ -0,0 +1,265 @@
+import "dotenv/config";
+import { GraphAILogger, GraphAI } from "graphai";
+import { textInputAgent } from "@graphai/input_agents";
+import { consoleStreamDataAgentFilter } from "@graphai/stream_agent_filter/node";
+import { openAIAgent } from "@graphai/openai_agent";
+import * as agents from "@graphai/vanilla";
+import tavilySearchAgent from "../agents/tavily_agent.js";
+import { cliLoadingPlugin } from "../utils/plugins.js";
+import { searchQueryPrompt, reflectionPrompt, finalAnswerPrompt } from "../utils/prompt.js";
+const vanillaAgents = agents.default ?? agents;
+const agentHeader = "\x1b[34m● \x1b[0m\x1b[1mAgent\x1b[0m:\x1b[0m";
+const graphData = {
+    version: 0.5,
+    nodes: {
+        maxRetries: {
+            value: 0,
+        },
+        userInput: {
+            agent: "textInputAgent",
+            params: {
+                message: "You:",
+                required: true,
+            },
+        },
+        startMessage: {
+            agent: "consoleAgent",
+            inputs: {
+                text: `\n${agentHeader} It takes a few minutes to gather resources, analyze data, and create a report.`,
+                userInput: ":userInput.text",
+            },
+        },
+        deepResearch: {
+            agent: "nestedAgent",
+            inputs: {
+                userInput: ":userInput.text",
+                maxRetries: ":maxRetries",
+                startMessage: ":startMessage",
+            },
+            graph: {
+                loop: {
+                    while: ":continue",
+                },
+                nodes: {
+                    searchResults: {
+                        value: [],
+                        update: ":reducer.array",
+                    },
+                    followUpQueries: {
+                        value: [],
+                        update: ":reflectionAgent.follow_up_queries",
+                    },
+                    counter: {
+                        value: 0,
+                        update: ":counter.add(1)",
+                    },
+                    searchQueryAgent: {
+                        agent: "openAIAgent",
+                        inputs: {
+                            model: "gpt-4o-mini",
+                            system: "You are a professional research assistant. Based on the user's inquiry, return the search query to be used for the search engine.",
+                            prompt: searchQueryPrompt("${:userInput}", "${:followUpQueries.join(,)}"),
+                        },
+                        params: {
+                            tool_choice: "auto",
+                            tools: [
+                                {
+                                    type: "function",
+                                    function: {
+                                        name: "search_query",
+                                        description: "Return the search queries to be used for the search engine.",
+                                        parameters: {
+                                            type: "object",
+                                            properties: {
+                                                queries: {
+                                                    type: "array",
+                                                    items: {
+                                                        type: "string",
+                                                        description: "A search query to be used for the search engine.",
+                                                    },
+                                                    description: "An array of search queries to be used for the search engine.",
+                                                },
+                                                research_topic: {
+                                                    type: "string",
+                                                    description: "The topic of the research. This is used to filter the search results.",
+                                                },
+                                                analysis_plan: {
+                                                    type: "string",
+                                                    description: "A detailed plan for analyzing the research topic, including main areas to investigate, key factors, and specific aspects that need deeper investigation",
+                                                },
+                                            },
+                                            required: ["queries", "research_topic", "analysis_plan"],
+                                        },
+                                    },
+                                },
+                            ],
+                        },
+                        output: {
+                            queries: ".tool.arguments.queries",
+                            research_topic: ".tool.arguments.research_topic",
+                            analysis_plan: ".tool.arguments.analysis_plan",
+                        },
+                    },
+                    logSearchQuery: {
+                        agent: "consoleAgent",
+                        inputs: {
+                            text: "\n" + agentHeader + " ${:searchQueryAgent.analysis_plan}",
+                        },
+                    },
+                    mapSearchAgent: {
+                        agent: "mapAgent",
+                        inputs: {
+                            rows: ":searchQueryAgent.queries",
+                        },
+                        params: {
+                            compositeResult: true,
+                        },
+                        graph: {
+                            nodes: {
+                                tavilySearchAgent: {
+                                    agent: "tavilySearchAgent",
+                                    inputs: {
+                                        query: ":row",
+                                    },
+                                    params: {
+                                        max_results: 3,
+                                    },
+                                },
+                                result: {
+                                    agent: "copyAgent",
+                                    inputs: {
+                                        results: ":tavilySearchAgent.results",
+                                    },
+                                    params: {
+                                        namedKey: "results",
+                                    },
+                                    isResult: true,
+                                },
+                                logSearchStatus: {
+                                    agent: ({ result }) => {
+                                        GraphAILogger.info(result.map((r) => `- [${r.title}](${r.url})`).join("\n"));
+                                    },
+                                    inputs: {
+                                        result: ":result",
+                                    },
+                                },
+                            },
+                        },
+                    },
+                    extractResults: {
+                        agent: "copyAgent",
+                        inputs: {
+                            results: ":mapSearchAgent.result.flat()",
+                        },
+                        params: {
+                            namedKey: "results",
+                        },
+                    },
+                    reflectionAgent: {
+                        agent: "openAIAgent",
+                        inputs: {
+                            model: "gpt-4o-mini",
+                            system: "You are a professional research assistant. Based on the user's inquiry and the search results, return the sufficiency of information, knowledge gaps, and follow-up queries as a function call.",
+                            prompt: reflectionPrompt("${:searchQueryAgent.research_topic}", "${:reducer.array.toJSON()}"),
+                        },
+                        params: {
+                            tool_choice: "auto",
+                            tools: [
+                                {
+                                    type: "function",
+                                    function: {
+                                        name: "research_sufficiency",
+                                        description: "Return whether the information is sufficient, any knowledge gaps, and follow-up queries for the user's inquiry.",
+                                        parameters: {
+                                            type: "object",
+                                            properties: {
+                                                is_sufficient: {
+                                                    type: "boolean",
+                                                    description: "Whether the information is sufficient",
+                                                },
+                                                knowledge_gap: {
+                                                    type: "string",
+                                                    description: "Summary of missing knowledge or information",
+                                                },
+                                                follow_up_queries: {
+                                                    type: "array",
+                                                    items: {
+                                                        type: "string",
+                                                        description: "Additional questions to investigate (up to 3 maximum)",
+                                                    },
+                                                },
+                                            },
+                                            required: ["is_sufficient", "knowledge_gap", "follow_up_queries"],
+                                        },
+                                    },
+                                },
+                            ],
+                        },
+                        output: {
+                            is_sufficient: ".tool.arguments.is_sufficient",
+                            knowledge_gap: ".tool.arguments.knowledge_gap",
+                            follow_up_queries: ".tool.arguments.follow_up_queries",
+                        },
+                    },
+                    reducer: {
+                        agent: "pushAgent",
+                        inputs: {
+                            array: ":searchResults",
+                            items: ":extractResults",
+                        },
+                    },
+                    continue: {
+                        agent: ({ is_sufficient, knowledge_gap, counter, maxRetries, }) => {
+                            if (is_sufficient || counter >= maxRetries - 1) {
+                                GraphAILogger.info(`\n${agentHeader} All necessary information has been gathered. Preparing comprehensive report.`);
+                                return false;
+                            }
+                            GraphAILogger.info(`\n${agentHeader} ${knowledge_gap}`);
+                            return true;
+                        },
+                        inputs: {
+                            is_sufficient: ":reflectionAgent.is_sufficient",
+                            knowledge_gap: ":reflectionAgent.knowledge_gap",
+                            counter: ":counter",
+                            maxRetries: ":maxRetries",
+                        },
+                    },
+                    finalAnswer: {
+                        agent: "openAIAgent",
+                        unless: ":continue",
+                        inputs: {
+                            model: "gpt-4o-mini",
+                            system: "You are a professional research assistant. Based on the user's inquiry and the search results, return the final answer.",
+                            prompt: finalAnswerPrompt("${:userInput}", "${:searchResults.toJSON()}", "${:searchQueryAgent.research_topic}"),
+                        },
+                        isResult: true,
+                    },
+                },
+            },
+        },
+        writeResult: {
+            agent: "consoleAgent",
+            inputs: {
+                text: "\n------Answer------\n\n${:deepResearch.finalAnswer.text}\n",
+            },
+        },
+    },
+};
+export const deepResearch = async () => {
+    const agentFilters = [
+        {
+            name: "consoleStreamDataAgentFilter",
+            agent: consoleStreamDataAgentFilter,
+            nodeIds: ["chatAgent"],
+        },
+    ];
+    const graph = new GraphAI(graphData, { ...vanillaAgents, openAIAgent, textInputAgent, tavilySearchAgent }, { agentFilters });
+    graph.injectValue("maxRetries", 3);
+    graph.registerCallback(cliLoadingPlugin({ nodeId: "searchQueryAgent", message: "Generating search queries..." }));
+    graph.registerCallback(cliLoadingPlugin({ nodeId: "reflectionAgent", message: "Analyzing search results..." }));
+    graph.registerCallback(cliLoadingPlugin({ nodeId: "tavilySearchAgent", message: "Searching..." }));
+    graph.registerCallback(cliLoadingPlugin({ nodeId: "finalAnswer", message: "Generating final answer..." }));
+    GraphAILogger.info(`${agentHeader} What would you like to know?\n`);
+    await graph.run();
+};
+deepResearch();

package/lib/types/schema.d.ts

@@ -49,6 +49,37 @@ export declare const speechOptionsSchema: z.ZodObject<{
     instruction?: string | undefined;
 }>;
 export declare const text2SpeechProviderSchema: z.ZodDefault<z.ZodUnion<[z.ZodLiteral<"openai">, z.ZodLiteral<"nijivoice">, z.ZodLiteral<"google">, z.ZodLiteral<"elevenlabs">]>>;
+export declare const speakerDataSchema: z.ZodObject<{
+    displayName: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    voiceId: z.ZodString;
+    speechOptions: z.ZodOptional<z.ZodObject<{
+        speed: z.ZodOptional<z.ZodNumber>;
+        instruction: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        speed?: number | undefined;
+        instruction?: string | undefined;
+    }, {
+        speed?: number | undefined;
+        instruction?: string | undefined;
+    }>>;
+    provider: z.ZodOptional<z.ZodDefault<z.ZodUnion<[z.ZodLiteral<"openai">, z.ZodLiteral<"nijivoice">, z.ZodLiteral<"google">, z.ZodLiteral<"elevenlabs">]>>>;
+}, "strict", z.ZodTypeAny, {
+    voiceId: string;
+    displayName?: Record<string, string> | undefined;
+    speechOptions?: {
+        speed?: number | undefined;
+        instruction?: string | undefined;
+    } | undefined;
+    provider?: "openai" | "nijivoice" | "google" | "elevenlabs" | undefined;
+}, {
+    voiceId: string;
+    displayName?: Record<string, string> | undefined;
+    speechOptions?: {
+        speed?: number | undefined;
+        instruction?: string | undefined;
+    } | undefined;
+    provider?: "openai" | "nijivoice" | "google" | "elevenlabs" | undefined;
+}>;
 export declare const speakerDictionarySchema: z.ZodRecord<z.ZodString, z.ZodObject<{
     displayName: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     voiceId: z.ZodString;

package/lib/types/schema.js

@@ -21,7 +21,7 @@ export const speechOptionsSchema = z
     .strict();
 const speakerIdSchema = z.string();
 export const text2SpeechProviderSchema = z.union([z.literal("openai"), z.literal("nijivoice"), z.literal("google"), z.literal("elevenlabs")]).default("openai");
-const speakerDataSchema = z
+export const speakerDataSchema = z
     .object({
     displayName: z.record(langSchema, z.string()).optional(),
     voiceId: z.string(),

package/lib/types/type.d.ts

@@ -1,4 +1,4 @@
-import { langSchema, localizedTextSchema, mulmoBeatSchema, mulmoScriptSchema, mulmoStudioSchema, mulmoStudioBeatSchema, mulmoStoryboardSchema, mulmoStoryboardSceneSchema, mulmoStudioMultiLingualSchema, mulmoStudioMultiLingualDataSchema, speakerDictionarySchema, mulmoImageParamsSchema, mulmoMovieParamsSchema, mulmoSpeechParamsSchema, textSlideParamsSchema, speechOptionsSchema, mulmoCanvasDimensionSchema, mulmoScriptTemplateSchema, mulmoScriptTemplateFileSchema, text2ImageProviderSchema, text2MovieProviderSchema, text2SpeechProviderSchema, mulmoPresentationStyleSchema, multiLingualTextsSchema, mulmoMermaidMediaSchema, mulmoTextSlideMediaSchema, mulmoMarkdownMediaSchema, mulmoImageMediaSchema, mulmoChartMediaSchema, mediaSourceSchema, mulmoSessionStateSchema } from "./schema.js";
+import { langSchema, localizedTextSchema, mulmoBeatSchema, mulmoScriptSchema, mulmoStudioSchema, mulmoStudioBeatSchema, mulmoStoryboardSchema, mulmoStoryboardSceneSchema, mulmoStudioMultiLingualSchema, mulmoStudioMultiLingualDataSchema, speakerDictionarySchema, mulmoImageParamsSchema, mulmoMovieParamsSchema, mulmoSpeechParamsSchema, textSlideParamsSchema, speechOptionsSchema, speakerDataSchema, mulmoCanvasDimensionSchema, mulmoScriptTemplateSchema, mulmoScriptTemplateFileSchema, text2ImageProviderSchema, text2MovieProviderSchema, text2SpeechProviderSchema, mulmoPresentationStyleSchema, multiLingualTextsSchema, mulmoMermaidMediaSchema, mulmoTextSlideMediaSchema, mulmoMarkdownMediaSchema, mulmoImageMediaSchema, mulmoChartMediaSchema, mediaSourceSchema, mulmoSessionStateSchema } from "./schema.js";
 import { pdf_modes, pdf_sizes, storyToScriptGenerateMode } from "../utils/const.js";
 import { LLM } from "../utils/utils.js";
 import { z } from "zod";
@@ -7,6 +7,7 @@ export type MulmoBeat = z.infer<typeof mulmoBeatSchema>;
 export type SpeakerDictonary = z.infer<typeof speakerDictionarySchema>;
 export type MulmoSpeechParams = z.infer<typeof mulmoSpeechParamsSchema>;
 export type SpeechOptions = z.infer<typeof speechOptionsSchema>;
+export type SpeakerData = z.infer<typeof speakerDataSchema>;
 export type MulmoImageParams = z.infer<typeof mulmoImageParamsSchema>;
 export type TextSlideParams = z.infer<typeof textSlideParamsSchema>;
 export type Text2ImageProvider = z.infer<typeof text2ImageProviderSchema>;
@@ -49,6 +50,7 @@ export type MulmoStudioContext = {
     force: boolean;
     caption?: string;
     sessionState: MulmoSessionState;
+    presentationStyle: MulmoPresentationStyle;
 };
 export type ScriptingParams = {
     urls: string[];

package/lib/utils/ffmpeg_utils.d.ts

@@ -10,3 +10,4 @@ export declare const FfmpegContextPushFormattedAudio: (context: FfmpegContext, s
 export declare const FfmpegContextInputFormattedAudio: (context: FfmpegContext, input: string, duration?: number | undefined) => string;
 export declare const FfmpegContextGenerateOutput: (context: FfmpegContext, output: string, options?: string[]) => Promise<number>;
 export declare const ffmpegGetMediaDuration: (filePath: string) => Promise<number>;
+export declare const extractImageFromMovie: (movieFile: string, imagePath: string) => Promise<void>;

package/lib/utils/ffmpeg_utils.js

@@ -61,3 +61,13 @@ export const ffmpegGetMediaDuration = (filePath) => {
         });
     });
 };
+export const extractImageFromMovie = (movieFile, imagePath) => {
+    return new Promise((resolve, reject) => {
+        ffmpeg(movieFile)
+            .outputOptions(["-frames:v 1"])
+            .output(imagePath)
+            .on("end", () => resolve())
+            .on("error", (err) => reject(err))
+            .run();
+    });
+};

package/lib/utils/file.d.ts

@@ -19,9 +19,7 @@ export declare const fetchMulmoScriptFile: (url: string) => Promise<{
 }>;
 export declare const getOutputStudioFilePath: (outDirPath: string, fileName: string) => string;
 export declare const resolveDirPath: (dirPath: string, studioFileName: 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, lang?: string) => string;
+export declare const getAudioFilePath: (audioDirPath: string, dirName: string, fileName: string, lang?: string) => string;
 export declare const getAudioArtifactFilePath: (outDirPath: string, fileName: string) => string;
 export declare const getOutputVideoFilePath: (outDirPath: string, fileName: string, lang?: string, caption?: string) => string;
 export declare const getOutputPdfFilePath: (outDirPath: string, fileName: string, pdfMode: PDFMode, lang?: string) => string;

package/lib/utils/file.js

@@ -59,18 +59,11 @@ export const getOutputStudioFilePath = (outDirPath, fileName) => {
 export const resolveDirPath = (dirPath, studioFileName) => {
     return path.resolve(dirPath, studioFileName);
 };
-// TODO: probably better to just use resolveDirPath instead.
-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, lang) => {
+export const getAudioFilePath = (audioDirPath, dirName, fileName, lang) => {
     if (lang) {
-        return path.resolve(audioDirPath, fileName, `${fileName}_${lang}.mp3`);
+        return path.resolve(audioDirPath, dirName, `${fileName}_${lang}.mp3`);
     }
-    return path.resolve(audioDirPath, fileName, fileName + ".mp3");
+    return path.resolve(audioDirPath, dirName, fileName + ".mp3");
 };
 export const getAudioArtifactFilePath = (outDirPath, fileName) => {
     return path.resolve(outDirPath, fileName + ".mp3");
@@ -98,7 +91,7 @@ export const mkdir = (dirPath) => {
 // export const silentPath = path.resolve(npmRoot, "./assets/audio/silent300.mp3");
 // export const silentLastPath = path.resolve(npmRoot, "./assets/audio/silent800.mp3");
 export const silent60secPath = () => path.resolve(npmRoot, "./assets/audio/silent60sec.mp3");
-export const defaultBGMPath = () => path.resolve(npmRoot, "./assets/music/StarsBeyondEx.mp3");
+export const defaultBGMPath = () => "https://github.com/receptron/mulmocast-media/raw/refs/heads/main/bgms/story002.mp3";
 export const getHTMLFile = (filename) => {
     const htmlPath = path.resolve(npmRoot, `./assets/html/${filename}.html`);
     return fs.readFileSync(htmlPath, "utf-8");

package/lib/utils/preprocess.js

@@ -39,6 +39,7 @@ const mulmoCredit = (speaker) => {
 export const createOrUpdateStudioData = (_mulmoScript, currentStudio, fileName) => {
     const mulmoScript = _mulmoScript.__test_invalid__ ? _mulmoScript : mulmoScriptSchema.parse(_mulmoScript); // validate and insert default value
     const studio = rebuildStudio(currentStudio, mulmoScript, fileName);
+    // TODO: Move this code out of this function later
     // Addition cloing credit
     if (mulmoScript.$mulmocast.credit === "closing") {
         mulmoScript.beats.push(mulmoCredit(mulmoScript.beats[0].speaker)); // First speaker

package/lib/utils/prompt.d.ts

@@ -14,3 +14,6 @@ export declare const sceneToBeatsPrompt: ({ sampleBeats, beatsPerScene, allScene
 }) => string;
 export declare const storyToScriptInfoPrompt: (scriptWithoutBeats: Omit<MulmoScript, "beats">, story: MulmoStoryboard) => string;
 export declare const storyToScriptPrompt: (script: MulmoScript, beatsPerScene: number, story: MulmoStoryboard) => string;
+export declare const searchQueryPrompt: (inquiry: string, followUpQueries: string) => string;
+export declare const reflectionPrompt: (researchTopic: string, searchResults: string) => string;
+export declare const finalAnswerPrompt: (userInput: string, searchResults: string, researchTopic: string) => string;

package/lib/utils/prompt.js

@@ -72,3 +72,55 @@ Only include keys that exist in the sample script.
 Do not add any keys that are not present in the sample script.
 Please provide your response as valid JSON within \`\`\`json code blocks for clarity.`.trim();
 };
+export const searchQueryPrompt = (inquiry, followUpQueries) => {
+    return `
+  You are a professional research assistant specialized in generating sophisticated and diverse web search queries.
+  Create queries for advanced automated web research tools that can analyze complex results, follow links, and integrate information.
+
+  Instructions:
+  - Ensure collection of the latest information (current date: ${new Date().toLocaleDateString()})
+  - Always prioritize a single search query, add additional ones only when the original question requires multiple aspects
+  - Each query should focus on a specific aspect of the original question
+  - Do not generate more than 3 queries
+  - Generate diverse queries when the topic is broad
+  - Do not generate multiple similar queries, one is sufficient
+  - If follow-up queries exist, prioritize them over the user's inquiry
+
+  User's inquiry: ${inquiry}
+  Follow-up queries: ${followUpQueries}
+  `;
+};
+export const reflectionPrompt = (researchTopic, searchResults) => {
+    return `
+  You are a professional research assistant analyzing summaries related to "${researchTopic}".
+
+  Instructions:
+  - Identify knowledge gaps and areas requiring deeper exploration, then generate follow-up queries
+  - If the provided summary is sufficient to answer the user's question, do not generate follow-up queries
+  - When knowledge gaps exist, generate follow-up queries that help deepen understanding
+  - Focus on technical details, implementation specifications, and emerging trends that are not fully covered
+
+  Requirements:
+  - Follow-up queries should be self-contained and include necessary context for web search
+
+  Search results: ${searchResults}
+  `;
+};
+export const finalAnswerPrompt = (userInput, searchResults, researchTopic) => {
+    const currentDate = new Date().toLocaleDateString();
+    return `
+  You are a professional research assistant. Generate a high-quality answer based on the following information.
+
+  Instructions:
+  - Utilize all provided information to create a logical and well-structured response
+  - Include article information (URL and title) as citations in your output when referencing search results
+  - Provide detailed technical specifications and implementation details where possible
+  - Reflect the latest information and trends
+  - Ensure the response is comprehensive and accurate
+
+  User's Question: ${userInput}
+  Search Results: ${searchResults}
+  Research Topic: ${researchTopic}
+  Current Date: ${currentDate}
+  `;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mulmocast",
-  "version": "0.0.15",
+  "version": "0.0.16",
   "description": "",
   "type": "module",
   "main": "lib/index.js",
@@ -10,7 +10,6 @@
   "files": [
     "./lib",
     "./scripts/templates",
-    "./assets/music/StarsBeyondEx.mp3",
     "./assets/audio/silent60sec.mp3",
     "./assets/html/",
     "./assets/templates/"
@@ -38,7 +37,8 @@
     "schema": "npx tsx ./src/cli/bin.ts tool schema",
     "story_to_script": "npx tsx ./src/cli/bin.ts tool story_to_script",
     "latest": "yarn upgrade-interactive  --latest",
-    "format": "prettier --write '{src,scripts,assets/templates,draft,ideason,scripts_mag2,proto,test,graphai,output,docs/scripts}/**/*.{ts,json,yaml}'"
+    "format": "prettier --write '{src,scripts,assets/templates,assets/styles,draft,ideason,scripts_mag2,proto,test,graphai,output,docs/scripts}/**/*.{ts,json,yaml}'",
+    "deep_research": "npx tsx ./src/tools/deep_research.ts"
   },
   "repository": "git+ssh://git@github.com/receptron/mulmocast-cli.git",
   "author": "snakajima",
@@ -58,6 +58,7 @@
     "@graphai/stream_agent_filter": "^2.0.2",
     "@graphai/vanilla": "^2.0.4",
     "@graphai/vanilla_node_agents": "^2.0.1",
+    "@tavily/core": "^0.5.7",
     "canvas": "^3.1.0",
     "clipboardy": "^4.0.0",
     "dotenv": "^16.4.7",