redate-cli 0.1.1 → 0.2.1

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "redate-cli",
-  "version": "0.1.1",
+  "version": "0.2.1",
   "description": "A CLI tool for renaming images based on EXIF data.",
   "type": "module",
   "main": "src/redate.js",
   "bin": {
     "redate": "./src/redate.js"
   },
+  "scripts": {
+    "redate": "node ./src/redate.js"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/niilopoutanen/redate.git"

package/src/config.js

@@ -0,0 +1,96 @@
+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");
+
+export const DEFAULT_CONFIG = {
+    format: "yyyy-mm-dd hh-min-ss",
+
+    fileHandling: "rename" // rename, copy, copy_in_folder
+};
+
+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(DEFAULT_CONFIG, null, 2)
+        );
+    }
+}
+
+export function getConfig() {
+    ensureConfig();
+    const stored = JSON.parse(fs.readFileSync(CONFIG_FILE, "utf-8"));
+
+    return deepMerge(DEFAULT_CONFIG, stored);
+}
+
+export function setConfig(partialConfig) {
+    const current = getConfig();
+    const updated = deepMerge(current, partialConfig);
+
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(updated, null, 2));
+    return updated;
+}
+
+function deepMerge(target, source) {
+    const output = { ...target };
+
+    for (const key of Object.keys(source)) {
+        if (
+            typeof source[key] === "object" &&
+            source[key] !== null &&
+            !Array.isArray(source[key])
+        ) {
+            output[key] = deepMerge(target[key] || {}, source[key]);
+        } else {
+            output[key] = source[key];
+        }
+    }
+
+    return output;
+}

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, DEFAULT_CONFIG } 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.2.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,138 @@ 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 configCommand = program
+    .command("config")
+    .description("Manage configuration");
+
+configCommand
+    .command("get [key]")
+    .action((key) => {
+        const config = getConfig();
+        if (!key) {
+            console.log(config);
+            return;
+        }
+
+        console.log(config[key]);
+    });
+
+configCommand
+    .command("set <key> <value>")
+    .action((key, value) => {
+        setConfig({ [key]: value });
+        console.log(`${key} updated to ${value}`);
+    });
+
+configCommand
+    .command("reset")
+    .action(() => {
+        setConfig(DEFAULT_CONFIG);
+        console.log("Config reset to defaults");
+    });
 program.parse(process.argv);
 
 
+const fileHandlers = {
+    rename: (src, dest) => {
+        fs.renameSync(src, dest);
+    },
+
+    copy: (src, dest) => {
+        fs.copyFileSync(src, dest);
+    },
+
+    copy_in_folder: (src, dest) => {
+        const dir = path.dirname(src);
+        const targetDir = path.join(dir, "redate");
+        if (!fs.existsSync(targetDir)) {
+            fs.mkdirSync(targetDir);
+        }
+        fs.copyFileSync(src, path.join(targetDir, path.basename(dest)));
+    }
+};
 
-function processFiles(folderPath) {
+
+async function processFiles(folderPath) {
     const files = fs.readdirSync(folderPath);
+    const config = getConfig();
     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;
+
+        processFile(filePath, config);
     }
 }
 
 
 
-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 {
-                console.log(`No EXIF date found for file: ${filePath}`);
-            }
-        }).catch((err) => {
-            console.error(`Error reading EXIF data from ${filePath}: ${err}`);
-        });
-    }
-    else {
-        console.error(`File does not exist: ${filePath}`);
+async function processFile(filePath, config) {
+    if (!config || config == null) {
+        config = getConfig();
     }
+
+    const date = await getDateFromFile(filePath);
+    if (!date) return;
+
+    const originalName = path.basename(filePath);
+    const newFileName = formatFileName(date, originalName, config);
+
+    applyFileHandling(filePath, newFileName, config);
+
+    console.log(`Processed: ${newFileName}`);
 }
+function applyFileHandling(srcPath, newFileName, config) {
+    const dir = path.dirname(srcPath);
+    const dest = path.join(dir, newFileName);
 
+    const handler = fileHandlers[config.fileHandling];
 
-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);
+    if (!handler) {
+        throw new Error(`Unknown fileHandling: ${config.fileHandling}`);
+    }
 
-    return `${yyyy}-${mm}-${dd} ${hh}-${min}-${ss}${ext}`;
+    handler(srcPath, dest);
 }
 
 
+export function formatFileName(date, originalName, config) {
+    let formatted = config.format;
+
+    const sortedTokens = Object.keys(TOKENS).sort((a, b) => b.length - a.length);
+
+    for (const key of sortedTokens) {
+        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;