backdot 1.3.1 → 1.5.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,8 +19,7 @@ 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/config", "~/.npmrc"]
+  "paths": ["~/.zshrc", "~/.oh-my-zsh/custom/*.zsh", "~/.ssh/config", "~/.npmrc"]
 }
 ```
 
@@ -30,12 +29,25 @@ Run your first backup:
 backdot --backup
 ```
 
+or configure the backport process to run automatically (daily at 2am)
+
+```bash
+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
 

package/dist/cli.js

@@ -1,17 +1,15 @@
 #!/usr/bin/env node
 import fs from "node:fs";
-import os from "node:os";
 import path from "node:path";
 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 { init } from "./commands/init.js";
 import { logger } from "./log.js";
+import { sendNotification } from "./notify.js";
 function getVersion() {
     const pkgPath = path.resolve(path.dirname(new URL(import.meta.url).pathname), "../package.json");
     try {
@@ -22,104 +20,6 @@ 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();
-    console.log();
-    console.log(`  Schedule:  ${scheduled ? "active (daily at 02:00)" : "not active"}`);
-    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.`);
-        }
-    }
-    catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        console.error(`\n  Config error: ${msg}`);
-        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];
@@ -131,18 +31,20 @@ async function main() {
             await backup();
         }
         else if (command === "--schedule") {
-            requireMacOS();
-            setupLaunchd();
+            schedule();
         }
         else if (command === "--unschedule") {
-            requireMacOS();
-            uninstallLaunchd();
+            unschedule();
         }
         else if (command === "--status") {
             await status();
         }
         else if (command === "--restore") {
-            await restore(args[1]);
+            const url = args[1];
+            if (url?.startsWith("--")) {
+                throw new Error(`Invalid repository URL: "${url}". Did you mean to pass a Git URL?`);
+            }
+            await restore(url);
         }
         else if (command === "--version") {
             console.log(getVersion());
@@ -176,6 +78,9 @@ async function main() {
         const msg = err instanceof Error ? err.message : String(err);
         logger.error(msg);
         console.error(`\n  Error: ${msg}\n`);
+        if (!process.stdout.isTTY) {
+            sendNotification("Backdot", `Backup failed: ${msg}`);
+        }
         process.exit(1);
     }
 }

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/{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/{restore.js → commands/restore.js}

@@ -3,10 +3,10 @@ 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 { 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

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.js

@@ -43,11 +43,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.d.ts

@@ -0,0 +1 @@
+export declare function sendNotification(title: string, message: string): void;

package/dist/notify.js

@@ -0,0 +1,21 @@
+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 = escapeAppleScript(message);
+    const titleEscaped = escapeAppleScript(title);
+    try {
+        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);
+        logger.warn(`Failed to send notification: ${msg}`);
+    }
+}

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.3.1",
+  "version": "1.5.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",