redate-cli 0.1.1 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "redate-cli",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "A CLI tool for renaming images based on EXIF data.",
   "type": "module",
   "main": "src/redate.js",

package/src/config.js

@@ -0,0 +1,64 @@
+import os from "os";
+import path from "path";
+import fs from "fs";
+
+const CONFIG_DIR = path.join(os.homedir(), ".redate");
+const CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+
+const DEFAULT_FORMAT = "yyyy-mm-dd hh-min-ss";
+
+export const TOKENS = {
+    yyyy: { desc: "4-digit year", value: (date) => date.getFullYear() },
+    yy:   { desc: "2-digit year", value: (date) => String(date.getFullYear()).slice(-2) },
+    mm:   { desc: "Month with leading zero", value: (date) => String(date.getMonth() + 1).padStart(2, "0") },
+    m:    { desc: "Month without leading zero", value: (date) => date.getMonth() + 1 },
+    mmm:  { desc: "Short month name", value: (date) => date.toLocaleString("en-US", { month: "short" }) },
+    mmmm: { desc: "Full month name", value: (date) => date.toLocaleString("en-US", { month: "long" }) },
+    dd:   { desc: "Day with leading zero", value: (date) => String(date.getDate()).padStart(2, "0") },
+    d:    { desc: "Day without leading zero", value: (date) => date.getDate() },
+    ddd:  { desc: "Day short name", value: (date) => date.toLocaleString("en-US", { weekday: "short" }) },
+    dddd: { desc: "Day full name", value: (date) => date.toLocaleString("en-US", { weekday: "long" }) },
+    hh:   { desc: "Hour 00–23", value: (date) => String(date.getHours()).padStart(2, "0") },
+    h:    { desc: "Hour 0–23", value: (date) => date.getHours() },
+    H:    { desc: "Hour 1–12", value: (date) => ((date.getHours() + 11) % 12 + 1) },
+    HH:   { desc: "Hour 01–12", value: (date) => String((date.getHours() + 11) % 12 + 1).padStart(2,"0") },
+    a:    { desc: "AM/PM", value: (date) => date.getHours() < 12 ? "AM" : "PM" },
+    A:    { desc: "am/pm", value: (date) => date.getHours() < 12 ? "am" : "pm" },
+    min:  { desc: "Minutes with leading zero", value: (date) => String(date.getMinutes()).padStart(2, "0") },
+    m_:   { desc: "Minutes without leading zero", value: (date) => date.getMinutes() },
+    ss:   { desc: "Seconds with leading zero", value: (date) => String(date.getSeconds()).padStart(2, "0") },
+    s:    { desc: "Seconds without leading zero", value: (date) => date.getSeconds() },
+    ms:   { desc: "Milliseconds", value: (date) => date.getMilliseconds() },
+    w:    { desc: "Week of year", value: (date) => {
+        const start = new Date(date.getFullYear(), 0, 1);
+        const diff = (date - start) + ((start.getDay() + 6) % 7) * 86400000;
+        return Math.floor(diff / (7 * 86400000)) + 1;
+    }},
+    D:    { desc: "Day of year", value: (date) => {
+        const start = new Date(date.getFullYear(), 0, 0);
+        const diff = date - start;
+        return Math.floor(diff / 86400000);
+    }},
+};
+
+function ensureConfig() {
+    if (!fs.existsSync(CONFIG_DIR)) fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    if (!fs.existsSync(CONFIG_FILE)) {
+        fs.writeFileSync(
+            CONFIG_FILE,
+            JSON.stringify({ format: DEFAULT_FORMAT }, null, 2)
+        );
+    }
+}
+
+export function getConfig() {
+    ensureConfig();
+    return JSON.parse(fs.readFileSync(CONFIG_FILE, "utf-8"));
+}
+
+export function setConfig(newConfig) {
+    ensureConfig();
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(newConfig, null, 2));
+}
+
+export const DEFAULT_FORMAT_VALUE = DEFAULT_FORMAT;

package/src/redate.js

@@ -3,6 +3,7 @@ import { Command } from "commander";
 import fs from "fs";
 import path from "path";
 import exifr from 'exifr';
+import { getConfig, setConfig, TOKENS } from "./config.js";
 
 
 const program = new Command();
@@ -10,12 +11,12 @@ const program = new Command();
 program
     .name("redate")
     .description("Rename images based on EXIF dates")
-    .version("0.1.1")
-    .argument("[paths...]", "File(s) or folder(s) to process")
-    .action((paths) => {
-        if (!paths || paths.length === 0) {
-            program.help({ error: true });
-        }
+    .version("0.1.1");
+
+program
+    .command("process <paths...>")
+    .description("Process file(s) or folder(s)")
+    .action(async (paths) => {
         for (const p of paths) {
             if (!fs.existsSync(p)) {
                 console.error(`Path does not exist: ${p}`);
@@ -23,81 +24,135 @@ program
             }
 
             const stats = fs.statSync(p);
+
             if (stats.isFile()) {
-                processFile(p);
+                await processFile(p);
             } else if (stats.isDirectory()) {
-                processFiles(p);
+                await processFiles(p);
             } else {
                 console.error(`Unsupported path type: ${p}`);
             }
         }
     });
+const DEFAULT_FORMAT = "yyyy-mm-dd hh-min-ss";
+
+const formatCommand = program
+    .command("format")
+    .description("Manage date format");
+
+formatCommand
+    .command("set <format>")
+    .description("Set global date format")
+    .action((format) => {
+        setConfig({ format });
+        console.log(`Format set to: ${format}`);
+    });
+
+formatCommand
+    .command("get")
+    .description("Show current global date format")
+    .action(() => {
+        const config = getConfig();
+        console.log(`Current format: ${config.format}`);
+    });
+
+formatCommand
+    .command("reset")
+    .description("Reset format to default")
+    .action(() => {
+        setConfig({ format: DEFAULT_FORMAT });
+        console.log(`Format reset to default: ${DEFAULT_FORMAT}`);
+    });
 
 program.parse(process.argv);
 
 
 
-function processFiles(folderPath) {
+
+async function processFiles(folderPath) {
     const files = fs.readdirSync(folderPath);
+
     for (const file of files) {
         const filePath = path.join(folderPath, file);
-        if (fs.statSync(filePath).isFile()) {
-            getDateFromFile(filePath).then((date) => {
-                if (date) {
-                    const newFileName = formatFileName(date, file);
-                    fs.renameSync(filePath, path.join(folderPath, newFileName));
-                    console.log(`Renamed to: ${newFileName}`);
-                }
-            }).catch((err) => {
-                console.error(`Error reading EXIF data from ${filePath}: ${err}`);
-            });
-        }
-    }
-}
 
+        if (!fs.statSync(filePath).isFile()) continue;
 
+        try {
+            const date = await getDateFromFile(filePath);
 
-function processFile(filePath) {
-    if (fs.existsSync(filePath) && fs.statSync(filePath).isFile()) {
-        console.log(`Processing file: ${filePath}`);
-        getDateFromFile(filePath).then((date) => {
-            if (date) {
-                const dir = path.dirname(filePath);
-                const originalName = path.basename(filePath);
-                const newFileName = formatFileName(date, originalName);
-                fs.renameSync(filePath, path.join(dir, newFileName));
-                console.log(`Renamed to: ${newFileName}`);
-            } else {
+            if (!date) {
                 console.log(`No EXIF date found for file: ${filePath}`);
+                continue;
             }
-        }).catch((err) => {
-            console.error(`Error reading EXIF data from ${filePath}: ${err}`);
-        });
+
+            const newFileName = formatFileName(date, file);
+            fs.renameSync(filePath, path.join(folderPath, newFileName));
+            console.log(`Renamed to: ${newFileName}`);
+
+        } catch (err) {
+            console.log(`Skipped (unsupported or invalid): ${filePath}`);
+        }
     }
-    else {
+}
+
+
+
+async function processFile(filePath) {
+    if (!fs.existsSync(filePath) || !fs.statSync(filePath).isFile()) {
         console.error(`File does not exist: ${filePath}`);
+        return;
     }
-}
 
+    console.log(`Processing file: ${filePath}`);
 
-function formatFileName(date, originalName) {
-    const yyyy = date.getFullYear();
-    const mm = String(date.getMonth() + 1).padStart(2, '0');
-    const dd = String(date.getDate()).padStart(2, '0');
-    const hh = String(date.getHours()).padStart(2, '0');
-    const min = String(date.getMinutes()).padStart(2, '0');
-    const ss = String(date.getSeconds()).padStart(2, '0');
-    const ext = path.extname(originalName);
+    try {
+        const date = await getDateFromFile(filePath);
 
-    return `${yyyy}-${mm}-${dd} ${hh}-${min}-${ss}${ext}`;
+        if (!date) {
+            console.log(`No EXIF date found for file: ${filePath}`);
+            return;
+        }
+
+        const dir = path.dirname(filePath);
+        const originalName = path.basename(filePath);
+        const newFileName = formatFileName(date, originalName);
+
+        fs.renameSync(filePath, path.join(dir, newFileName));
+        console.log(`Renamed to: ${newFileName}`);
+    } catch (err) {
+        console.error(`Error reading EXIF data from ${filePath}: ${err}`);
+    }
 }
 
 
+
+export function formatFileName(date, originalName) {
+    const config = getConfig();
+    let formatted = config.format;
+
+    for (const key in TOKENS) {
+        if (formatted.includes(key)) {
+            formatted = formatted.replaceAll(key, TOKENS[key].value(date));
+        }
+    }
+
+    const ext = path.extname(originalName);
+    return `${formatted}${ext}`;
+}
 async function getDateFromFile(filePath) {
     const exif = await exifr.parse(filePath, { reviveValues: true });
-    if (!exif?.DateTimeOriginal) return null;
 
-    const date = exif.DateTimeOriginal;
+
+    const date =
+        exif?.DateTimeOriginal ||
+        exif?.CreateDate ||
+        exif?.ModifyDate;
+
+    if (!date) {
+        console.error(`No EXIF date found for file: ${filePath}`);
+        return null;
+    };
+
     const offset = exif.OffsetTimeOriginal;
 
     if (!offset) return date;