backdot 1.4.0 → 1.6.0

package/README.md

@@ -4,7 +4,7 @@
 
 <h1 align="center">backdot</h1>
 
-<p align="center">Automated backup of important files (configs, dotfiles, gitignored files) to your own private Git repo.</p>
+<p align="center">Automated backup of important files (configs, dotfiles) to your own private Git repo.</p>
 
 ## Getting started
 
@@ -19,7 +19,6 @@ This creates `~/.backdot.json` with sensible defaults and walks you through setu
 {
   "repository": "git@github.com:USERNAME/backdot-backup.git",
   "machine": "my-work-laptop",
-  "gitignored": ["~/my-project"],
   "paths": ["~/.zshrc", "~/.oh-my-zsh/custom/*.zsh", "~/.ssh/config", "~/.npmrc"]
 }
 ```
@@ -38,21 +37,31 @@ backdot --schedule
 
 ## Configuration
 
-| Key          | Description                                            |
-| ------------ | ------------------------------------------------------ |
-| `gitignored` | Directories to scan for gitignored files               |
-| `paths`      | Glob patterns matching individual files or directories |
+| Key     | Description                                            |
+| ------- | ------------------------------------------------------ |
+| `paths` | Glob patterns matching individual files or directories |
+
+Prefix a pattern with `!` to exclude matching files:
+
+```json
+{
+  "paths": ["~/.config/ghostty/**", "!~/.config/ghostty/crash-reports/**"]
+}
+```
 
 ## Commands
 
-| Command        | Description                                            |
-| -------------- | ------------------------------------------------------ |
-| `--init`       | Set up backdot for the first time                      |
-| `--backup`     | Run a backup now                                       |
-| `--restore`    | Restore files to their original locations              |
-| `--schedule`   | Schedule automatic daily backup via launchd (Mac-only) |
-| `--unschedule` | Remove the daily schedule                              |
-| `--status`     | Show schedule and resolved file list                   |
+| Command                          | Description                                    |
+| -------------------------------- | ---------------------------------------------- |
+| `--init`                         | Set up backdot for the first time              |
+| `--backup`                       | Run a backup now                               |
+| `--restore`                      | Restore latest backup from the configured repo |
+| `--restore <url>`                | Restore from a specific repo URL               |
+| `--restore [url] --commit <sha>` | Restore from a specific backup commit          |
+| `--history [url]`                | Browse and restore a previous backup           |
+| `--schedule`                     | Schedule automatic daily backup (Mac-only)     |
+| `--unschedule`                   | Unschedule the daily backup                    |
+| `--status`                       | Show schedule and resolved file list           |
 
 ## Development
 

package/dist/cli.js

@@ -1,16 +1,15 @@
 #!/usr/bin/env node
 import fs from "node:fs";
-import os from "node:os";
 import path from "node:path";
+import { parseArgs } from "node:util";
 import chalk from "chalk";
-import ora from "ora";
-import { loadConfig, CONFIG_PATH } from "./config.js";
-import { resolveFiles } from "./resolve.js";
-import { cleanStaging, copyToStaging, writeRepoReadme, compareFiles } from "./staging.js";
-import { gitPull, gitCommitAndPush } from "./git.js";
-import { restore } from "./restore.js";
-import { init } from "./init.js";
-import { setupLaunchd, uninstallLaunchd, isScheduled } from "./plist.js";
+import { CONFIG_PATH } from "./config.js";
+import { backup } from "./commands/backup.js";
+import { status } from "./commands/status.js";
+import { schedule, unschedule } from "./commands/schedule.js";
+import { restore } from "./commands/restore.js";
+import { history } from "./commands/history.js";
+import { init } from "./commands/init.js";
 import { logger } from "./log.js";
 import { sendNotification } from "./notify.js";
 function getVersion() {
@@ -23,151 +22,83 @@ function getVersion() {
         return "unknown";
     }
 }
-async function backup() {
-    logger.info("Starting backup");
-    const config = loadConfig();
-    logger.info(`Repository: ${config.repository}`);
-    logger.info(`Machine: ${config.machine}`);
-    const spinner = ora("Resolving files").start();
-    try {
-        const userFiles = resolveFiles(config);
-        logger.info(`Resolved ${userFiles.length} file(s)`);
-        if (userFiles.length === 0) {
-            spinner.info("No files resolved, nothing to back up");
-            return;
-        }
-        const files = [...userFiles, CONFIG_PATH];
-        spinner.text = "Syncing with remote";
-        await gitPull(config.repository);
-        spinner.text = `Copying ${files.length} file(s) to staging`;
-        cleanStaging(config.machine);
-        copyToStaging(files, config.machine);
-        writeRepoReadme(config.repository);
-        spinner.text = "Pushing to remote";
-        const result = await gitCommitAndPush();
-        const successMsg = result?.commitUrl
-            ? `Backup complete → ${result.commitUrl}`
-            : "Backup complete";
-        spinner.succeed(successMsg);
-        console.log();
-    }
-    catch (err) {
-        spinner.fail("Backup failed");
-        throw err;
-    }
-    logger.info("Backup complete");
-}
-function tildePath(filePath) {
-    const home = os.homedir();
-    return filePath.startsWith(home) ? "~" + filePath.slice(home.length) : filePath;
-}
-async function status() {
-    const scheduled = isScheduled();
+function printHelp() {
+    console.log();
+    console.log("  Usage: backdot <command>");
     console.log();
-    console.log(`  Schedule:  ${scheduled ? "active (daily at 02:00)" : "not active"}`);
+    console.log("  Commands:");
+    console.log();
+    console.log("    --init                       Set up backdot for the first time");
+    console.log("    --backup                     Run a backup now");
+    console.log("    --restore [url]              Restore files from the backup repo");
+    console.log("    --restore [url] --commit <sha>  Restore from a specific backup commit");
+    console.log("    --restore [url] --yes (-y)      Accept defaults without prompting");
+    console.log("    --history [url]              Browse and restore a previous backup");
+    console.log("    --schedule                   Install daily backup schedule (macOS launchd)");
+    console.log("    --unschedule                 Remove the daily backup schedule");
+    console.log("    --status                     Show schedule and resolved files");
+    console.log("    --version                    Show version");
+    console.log();
+}
+async function main() {
+    let values;
+    let positionals;
     try {
-        const config = loadConfig();
-        console.log(`  Repo:      ${config.repository}`);
-        console.log(`  Machine:   ${config.machine}`);
-        console.log();
-        const spinner = ora("Resolving files").start();
-        const userFiles = resolveFiles(config);
-        if (userFiles.length === 0) {
-            spinner.warn("No files resolved. Check your ~/.backdot.json entries.");
-            console.log();
-            return;
-        }
-        const files = [...userFiles, CONFIG_PATH];
-        spinner.text = "Comparing with remote backup";
-        const { backedUp, modified, notBackedUp } = await compareFiles(files, config.machine);
-        spinner.stop();
-        if (modified.length === 0 && notBackedUp.length === 0) {
-            console.log(chalk.green(`  All ${files.length} file(s) are backed up ✓`));
-        }
-        else {
-            if (modified.length > 0) {
-                console.log(chalk.yellow(`  Modified since last backup (${modified.length}):`));
-                for (const f of modified) {
-                    console.log(`        ${tildePath(f)}`);
-                }
-                console.log();
-            }
-            if (notBackedUp.length > 0) {
-                console.log(chalk.red(`  Not yet backed up (${notBackedUp.length}):`));
-                for (const f of notBackedUp) {
-                    console.log(`        ${tildePath(f)}`);
-                }
-                console.log();
-            }
-            if (backedUp.length > 0) {
-                console.log(chalk.green(`  Backed up (${backedUp.length}):`));
-                for (const f of backedUp) {
-                    console.log(`        ${tildePath(f)}`);
-                }
-                console.log();
-            }
-            console.log(`  Run ${chalk.bold("backdot --backup")} to back up all changes.`);
-        }
+        ({ values, positionals } = parseArgs({
+            args: process.argv.slice(2),
+            options: {
+                init: { type: "boolean" },
+                backup: { type: "boolean" },
+                restore: { type: "boolean" },
+                history: { type: "boolean" },
+                schedule: { type: "boolean" },
+                unschedule: { type: "boolean" },
+                status: { type: "boolean" },
+                version: { type: "boolean" },
+                help: { type: "boolean" },
+                commit: { type: "string" },
+                yes: { type: "boolean", short: "y" },
+            },
+            allowPositionals: true,
+            strict: true,
+        }));
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
-        console.error(`\n  Config error: ${msg}`);
+        console.error(`\n  Error: ${msg}\n`);
+        printHelp();
         process.exit(1);
     }
-    console.log();
-}
-function requireMacOS() {
-    if (process.platform !== "darwin") {
-        throw new Error("Scheduling is only supported on macOS (launchd). Use cron or systemd on Linux.");
-    }
-}
-async function main() {
-    const args = process.argv.slice(2);
-    const command = args[0];
     try {
-        if (command === "--init") {
+        if (values.init) {
             init();
         }
-        else if (command === "--backup") {
+        else if (values.backup) {
             await backup();
         }
-        else if (command === "--schedule") {
-            requireMacOS();
-            setupLaunchd();
+        else if (values.schedule) {
+            schedule();
         }
-        else if (command === "--unschedule") {
-            requireMacOS();
-            uninstallLaunchd();
+        else if (values.unschedule) {
+            unschedule();
         }
-        else if (command === "--status") {
+        else if (values.status) {
             await status();
         }
-        else if (command === "--restore") {
-            await restore(args[1]);
+        else if (values.restore) {
+            await restore(positionals[0], values.commit, {
+                yes: !!values.yes,
+            });
         }
-        else if (command === "--version") {
+        else if (values.history) {
+            await history(positionals[0]);
+        }
+        else if (values.version) {
             console.log(getVersion());
         }
         else {
-            console.log();
-            console.log("  Usage: backdot <command>");
-            console.log();
-            console.log("  Commands:");
-            console.log();
-            console.log("    --init         Set up backdot for the first time");
-            console.log("    --backup       Run a backup now");
-            console.log("    --restore [url] Restore files from the backup repo");
-            console.log("    --schedule     Install daily backup schedule (macOS launchd)");
-            console.log("    --unschedule   Remove the daily backup schedule");
-            console.log("    --status       Show schedule and resolved files");
-            console.log("    --version      Show version");
-            console.log();
-            if (command && command !== "--help") {
-                console.error(`  Unknown command: ${command}`);
-                console.log();
-                process.exit(1);
-            }
-            else if (!fs.existsSync(CONFIG_PATH)) {
+            printHelp();
+            if (!fs.existsSync(CONFIG_PATH)) {
                 console.log(`  No config found. Run ${chalk.bold("backdot --init")} to get started.`);
                 console.log();
             }

package/dist/commands/backup.d.ts

@@ -0,0 +1 @@
+export declare function backup(): Promise<void>;

package/dist/commands/backup.js

@@ -0,0 +1,40 @@
+import ora from "ora";
+import { loadConfig, CONFIG_PATH } from "../config.js";
+import { resolveFiles } from "../resolve.js";
+import { cleanStaging, copyToStaging, writeRepoReadme } from "../staging.js";
+import { gitPull, gitCommitAndPush } from "../git.js";
+import { logger } from "../log.js";
+export async function backup() {
+    logger.info("Starting backup");
+    const config = loadConfig();
+    logger.info(`Repository: ${config.repository}`);
+    logger.info(`Machine: ${config.machine}`);
+    const spinner = ora("Resolving files").start();
+    try {
+        const userFiles = resolveFiles(config);
+        logger.info(`Resolved ${userFiles.length} file(s)`);
+        if (userFiles.length === 0) {
+            spinner.info("No files resolved, nothing to back up");
+            return;
+        }
+        const files = [...userFiles, CONFIG_PATH];
+        spinner.text = "Syncing with remote";
+        await gitPull(config.repository);
+        spinner.text = `Copying ${files.length} file(s) to staging`;
+        cleanStaging(config.machine);
+        copyToStaging(files, config.machine);
+        writeRepoReadme(config.repository);
+        spinner.text = "Pushing to remote";
+        const result = await gitCommitAndPush();
+        const successMsg = result?.commitUrl
+            ? `Backup complete → ${result.commitUrl}`
+            : "Backup complete";
+        spinner.succeed(successMsg);
+        console.log();
+    }
+    catch (err) {
+        spinner.fail("Backup failed");
+        throw err;
+    }
+    logger.info("Backup complete");
+}

package/dist/commands/history.d.ts

@@ -0,0 +1 @@
+export declare function history(repoUrl?: string): Promise<void>;

package/dist/commands/history.js

@@ -0,0 +1,28 @@
+import ora from "ora";
+import { select } from "@inquirer/prompts";
+import { loadConfig } from "../config.js";
+import { gitPull, gitLog } from "../git.js";
+import { restore } from "./restore.js";
+import { logger } from "../log.js";
+export async function history(repoUrl) {
+    logger.info("Starting history");
+    const repository = repoUrl ?? loadConfig().repository;
+    const spinner = ora("Fetching backup history").start();
+    await gitPull(repository);
+    const commits = await gitLog();
+    spinner.stop();
+    if (commits.length === 0) {
+        console.log("\n  No backup history found.\n");
+        return;
+    }
+    const selected = await select({
+        message: "Select a backup to restore from:",
+        loop: false,
+        choices: commits.map((c) => ({
+            name: `${c.hash.slice(0, 7)}  ${c.date.split("T")[0]}  ${c.message}`,
+            value: c.hash,
+        })),
+    });
+    console.log();
+    await restore(repoUrl, selected);
+}

package/dist/{init.js → commands/init.js}

@@ -1,11 +1,10 @@
 import fs from "node:fs";
 import os from "node:os";
 import chalk from "chalk";
-import { CONFIG_PATH } from "./config.js";
+import { CONFIG_PATH } from "../config.js";
 const TEMPLATE = {
     repository: "git@github.com:USERNAME/backdot-backup.git",
     machine: os.hostname(),
-    gitignored: [],
     paths: ["~/.zshrc", "~/.gitconfig"],
 };
 export function init() {

package/dist/commands/restore.d.ts

@@ -0,0 +1,5 @@
+interface RestoreOptions {
+    yes?: boolean;
+}
+export declare function restore(repoUrl?: string, commit?: string, options?: RestoreOptions): Promise<void>;
+export {};

package/dist/{restore.js → commands/restore.js}

@@ -2,11 +2,11 @@ import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
 import ora from "ora";
-import { checkbox, select } from "@inquirer/prompts";
-import { loadConfig } from "./config.js";
-import { gitPull } from "./git.js";
-import { STAGING_DIR, machineDir } from "./staging.js";
-import { logger } from "./log.js";
+import { checkbox, select, Separator } from "@inquirer/prompts";
+import { loadConfig } from "../config.js";
+import { gitPull } from "../git.js";
+import { STAGING_DIR, machineDir } from "../staging.js";
+import { logger } from "../log.js";
 const HOME = os.homedir();
 function walkDir(dir) {
     return fs
@@ -25,13 +25,13 @@ function listMachines() {
         .filter((e) => e.isDirectory() && e.name !== ".git")
         .map((e) => e.name);
 }
-async function resolveRepoAndMachine(repoUrl) {
+async function resolveRepoAndMachine(repoUrl, commit) {
     if (!repoUrl) {
         const config = loadConfig();
         return { repository: config.repository, machine: config.machine };
     }
     const spinner = ora("Cloning backup repository").start();
-    await gitPull(repoUrl);
+    await gitPull(repoUrl, commit);
     spinner.stop();
     const machines = listMachines();
     if (machines.length === 0) {
@@ -44,18 +44,19 @@ async function resolveRepoAndMachine(repoUrl) {
     else {
         machine = await select({
             message: "Multiple machines found. Which one do you want to restore?",
+            loop: false,
             choices: machines.map((m) => ({ name: m, value: m })),
         });
     }
     return { repository: repoUrl, machine };
 }
-export async function restore(repoUrl) {
+export async function restore(repoUrl, commit, options = {}) {
     logger.info("Starting restore");
-    const { repository, machine } = await resolveRepoAndMachine(repoUrl);
+    const { repository, machine } = await resolveRepoAndMachine(repoUrl, commit);
     const spinner = ora("Fetching latest backup").start();
     const baseDir = machineDir(machine);
     if (!repoUrl) {
-        await gitPull(repository);
+        await gitPull(repository, commit);
     }
     spinner.text = "Resolving files";
     if (!fs.existsSync(baseDir)) {
@@ -86,25 +87,29 @@ export async function restore(repoUrl) {
     logger.info(`${fresh.length} new, ${existing.length} already exist`);
     spinner.stop();
     console.log();
-    if (fresh.length > 0) {
-        console.log(`${fresh.length} new file(s) to restore:`);
-        console.log();
-        for (const f of fresh) {
-            console.log(`  ${f.rel}`);
-        }
-        console.log();
+    let toRestore;
+    if (options.yes) {
+        toRestore = fresh;
     }
-    let toRestore = fresh;
-    if (existing.length > 0) {
-        const selected = await checkbox({
-            message: `${existing.length} file(s) already exist. Select which to overwrite:`,
-            choices: existing.map((f) => ({
-                name: f.rel,
-                value: f,
-                checked: true,
-            })),
+    else {
+        const choices = [];
+        if (fresh.length > 0) {
+            choices.push(new Separator(`── New files (${fresh.length}) ──`));
+            for (const f of fresh) {
+                choices.push({ name: f.rel, value: f, checked: true });
+            }
+        }
+        if (existing.length > 0) {
+            choices.push(new Separator(`── Existing files — will overwrite (${existing.length}) ──`));
+            for (const f of existing) {
+                choices.push({ name: f.rel, value: f, checked: false });
+            }
+        }
+        toRestore = await checkbox({
+            message: "Select files to restore:",
+            loop: false,
+            choices,
         });
-        toRestore = [...fresh, ...selected];
         console.log();
     }
     if (toRestore.length === 0) {

package/dist/commands/schedule.d.ts

@@ -0,0 +1,2 @@
+export declare function schedule(): void;
+export declare function unschedule(): void;

package/dist/commands/schedule.js

@@ -0,0 +1,14 @@
+import { setupLaunchd, uninstallLaunchd } from "../plist.js";
+function requireMacOS() {
+    if (process.platform !== "darwin") {
+        throw new Error("Scheduling is only supported on macOS (launchd). Use cron or systemd on Linux.");
+    }
+}
+export function schedule() {
+    requireMacOS();
+    setupLaunchd();
+}
+export function unschedule() {
+    requireMacOS();
+    uninstallLaunchd();
+}

package/dist/commands/status.d.ts

@@ -0,0 +1 @@
+export declare function status(): Promise<void>;

package/dist/commands/status.js

@@ -0,0 +1,69 @@
+import os from "node:os";
+import chalk from "chalk";
+import ora from "ora";
+import { loadConfig, CONFIG_PATH } from "../config.js";
+import { resolveFiles } from "../resolve.js";
+import { compareFiles } from "../staging.js";
+import { isScheduled } from "../plist.js";
+function tildePath(filePath) {
+    const home = os.homedir();
+    return filePath.startsWith(home) ? "~" + filePath.slice(home.length) : filePath;
+}
+export async function status() {
+    const scheduled = isScheduled();
+    console.log();
+    console.log(`  Schedule:  ${scheduled ? "active (daily at 02:00)" : "not active"}`);
+    const config = loadConfig();
+    console.log(`  Repo:      ${config.repository}`);
+    console.log(`  Machine:   ${config.machine}`);
+    console.log();
+    const spinner = ora("Resolving files").start();
+    try {
+        const userFiles = resolveFiles(config);
+        if (userFiles.length === 0) {
+            spinner.warn("No files resolved. Check your ~/.backdot.json entries.");
+            console.log();
+            return;
+        }
+        const files = [...userFiles, CONFIG_PATH];
+        spinner.text = "Comparing with remote backup";
+        const { backedUp, modified, notBackedUp, error } = await compareFiles(files, config.machine);
+        spinner.stop();
+        if (error) {
+            console.log(chalk.yellow(`  Could not fetch status: ${error}`));
+            return;
+        }
+        if (modified.length === 0 && notBackedUp.length === 0) {
+            console.log(chalk.green(`  All ${files.length} file(s) are backed up ✓`));
+        }
+        else {
+            if (modified.length > 0) {
+                console.log(chalk.yellow(`  Modified since last backup (${modified.length}):`));
+                for (const f of modified) {
+                    console.log(`        ${tildePath(f)}`);
+                }
+                console.log();
+            }
+            if (notBackedUp.length > 0) {
+                console.log(chalk.red(`  Not yet backed up (${notBackedUp.length}):`));
+                for (const f of notBackedUp) {
+                    console.log(`        ${tildePath(f)}`);
+                }
+                console.log();
+            }
+            if (backedUp.length > 0) {
+                console.log(chalk.green(`  Backed up (${backedUp.length}):`));
+                for (const f of backedUp) {
+                    console.log(`        ${tildePath(f)}`);
+                }
+                console.log();
+            }
+            console.log(`  Run ${chalk.bold("backdot --backup")} to back up all changes.`);
+        }
+    }
+    catch (err) {
+        spinner.fail("Status check failed");
+        throw err;
+    }
+    console.log();
+}

package/dist/config.d.ts

@@ -4,8 +4,7 @@ export declare function expandTilde(p: string): string;
 declare const ConfigSchema: z.ZodObject<{
     repository: z.ZodString;
     machine: z.ZodString;
-    gitignored: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>>;
-    paths: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>>;
+    paths: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
 }, z.core.$strip>;
 export type Config = z.infer<typeof ConfigSchema>;
 export declare function loadConfig(): Config;

package/dist/config.js

@@ -4,21 +4,20 @@ import os from "node:os";
 import { z } from "zod";
 export const CONFIG_PATH = path.join(os.homedir(), ".backdot.json");
 export function expandTilde(p) {
+    if (p.startsWith("!")) {
+        return "!" + expandTilde(p.slice(1));
+    }
     if (p.startsWith("~/") || p === "~") {
         return path.join(os.homedir(), p.slice(1));
     }
     return p;
 }
-const pathList = z.array(z.string().min(1).transform(expandTilde)).optional().default([]);
-const ConfigSchema = z
-    .object({
+const ConfigSchema = z.object({
     repository: z.string().min(1),
     machine: z.string().min(1),
-    gitignored: pathList,
-    paths: pathList,
-})
-    .refine((c) => c.gitignored.length > 0 || c.paths.length > 0, {
-    message: 'At least one of "gitignored" or "paths" must be a non-empty array',
+    paths: z
+        .array(z.string().min(1).transform(expandTilde))
+        .min(1, '"paths" must be a non-empty array'),
 });
 export function loadConfig() {
     if (!fs.existsSync(CONFIG_PATH)) {

package/dist/git.d.ts

@@ -1,4 +1,20 @@
-export declare function gitPull(repository: string): Promise<void>;
+interface FileChangeSummary {
+    created: string[];
+    deleted: string[];
+    modified: string[];
+    renamed: Array<{
+        from: string;
+        to: string;
+    }>;
+}
+export declare function buildCommitMessage(changes: FileChangeSummary, maxLen?: number): string;
+export declare function gitPull(repository: string, commit?: string): Promise<void>;
+export declare function gitLog(limit?: number): Promise<Array<{
+    hash: string;
+    date: string;
+    message: string;
+}>>;
 export declare function gitCommitAndPush(): Promise<{
     commitUrl: string | null;
 } | null>;
+export {};

package/dist/git.js

@@ -5,12 +5,50 @@ import { simpleGit, CleanOptions } from "simple-git";
 import { logger } from "./log.js";
 import { STAGING_DIR } from "./staging.js";
 import { getCommitUrl } from "./commitUrl.js";
-export async function gitPull(repository) {
+export function buildCommitMessage(changes, maxLen = 250) {
+    const unique = (paths) => [...new Set(paths.map((f) => path.basename(f)))];
+    const removed = unique(changes.deleted);
+    const added = unique(changes.created);
+    const modified = unique([...changes.modified, ...changes.renamed.map((r) => r.to)]);
+    const categories = [
+        { label: "removed", files: removed },
+        { label: "added", files: added },
+        { label: "modified", files: modified },
+    ].filter((c) => c.files.length > 0);
+    if (categories.length === 0) {
+        return "backup";
+    }
+    function format(cat, listFiles) {
+        if (listFiles) {
+            return `${cat.label}: ${cat.files.join(", ")}`;
+        }
+        const n = cat.files.length;
+        return `${cat.label}: ${n} file${n !== 1 ? "s" : ""}`;
+    }
+    function build(listFlags) {
+        return categories.map((cat, i) => format(cat, listFlags[i])).join("; ");
+    }
+    const flags = categories.map(() => true);
+    let msg = build(flags);
+    if (msg.length <= maxLen)
+        return msg;
+    for (const label of ["modified", "added", "removed"]) {
+        const idx = categories.findIndex((c) => c.label === label);
+        if (idx !== -1 && flags[idx]) {
+            flags[idx] = false;
+            msg = build(flags);
+            if (msg.length <= maxLen)
+                return msg;
+        }
+    }
+    return msg.slice(0, maxLen - 3) + "...";
+}
+export async function gitPull(repository, commit) {
     if (fs.existsSync(path.join(STAGING_DIR, ".git"))) {
         const git = simpleGit(STAGING_DIR);
         await git.fetch("origin");
-        const branch = await git.revparse(["--abbrev-ref", "HEAD"]);
-        await git.reset(["--hard", `origin/${branch}`]);
+        const target = commit ?? `origin/${await git.revparse(["--abbrev-ref", "HEAD"])}`;
+        await git.reset(["--hard", target]);
         await git.clean(CleanOptions.FORCE, ["-d"]);
     }
     else {
@@ -23,9 +61,23 @@ export async function gitPull(repository) {
             await git.init();
             await git.addRemote("origin", repository);
         }
+        if (commit) {
+            const git = simpleGit(STAGING_DIR);
+            await git.reset(["--hard", commit]);
+            await git.clean(CleanOptions.FORCE, ["-d"]);
+        }
     }
     logger.info("Synced staging directory from remote");
 }
+export async function gitLog(limit = 20) {
+    const git = simpleGit(STAGING_DIR);
+    const log = await git.log({ maxCount: limit });
+    return log.all.map((entry) => ({
+        hash: entry.hash,
+        date: entry.date,
+        message: entry.message,
+    }));
+}
 export async function gitCommitAndPush() {
     const git = simpleGit(STAGING_DIR);
     await git.add(".");
@@ -34,8 +86,7 @@ export async function gitCommitAndPush() {
         logger.info("No changes to commit");
         return null;
     }
-    const date = new Date().toISOString().split("T")[0];
-    const message = `Automated backup: ${date}`;
+    const message = buildCommitMessage(status);
     await git.commit(message);
     await pRetry(async () => git.push(["-u", "origin", "HEAD"]), {
         retries: 5,
@@ -43,11 +94,17 @@ export async function gitCommitAndPush() {
             logger.info(`Push failed (attempt ${attemptNumber}, ${retriesLeft} retries left), rebasing`);
             await git.fetch("origin");
             const branch = (await git.revparse(["--abbrev-ref", "HEAD"])).trim();
-            await git.rebase([`origin/${branch}`]);
+            try {
+                await git.rebase([`origin/${branch}`]);
+            }
+            catch {
+                await git.rebase(["--abort"]);
+                throw new Error("Rebase conflict, aborting retry");
+            }
         },
     });
     logger.info(`Committed and pushed: ${message}`);
-    const sha = await git.revparse(["HEAD"]);
+    const sha = (await git.revparse(["HEAD"])).trim();
     const remoteUrl = (await git.remote(["get-url", "origin"])) ?? "";
     const commitUrl = getCommitUrl(remoteUrl, sha);
     return { commitUrl };

package/dist/log.js

@@ -1,7 +1,10 @@
+import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
 import winston from "winston";
-const LOG_FILE = path.join(os.homedir(), ".backdot", "backup.log");
+const LOG_DIR = path.join(os.homedir(), ".backdot");
+fs.mkdirSync(LOG_DIR, { recursive: true });
+const LOG_FILE = path.join(LOG_DIR, "backup.log");
 export const logger = winston.createLogger({
     level: "info",
     format: winston.format.combine(winston.format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }), winston.format.printf(({ timestamp, level, message }) => `${timestamp} [${level}] ${message}`)),

package/dist/notify.js

@@ -1,12 +1,18 @@
-import { execSync } from "node:child_process";
+import { execFileSync } from "node:child_process";
 import { logger } from "./log.js";
+function escapeAppleScript(str) {
+    return str.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
 export function sendNotification(title, message) {
     if (process.platform !== "darwin")
         return;
-    const escaped = message.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
-    const titleEscaped = title.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+    const escaped = escapeAppleScript(message);
+    const titleEscaped = escapeAppleScript(title);
     try {
-        execSync(`osascript -e 'display notification "${escaped}" with title "${titleEscaped}" subtitle "Scheduled backup failed"'`, { stdio: "pipe" });
+        execFileSync("osascript", [
+            "-e",
+            `display notification "${escaped}" with title "${titleEscaped}" subtitle "Scheduled backup failed"`,
+        ], { stdio: "pipe" });
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);

package/dist/plist.js

@@ -1,4 +1,4 @@
-import { execSync } from "node:child_process";
+import { execFileSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
@@ -50,7 +50,7 @@ export function isScheduled() {
         return false;
     }
     try {
-        const output = execSync(`launchctl list ${LABEL}`, { encoding: "utf-8", stdio: "pipe" });
+        const output = execFileSync("launchctl", ["list", LABEL], { encoding: "utf-8", stdio: "pipe" });
         return output.includes(LABEL);
     }
     catch {
@@ -65,7 +65,7 @@ export function setupLaunchd() {
         fs.mkdirSync(dir, { recursive: true });
     }
     try {
-        execSync(`launchctl unload ${PLIST_PATH}`, { stdio: "pipe" });
+        execFileSync("launchctl", ["unload", PLIST_PATH], { stdio: "pipe" });
     }
     catch {
         // Not loaded, that's fine
@@ -73,7 +73,7 @@ export function setupLaunchd() {
     fs.writeFileSync(PLIST_PATH, plistContent);
     logger.info(`Plist written to ${PLIST_PATH}`);
     try {
-        execSync(`launchctl load ${PLIST_PATH}`);
+        execFileSync("launchctl", ["load", PLIST_PATH], { stdio: "pipe" });
         spinner.succeed("Daily backup scheduled (02:00)");
         console.log();
         logger.info("Launchd job loaded");
@@ -83,13 +83,13 @@ export function setupLaunchd() {
         spinner.fail(`Failed to load launchd job: ${msg}`);
         console.log();
         logger.error(`Failed to load launchd job: ${msg}`);
-        process.exit(1);
+        throw new Error(`Failed to load launchd job: ${msg}`, { cause: err });
     }
 }
 export function uninstallLaunchd() {
     const spinner = ora("Removing schedule").start();
     try {
-        execSync(`launchctl unload ${PLIST_PATH}`, { stdio: "pipe" });
+        execFileSync("launchctl", ["unload", PLIST_PATH], { stdio: "pipe" });
         logger.info("Launchd job unloaded");
     }
     catch {

package/dist/resolve.js

@@ -1,34 +1,14 @@
-import { execSync } from "node:child_process";
 import fs from "node:fs";
-import path from "node:path";
 import fg from "fast-glob";
 import { logger } from "./log.js";
-function resolveGitignored(dirPath) {
-    if (!fs.existsSync(dirPath)) {
-        logger.warn(`Directory does not exist, skipping: ${dirPath}`);
+function resolveGlobs(patterns) {
+    if (patterns.length === 0)
         return [];
-    }
-    try {
-        const output = execSync("git ls-files --others --ignored --exclude-standard", {
-            cwd: dirPath,
-            encoding: "utf-8",
-        });
-        return output
-            .split("\n")
-            .filter((line) => line.length > 0)
-            .map((rel) => path.resolve(dirPath, rel));
-    }
-    catch {
-        logger.warn(`Failed to list gitignored files in: ${dirPath}`);
-        return [];
-    }
-}
-function resolveGlob(pattern) {
     try {
-        return fg.sync(pattern, { absolute: true, dot: true });
+        return fg.sync(patterns, { absolute: true, dot: true, onlyFiles: true });
     }
     catch {
-        logger.warn(`Glob pattern failed: ${pattern}`);
+        logger.warn("Glob pattern resolution failed");
         return [];
     }
 }
@@ -38,12 +18,7 @@ const LARGE_FILE_THRESHOLD = 10 * 1024 * 1024; // 10 MB
  * Skips entries that fail resolution and logs warnings.
  */
 export function resolveFiles(config) {
-    const unique = [
-        ...new Set([
-            ...config.gitignored.flatMap(resolveGitignored),
-            ...config.paths.flatMap(resolveGlob),
-        ]),
-    ];
+    const unique = [...new Set(resolveGlobs(config.paths))];
     return unique.filter((filePath) => {
         try {
             fs.accessSync(filePath, fs.constants.R_OK);

package/dist/staging.d.ts

@@ -7,6 +7,7 @@ export interface ComparisonResult {
     backedUp: string[];
     modified: string[];
     notBackedUp: string[];
+    error?: string;
 }
 export declare function compareFiles(files: string[], machine: string): Promise<ComparisonResult>;
 export declare function writeRepoReadme(repository: string): void;

package/dist/staging.js

@@ -38,25 +38,30 @@ export function copyToStaging(files, machine) {
     }
     logger.info(`Copied ${copied} file(s) to staging`);
 }
-const allNotBackedUp = (files) => ({
-    backedUp: [],
-    modified: [],
-    notBackedUp: files,
-});
+function failedComparisonResult(err) {
+    const errorMessage = err instanceof Error ? err.message : String(err);
+    return { backedUp: [], modified: [], notBackedUp: [], error: errorMessage };
+}
 export async function compareFiles(files, machine) {
     if (files.length === 0)
         return { backedUp: [], modified: [], notBackedUp: [] };
     const gitDir = path.join(STAGING_DIR, ".git");
-    if (!fs.existsSync(gitDir))
-        return allNotBackedUp(files);
+    if (!fs.existsSync(gitDir)) {
+        return failedComparisonResult(new Error("Backup repository not found. Run backdot --backup first."));
+    }
     const git = simpleGit(STAGING_DIR);
-    await git.fetch("origin");
+    try {
+        await git.fetch("origin");
+    }
+    catch (err) {
+        return failedComparisonResult(err);
+    }
     let branch;
     try {
         branch = (await git.revparse(["--abbrev-ref", "HEAD"])).trim();
     }
-    catch {
-        return allNotBackedUp(files);
+    catch (err) {
+        return failedComparisonResult(err);
     }
     let committedHashes;
     try {
@@ -70,8 +75,8 @@ export async function compareFiles(files, machine) {
             .filter((m) => m !== null)
             .map((m) => [m[2], m[1]]));
     }
-    catch {
-        return allNotBackedUp(files);
+    catch (err) {
+        return failedComparisonResult(err);
     }
     let sourceHashes;
     try {
@@ -80,8 +85,8 @@ export async function compareFiles(files, machine) {
         });
         sourceHashes = hashOutput.trim().split("\n");
     }
-    catch {
-        return allNotBackedUp(files);
+    catch (err) {
+        return failedComparisonResult(err);
     }
     return files.reduce((acc, file, i) => {
         const repoRelPath = path.relative(STAGING_DIR, getStagedPath(file, machine));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "backdot",
-  "version": "1.4.0",
+  "version": "1.6.0",
   "description": "Lightweight CLI to backup dotfiles and gitignored files to a Git repo on a daily schedule",
   "type": "module",
   "license": "MIT",
@@ -34,7 +34,8 @@
     "format:check": "prettier --check src/",
     "test": "vitest run --exclude src/e2e.test.ts",
     "test:e2e": "npm run build && vitest run src/e2e.test.ts",
-    "test:watch": "vitest"
+    "test:watch": "vitest",
+    "prepare": "husky"
   },
   "dependencies": {
     "@inquirer/prompts": "^8.3.0",
@@ -49,11 +50,20 @@
   "engines": {
     "node": ">=18"
   },
+  "lint-staged": {
+    "*.{ts,js}": [
+      "prettier --write",
+      "eslint --fix"
+    ],
+    "*.{json,md,yml}": "prettier --write"
+  },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
     "@types/node": "^22.13.5",
     "eslint": "^10.0.2",
     "eslint-config-prettier": "^10.1.8",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.2.7",
     "prettier": "^3.8.1",
     "typescript": "^5.7.3",
     "typescript-eslint": "^8.56.1",

package/dist/restore.d.ts

@@ -1 +0,0 @@
-export declare function restore(repoUrl?: string): Promise<void>;