redate-cli 0.2.0 → 0.2.2

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "redate-cli",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "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

@@ -5,60 +5,92 @@ 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 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" }) },
+    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" }) },
+    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);
-    }},
+    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_DIR)) {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+
     if (!fs.existsSync(CONFIG_FILE)) {
         fs.writeFileSync(
             CONFIG_FILE,
-            JSON.stringify({ format: DEFAULT_FORMAT }, null, 2)
+            JSON.stringify(DEFAULT_CONFIG, null, 2)
         );
     }
 }
 
 export function getConfig() {
     ensureConfig();
-    return JSON.parse(fs.readFileSync(CONFIG_FILE, "utf-8"));
+    const stored = JSON.parse(fs.readFileSync(CONFIG_FILE, "utf-8"));
+
+    return deepMerge(DEFAULT_CONFIG, stored);
 }
 
-export function setConfig(newConfig) {
-    ensureConfig();
-    fs.writeFileSync(CONFIG_FILE, JSON.stringify(newConfig, null, 2));
+export function setConfig(partialConfig) {
+    const current = getConfig();
+    const updated = deepMerge(current, partialConfig);
+
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(updated, null, 2));
+    return updated;
 }
 
-export const DEFAULT_FORMAT_VALUE = DEFAULT_FORMAT;
+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,7 +3,10 @@ import { Command } from "commander";
 import fs from "fs";
 import path from "path";
 import exifr from 'exifr';
-import { getConfig, setConfig, TOKENS } from "./config.js";
+import https from "https";
+import { execSync } from "child_process";
+import readline from "readline";
+import { getConfig, setConfig, TOKENS, DEFAULT_CONFIG } from "./config.js";
 
 
 const program = new Command();
@@ -11,7 +14,7 @@ const program = new Command();
 program
     .name("redate")
     .description("Rename images based on EXIF dates")
-    .version("0.1.1");
+    .version("0.2.2");
 
 program
     .command("process <paths...>")
@@ -34,106 +37,149 @@ program
             }
         }
     });
-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 configCommand = program
+    .command("config")
+    .description("Manage configuration");
+
+configCommand
+    .command("get [key]")
+    .action((key) => {
         const config = getConfig();
-        console.log(`Current format: ${config.format}`);
+        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}`);
     });
 
-formatCommand
+configCommand
     .command("reset")
-    .description("Reset format to default")
     .action(() => {
-        setConfig({ format: DEFAULT_FORMAT });
-        console.log(`Format reset to default: ${DEFAULT_FORMAT}`);
+        setConfig(DEFAULT_CONFIG);
+        console.log("Config reset to defaults");
     });
 
-program.parse(process.argv);
-
 
+program
+    .command("update")
+    .description("Check for newer version and update globally")
+    .action(async () => {
+        try {
+            const currentVersion = program.version();
 
+            const latestVersion = await getLatestVersionFromNpm("redate-cli");
 
-async function processFiles(folderPath) {
-    const files = fs.readdirSync(folderPath);
+            if (!latestVersion) {
+                console.error("Could not check latest version.");
+                return;
+            }
 
-    for (const file of files) {
-        const filePath = path.join(folderPath, file);
+            if (latestVersion === currentVersion) {
+                console.log(`You are already using the latest version (${currentVersion}).`);
+                return;
+            }
 
-        if (!fs.statSync(filePath).isFile()) continue;
+            console.log(`New version available: ${latestVersion}`);
+            console.log(`Current version: ${currentVersion}`);
 
-        try {
-            const date = await getDateFromFile(filePath);
+            const shouldUpdate = await askYesNo("Update globally now? (y/n): ");
 
-            if (!date) {
-                console.log(`No EXIF date found for file: ${filePath}`);
-                continue;
+            if (!shouldUpdate) {
+                console.log("Update cancelled.");
+                return;
             }
 
-            const newFileName = formatFileName(date, file);
-            fs.renameSync(filePath, path.join(folderPath, newFileName));
-            console.log(`Renamed to: ${newFileName}`);
+            console.log("Updating...");
+            execSync("npm install -g redate", { stdio: "inherit" });
 
+            console.log("Update completed.");
         } catch (err) {
-            console.log(`Skipped (unsupported or invalid): ${filePath}`);
+            console.error("Update failed:", err.message);
+        }
+    });
+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)));
+    }
+};
+
+
+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()) continue;
+
+        processFile(filePath, config);
     }
 }
 
 
 
-async function processFile(filePath) {
-    if (!fs.existsSync(filePath) || !fs.statSync(filePath).isFile()) {
-        console.error(`File does not exist: ${filePath}`);
-        return;
+async function processFile(filePath, config) {
+    if (!config || config == null) {
+        config = getConfig();
     }
 
-    console.log(`Processing file: ${filePath}`);
+    const date = await getDateFromFile(filePath);
+    if (!date) return;
 
-    try {
-        const date = await getDateFromFile(filePath);
+    const originalName = path.basename(filePath);
+    const newFileName = formatFileName(date, originalName, config);
 
-        if (!date) {
-            console.log(`No EXIF date found for file: ${filePath}`);
-            return;
-        }
+    applyFileHandling(filePath, newFileName, config);
 
-        const dir = path.dirname(filePath);
-        const originalName = path.basename(filePath);
-        const newFileName = formatFileName(date, originalName);
+    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];
 
-        fs.renameSync(filePath, path.join(dir, newFileName));
-        console.log(`Renamed to: ${newFileName}`);
-    } catch (err) {
-        console.error(`Error reading EXIF data from ${filePath}: ${err}`);
+    if (!handler) {
+        throw new Error(`Unknown fileHandling: ${config.fileHandling}`);
     }
-}
 
+    handler(srcPath, dest);
+}
 
 
-export function formatFileName(date, originalName) {
-    const config = getConfig();
+export function formatFileName(date, originalName, config) {
     let formatted = config.format;
 
-    for (const key in TOKENS) {
-        if (formatted.includes(key)) {
-            formatted = formatted.replaceAll(key, TOKENS[key].value(date));
-        }
+    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);
@@ -162,4 +208,42 @@ async function getDateFromFile(filePath) {
     const offsetMs = sign * (h * 60 + m) * 60_000;
 
     return new Date(date.getTime() + offsetMs);
+}
+
+
+function getLatestVersionFromNpm(packageName) {
+    return new Promise((resolve, reject) => {
+        https
+            .get(`https://registry.npmjs.org/${packageName}/latest`, (res) => {
+                let data = "";
+
+                res.on("data", (chunk) => {
+                    data += chunk;
+                });
+
+                res.on("end", () => {
+                    try {
+                        const json = JSON.parse(data);
+                        resolve(json.version);
+                    } catch (e) {
+                        reject(e);
+                    }
+                });
+            })
+            .on("error", reject);
+    });
+}
+
+function askYesNo(question) {
+    return new Promise((resolve) => {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim().toLowerCase() === "y");
+        });
+    });
 }