From 67abb253cbf985e584395b51828ab12cfb842b89 Mon Sep 17 00:00:00 2001
From: Ken Yasue <ken@yasue.us>
Date: Sat, 16 Aug 2025 13:11:45 +0200
Subject: [PATCH] save current changes

---
 src/index.ts | 86 ++++++++++++++++++++++++++++++++++------------------
 1 file changed, 56 insertions(+), 30 deletions(-)

diff --git a/src/index.ts b/src/index.ts
index 92b8c6f..b063144 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -4,18 +4,18 @@ import { generateImage } from './lib/image-generator';
 import { generateVideo } from './lib/video-generator';
 import { logger } from './lib/logger';
 
-async function generateVideoFromKeyword(keyword: string) {
+async function prepareImageForKeyword(keyword: string): Promise<{ keyword: string; generatedImagePath: string } | null> {
     const numberOfPages = 1;
     const imagePaths = await downloadPinterestImages(keyword, numberOfPages);
-    logger.debug('Downloaded images:', imagePaths);
+    logger.debug(`Downloaded ${imagePaths.length} images for keyword: ${keyword}`);
 
     if (imagePaths.length === 0) {
-        logger.warn('No images downloaded, cannot proceed.');
-        return;
+        logger.warn(`No images downloaded for keyword "${keyword}", cannot proceed.`);
+        return null;
     }
 
     const randomImagePath = imagePaths[Math.floor(Math.random() * imagePaths.length)];
-    logger.debug(`Randomly selected image: ${randomImagePath}`);
+    logger.debug(`Randomly selected image for "${keyword}": ${randomImagePath}`);
 
     try {
         const imagePromptResponse = await describeImage(randomImagePath,
@@ -24,18 +24,26 @@ async function generateVideoFromKeyword(keyword: string) {
             Output should be in this format
             ---
             {
-                "prompt":""
+                "prompt":"Ultra detialed realistic photo, {result comes here}"
             }
             ---
             `);
         const imagePrompt = imagePromptResponse.prompt;
-        logger.debug(`Description for ${randomImagePath}:`, imagePrompt);
+        logger.info(`Description for ${randomImagePath}:`, imagePrompt);
 
         const timestamp = new Date().getTime();
         const imageFileName = `${keyword.replace(/\s/g, '_')}_${timestamp}.png`;
         const generatedImagePath = await generateImage(imagePrompt, imageFileName);
         logger.debug(`Generated new image from prompt, saved to: ${generatedImagePath}`);
+        return { keyword, generatedImagePath };
+    } catch (error) {
+        logger.error(`Failed to process ${randomImagePath} for keyword "${keyword}":`, error);
+        return null;
+    }
+}
 
+async function generateVideoFromImagePath(keyword: string, generatedImagePath: string) {
+    try {
         const videoPromptResponse = await describeImage(generatedImagePath,
             `Generate a prompt for an 8-second video based on the provided image.
             The prompt should describe a dynamic scene that evolves from the static image.
@@ -47,43 +55,61 @@ async function generateVideoFromKeyword(keyword: string) {
             ---
             `);
         const videoPrompt = videoPromptResponse.prompt;
-        logger.debug(`Generated video prompt: ${videoPrompt}`);
+        logger.info(`Generated video prompt for ${generatedImagePath}: ${videoPrompt}`);
 
+        const timestamp = new Date().getTime();
         const videoFileName = `${keyword.replace(/\s/g, '_')}_${timestamp}.mp4`;
         const generatedVideoPath = await generateVideo(videoPrompt, generatedImagePath, videoFileName);
         logger.debug(`Generated video from prompt, saved to: ${generatedVideoPath}`);
     } catch (error) {
-        logger.error(`Failed to process ${randomImagePath}:`, error);
+        logger.error(`Failed to generate video for ${generatedImagePath}:`, error);
     }
 }
 
-(async () => {
-    while (1) {
-        const keywords = [
-            "beautiful woman portrait",
-            "handsome man candid",
-            "interesting street photography",
-            "stunning landscape",
-            "vibrant city nightlife",
-            "elegant fashion model",
-            "captivating eyes",
-            "fantasy landscape",
-            "RPG character art",
-            "high fashion model",
-            "city nightscape",
-            "fireworks display",
-            "nebula space art",
-            "3D abstract render"
-        ];
 
+(async () => {
+    const keywords = [
+        "beautiful woman portrait",
+        "handsome man candid",
+        "interesting street photography",
+        "stunning landscape",
+        "vibrant city nightlife",
+        "elegant fashion model",
+        "fantasy landscape",
+        "RPG character art",
+        "high fashion model",
+        "city nightscape",
+        "fireworks display",
+        "nebula space art",
+        "3D abstract render"
+    ];
+
+    while (1) {
+        const preparedImages = [];
+        logger.info('--- Starting image preparation phase ---');
         for (const keyword of keywords) {
             const startTime = Date.now();
-            logger.info(`--- Starting process for keyword: ${keyword} ---`);
-            await generateVideoFromKeyword(keyword);
+            logger.info(`--- Preparing image for keyword: ${keyword} ---`);
+            const result = await prepareImageForKeyword(keyword);
+            if (result) {
+                preparedImages.push(result);
+            }
             const endTime = Date.now();
             const durationInSeconds = (endTime - startTime) / 1000;
-            logger.info(`--- Finished process for keyword: ${keyword} in ${durationInSeconds.toFixed(2)} seconds ---`);
+            logger.info(`--- Finished preparing image for keyword: ${keyword} in ${durationInSeconds.toFixed(2)} seconds ---`);
         }
+        logger.info('--- Finished image preparation phase ---');
+
+        logger.info('--- Starting video generation phase ---');
+        for (const { keyword, generatedImagePath } of preparedImages) {
+            const startTime = Date.now();
+            logger.info(`--- Generating video for keyword: ${keyword} ---`);
+            await generateVideoFromImagePath(keyword, generatedImagePath);
+            const endTime = Date.now();
+            const durationInSeconds = (endTime - startTime) / 1000;
+            logger.info(`--- Finished generating video for keyword: ${keyword} in ${durationInSeconds.toFixed(2)} seconds ---`);
+        }
+        logger.info('--- Finished video generation phase ---');
     }
 
 })();