refactor(tools): lazy-create media metadata dirs and remove try/catch

Create data/<type> only when writing first YAML; replace exception-based flow with existence checks and simplify template loading and main flow.

tools/generate_metadata_files.js

@@ -1,4 +1,5 @@
 const fs = require('fs/promises');
+const fsSync = require('fs');
 const path = require('path');
 const readline = require('readline');
 
@@ -8,6 +9,7 @@ const MEDIA_TYPES = ['images', 'sounds', 'videos'];
 
 function askQuestion(query) {
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+
   return new Promise(resolve => rl.question(query, answer => { rl.close(); resolve(answer.trim()); }));
 }
 
@@ -16,12 +18,16 @@ async function findLatestBundle(dir) {
 
   async function search(current) {
     const entries = await fs.readdir(current, { withFileTypes: true });
+
     for (const entry of entries) {
       const fullPath = path.join(current, entry.name);
+
       if (entry.isDirectory()) {
         const hasIndex = (await fs.readdir(fullPath)).includes('index.md');
+
         if (hasIndex) {
           const stat = await fs.stat(fullPath);
+
           if (stat.mtimeMs > latest.time) {
             latest = { path: fullPath, time: stat.mtimeMs };
           }
@@ -33,72 +39,82 @@ async function findLatestBundle(dir) {
   }
 
   await search(dir);
+
   return latest.path;
 }
 
 async function loadTemplate() {
-  try {
-    const content = await fs.readFile(TEMPLATE_PATH, 'utf8');
-    return content;
-  } catch (err) {
-    console.error(`Error loading template from ${TEMPLATE_PATH}`);
-    throw err;
-  }
+  return fs.readFile(TEMPLATE_PATH, 'utf8');
 }
 
 async function generateYamlFiles(bundlePath, yamlTemplate) {
   console.log(`\nProcessing bundle: ${bundlePath}`);
+
   for (const type of MEDIA_TYPES) {
     const mediaDir = path.join(bundlePath, type);
     const dataDir = path.join(bundlePath, 'data', type);
-    try {
-      await fs.mkdir(dataDir, { recursive: true });
-    } catch {}
 
-    let files;
-    try {
-      files = await fs.readdir(mediaDir);
-    } catch {
+    let dataDirEnsured = false; // Create lazily only if a YAML file must be written
+
+    if (!fsSync.existsSync(mediaDir)) {
       console.log(`Skipped: no folder "${type}" found.`);
+
       continue;
     }
 
+    const files = await fs.readdir(mediaDir);
+
     for (const file of files) {
       const ext = path.extname(file);
+
       if (!ext) {
         console.log(`Ignored: ${file} (no extension)`);
+
         continue;
       }
+
       const yamlName = path.basename(file, ext) + '.yaml';
       const yamlPath = path.join(dataDir, yamlName);
 
-      try {
-        await fs.access(yamlPath);
+      if (fsSync.existsSync(yamlPath)) {
         console.log(`Skipped: ${yamlPath} (already exists)`);
+
         continue;
-      } catch {
-        await fs.writeFile(yamlPath, yamlTemplate, 'utf8');
-        console.log(`Created: ${yamlPath}`);
       }
+
+      if (!dataDirEnsured) {
+        await fs.mkdir(dataDir, { recursive: true });
+
+        dataDirEnsured = true;
+      }
+
+      await fs.writeFile(yamlPath, yamlTemplate, 'utf8');
+
+      console.log(`Created: ${yamlPath}`);
     }
   }
 }
 
 async function main() {
   const manualPath = process.argv[2];
+
   let bundle;
 
   if (manualPath) {
     bundle = path.resolve(manualPath);
   } else {
     const latest = await findLatestBundle(CONTENT_DIR);
+
     if (!latest) {
       console.error('No bundle found in content/.');
       return;
     }
+
     const confirm = await askQuestion(`Use latest bundle found: ${latest}? (Y/n) `);
+
     if (confirm.toLowerCase() === 'n') {
       const inputPath = await askQuestion('Enter the relative path to your bundle: ');
+
       bundle = path.resolve(inputPath);
     } else {
       bundle = latest;
@@ -106,9 +122,8 @@ async function main() {
   }
 
   const template = await loadTemplate();
+
   await generateYamlFiles(bundle, template);
 }
 
-main().catch(err => {
-  console.error('Error:', err);
-});
+main();