backdot 1.1.0 → 1.3.0

package/README.md

@@ -1,21 +1,26 @@
-# backdot
+<p align="center">
+  <img src="logo-small.png" alt="backdot" width="400" />
+</p>
 
-Back up dotfiles and gitignored files to a private Git repo — on demand or on a daily schedule.
+<h1 align="center">backdot</h1>
+
+<p align="center">Automated backup of important files (configs, dotfiles, gitignored files) to your own private Git repo.</p>
 
 ## Getting started
 
 ```bash
 npm install -g backdot
+backdot --init
 ```
 
-Create `~/.backdot.json` pointing to a private repo and the files you want backed up:
+This creates `~/.backdot.json` with sensible defaults and walks you through setup. Open the config file and set your repository URL and the files you want backed up:
 
 ```json
 {
-  "repository": "git@github.com:USERNAME/dotfiles-backup.git",
+  "repository": "git@github.com:USERNAME/backdot-backup.git",
   "machine": "my-work-laptop",
-  "files.gitignored": ["~/my-project"],
-  "files.match": ["~/.zshrc", "~/.oh-my-zsh/custom/*.zsh", "~/.ssh/config/config", "~/.npmrc"]
+  "gitignored": ["~/my-project"],
+  "paths": ["~/.zshrc", "~/.oh-my-zsh/custom/*.zsh", "~/.ssh/config/config", "~/.npmrc"]
 }
 ```
 
@@ -27,15 +32,16 @@ backdot --backup
 
 ## Configuration
 
-| Key                | Description                                            |
-| ------------------ | ------------------------------------------------------ |
-| `files.gitignored` | Directories to scan for gitignored files               |
-| `files.match`      | Glob patterns matching individual files or directories |
+| Key          | Description                                            |
+| ------------ | ------------------------------------------------------ |
+| `gitignored` | Directories to scan for gitignored files               |
+| `paths`      | Glob patterns matching individual files or directories |
 
 ## 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) |

package/dist/cli.js

@@ -1,12 +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 } from "./staging.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 { logger } from "./log.js";
 function getVersion() {
@@ -26,7 +29,7 @@ async function backup() {
     logger.info(`Machine: ${config.machine}`);
     const spinner = ora("Resolving files").start();
     try {
-        const userFiles = resolveFiles(config.files);
+        const userFiles = resolveFiles(config);
         logger.info(`Resolved ${userFiles.length} file(s)`);
         if (userFiles.length === 0) {
             spinner.info("No files resolved, nothing to back up");
@@ -38,10 +41,13 @@ async function backup() {
         spinner.text = `Copying ${files.length} file(s) to staging`;
         cleanStaging(config.machine);
         copyToStaging(files, config.machine);
-        writeRepoReadme();
+        writeRepoReadme(config.repository);
         spinner.text = "Pushing to remote";
-        await gitCommitAndPush();
-        spinner.succeed("Backup complete");
+        const result = await gitCommitAndPush();
+        const successMsg = result?.commitUrl
+            ? `Backup complete → ${result.commitUrl}`
+            : "Backup complete";
+        spinner.succeed(successMsg);
         console.log();
     }
     catch (err) {
@@ -50,7 +56,11 @@ async function backup() {
     }
     logger.info("Backup complete");
 }
-function status() {
+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"}`);
@@ -60,18 +70,42 @@ function status() {
         console.log(`  Machine:   ${config.machine}`);
         console.log();
         const spinner = ora("Resolving files").start();
-        const userFiles = resolveFiles(config.files);
+        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 {
-            const files = [...userFiles, CONFIG_PATH];
-            spinner.stop();
-            console.log(`${files.length} file(s) resolved:`);
-            console.log();
-            for (const file of files) {
-                console.log(`  ${file}`);
+            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) {
@@ -90,7 +124,10 @@ async function main() {
     const args = process.argv.slice(2);
     const command = args[0];
     try {
-        if (command === "--backup") {
+        if (command === "--init") {
+            init();
+        }
+        else if (command === "--backup") {
             await backup();
         }
         else if (command === "--schedule") {
@@ -102,10 +139,10 @@ async function main() {
             uninstallLaunchd();
         }
         else if (command === "--status") {
-            status();
+            await status();
         }
         else if (command === "--restore") {
-            await restore();
+            await restore(args[1]);
         }
         else if (command === "--version") {
             console.log(getVersion());
@@ -116,8 +153,9 @@ async function main() {
             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      Restore files from the backup repo");
+            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");
@@ -128,6 +166,10 @@ async function main() {
                 console.log();
                 process.exit(1);
             }
+            else if (!fs.existsSync(CONFIG_PATH)) {
+                console.log(`  No config found. Run ${chalk.bold("backdot --init")} to get started.`);
+                console.log();
+            }
         }
     }
     catch (err) {

package/dist/commitUrl.d.ts

@@ -0,0 +1 @@
+export declare function getCommitUrl(remoteUrl: string, sha: string): string | null;

package/dist/commitUrl.js

@@ -0,0 +1,18 @@
+const PROVIDERS = {
+    "github.com": (p, sha) => `https://github.com/${p}/commit/${sha}`,
+    "gitlab.com": (p, sha) => `https://gitlab.com/${p}/-/commit/${sha}`,
+    "bitbucket.org": (p, sha) => `https://bitbucket.org/${p}/commits/${sha}`,
+};
+export function getCommitUrl(remoteUrl, sha) {
+    for (const [host, buildUrl] of Object.entries(PROVIDERS)) {
+        const idx = remoteUrl.indexOf(host);
+        if (idx === -1)
+            continue;
+        let repoPath = remoteUrl.slice(idx + host.length + 1).trim();
+        if (repoPath.endsWith(".git")) {
+            repoPath = repoPath.slice(0, -4);
+        }
+        return buildUrl(repoPath, sha);
+    }
+    return null;
+}

package/dist/config.d.ts

@@ -1,24 +1,12 @@
 import { z } from "zod";
 export declare const CONFIG_PATH: string;
 export declare function expandTilde(p: string): string;
-declare const ConfigSchema: z.ZodPipe<z.ZodObject<{
+declare const ConfigSchema: z.ZodObject<{
     repository: z.ZodString;
     machine: z.ZodString;
-    "files.gitignored": z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>>;
-    "files.match": z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>>;
-}, z.core.$strip>, z.ZodTransform<{
-    repository: string;
-    machine: string;
-    files: {
-        gitignored: string[];
-        match: string[];
-    };
-}, {
-    repository: string;
-    machine: string;
-    "files.gitignored": string[];
-    "files.match": string[];
-}>>;
+    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>>>>>;
+}, z.core.$strip>;
 export type Config = z.infer<typeof ConfigSchema>;
 export declare function loadConfig(): Config;
 export {};

package/dist/config.js

@@ -14,23 +14,15 @@ const ConfigSchema = z
     .object({
     repository: z.string().min(1),
     machine: z.string().min(1),
-    "files.gitignored": pathList,
-    "files.match": pathList,
+    gitignored: pathList,
+    paths: pathList,
 })
-    .refine((c) => c["files.gitignored"].length > 0 || c["files.match"].length > 0, {
-    message: 'At least one of "files.gitignored" or "files.match" must be a non-empty array',
-})
-    .transform((c) => ({
-    repository: c.repository,
-    machine: c.machine,
-    files: {
-        gitignored: c["files.gitignored"],
-        match: c["files.match"],
-    },
-}));
+    .refine((c) => c.gitignored.length > 0 || c.paths.length > 0, {
+    message: 'At least one of "gitignored" or "paths" must be a non-empty array',
+});
 export function loadConfig() {
     if (!fs.existsSync(CONFIG_PATH)) {
-        throw new Error(`Config file not found: ${CONFIG_PATH}`);
+        throw new Error(`Config file not found: ${CONFIG_PATH}\n  Run "backdot --init" to create it.`);
     }
     let raw;
     try {

package/dist/git.d.ts

@@ -1,2 +1,4 @@
 export declare function gitPull(repository: string): Promise<void>;
-export declare function gitCommitAndPush(): Promise<void>;
+export declare function gitCommitAndPush(): Promise<{
+    commitUrl: string | null;
+} | null>;

package/dist/git.js

@@ -1,8 +1,10 @@
 import fs from "node:fs";
 import path from "node:path";
+import pRetry from "p-retry";
 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) {
     if (fs.existsSync(path.join(STAGING_DIR, ".git"))) {
         const git = simpleGit(STAGING_DIR);
@@ -30,11 +32,23 @@ export async function gitCommitAndPush() {
     const status = await git.status();
     if (status.isClean()) {
         logger.info("No changes to commit");
-        return;
+        return null;
     }
     const date = new Date().toISOString().split("T")[0];
     const message = `Automated backup: ${date}`;
     await git.commit(message);
-    await git.push(["-u", "origin", "HEAD"]);
+    await pRetry(async () => git.push(["-u", "origin", "HEAD"]), {
+        retries: 5,
+        onFailedAttempt: async ({ attemptNumber, retriesLeft }) => {
+            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}`]);
+        },
+    });
     logger.info(`Committed and pushed: ${message}`);
+    const sha = await git.revparse(["HEAD"]);
+    const remoteUrl = (await git.remote(["get-url", "origin"])) ?? "";
+    const commitUrl = getCommitUrl(remoteUrl, sha);
+    return { commitUrl };
 }

package/dist/init.d.ts

@@ -0,0 +1 @@
+export declare function init(): void;

package/dist/init.js

@@ -0,0 +1,43 @@
+import fs from "node:fs";
+import os from "node:os";
+import chalk from "chalk";
+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() {
+    console.log();
+    console.log(chalk.bold("  Welcome to backdot!"));
+    console.log();
+    // Step 1
+    console.log(chalk.bold("  Step 1 — Create a private Git repository"));
+    console.log();
+    console.log("  If you don't have a backup repo yet, create one:");
+    console.log();
+    console.log(`    GitHub:    ${chalk.cyan("https://github.com/new?name=backdot-backup&visibility=private")}`);
+    console.log(`    GitLab:    ${chalk.cyan("https://gitlab.com/projects/new#blank_project")}`);
+    console.log(`    Bitbucket: ${chalk.cyan("https://bitbucket.org/repo/create")}`);
+    console.log();
+    // Step 2
+    console.log(chalk.bold(`  Step 2 — Edit ${CONFIG_PATH}`));
+    console.log();
+    if (fs.existsSync(CONFIG_PATH)) {
+        console.log(`  ${chalk.yellow(`${CONFIG_PATH} already exists — skipping creation.`)}`);
+    }
+    else {
+        fs.writeFileSync(CONFIG_PATH, JSON.stringify(TEMPLATE, null, 2) + "\n");
+        console.log(`  Created ${CONFIG_PATH} with defaults.`);
+    }
+    console.log("  Open it and set your repository URL and files to back up.");
+    console.log();
+    // Step 3
+    console.log(chalk.bold("  Step 3 — Run your first backup"));
+    console.log();
+    console.log(`    ${chalk.bold("backdot --backup")}          Run a one-time backup`);
+    console.log(`    ${chalk.bold("backdot --schedule")}        Schedule daily backups (macOS)`);
+    console.log(`    ${chalk.bold("backdot --status")}          Check which files will be backed up`);
+    console.log();
+}

package/dist/resolve.d.ts

@@ -3,4 +3,4 @@ import { Config } from "./config.js";
  * Resolve all file entries to absolute paths.
  * Skips entries that fail resolution and logs warnings.
  */
-export declare function resolveFiles(files: Config["files"]): string[];
+export declare function resolveFiles(config: Config): string[];

package/dist/resolve.js

@@ -37,15 +37,13 @@ const LARGE_FILE_THRESHOLD = 10 * 1024 * 1024; // 10 MB
  * Resolve all file entries to absolute paths.
  * Skips entries that fail resolution and logs warnings.
  */
-export function resolveFiles(files) {
-    const allFiles = [];
-    for (const dirPath of files.gitignored) {
-        allFiles.push(...resolveGitignored(dirPath));
-    }
-    for (const pattern of files.match) {
-        allFiles.push(...resolveGlob(pattern));
-    }
-    const unique = [...new Set(allFiles)];
+export function resolveFiles(config) {
+    const unique = [
+        ...new Set([
+            ...config.gitignored.flatMap(resolveGitignored),
+            ...config.paths.flatMap(resolveGlob),
+        ]),
+    ];
     return unique.filter((filePath) => {
         try {
             fs.accessSync(filePath, fs.constants.R_OK);

package/dist/restore.d.ts

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

package/dist/restore.js

@@ -2,26 +2,20 @@ import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
 import ora from "ora";
-import { checkbox } from "@inquirer/prompts";
+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";
 const HOME = os.homedir();
 function walkDir(dir) {
-    const results = [];
-    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-        if (entry.name === ".git")
-            continue;
+    return fs
+        .readdirSync(dir, { withFileTypes: true })
+        .filter((entry) => entry.name !== ".git")
+        .flatMap((entry) => {
         const full = path.join(dir, entry.name);
-        if (entry.isDirectory()) {
-            results.push(...walkDir(full));
-        }
-        else {
-            results.push(full);
-        }
-    }
-    return results;
+        return entry.isDirectory() ? walkDir(full) : [full];
+    });
 }
 function listMachines() {
     if (!fs.existsSync(STAGING_DIR))
@@ -31,22 +25,48 @@ function listMachines() {
         .filter((e) => e.isDirectory() && e.name !== ".git")
         .map((e) => e.name);
 }
-export async function restore() {
+async function resolveRepoAndMachine(repoUrl) {
+    if (!repoUrl) {
+        const config = loadConfig();
+        return { repository: config.repository, machine: config.machine };
+    }
+    const spinner = ora("Cloning backup repository").start();
+    await gitPull(repoUrl);
+    spinner.stop();
+    const machines = listMachines();
+    if (machines.length === 0) {
+        throw new Error("The backup repository is empty (no machine directories found).");
+    }
+    let machine;
+    if (machines.length === 1) {
+        machine = machines[0];
+    }
+    else {
+        machine = await select({
+            message: "Multiple machines found. Which one do you want to restore?",
+            choices: machines.map((m) => ({ name: m, value: m })),
+        });
+    }
+    return { repository: repoUrl, machine };
+}
+export async function restore(repoUrl) {
     logger.info("Starting restore");
-    const config = loadConfig();
-    const baseDir = machineDir(config.machine);
+    const { repository, machine } = await resolveRepoAndMachine(repoUrl);
     const spinner = ora("Fetching latest backup").start();
-    await gitPull(config.repository);
+    const baseDir = machineDir(machine);
+    if (!repoUrl) {
+        await gitPull(repository);
+    }
     spinner.text = "Resolving files";
     if (!fs.existsSync(baseDir)) {
         spinner.stop();
         const available = listMachines();
         if (available.length > 0) {
-            console.log(`\n  No backup found for machine "${config.machine}".`);
+            console.log(`\n  No backup found for machine "${machine}".`);
             console.log(`  Available machines: ${available.join(", ")}\n`);
         }
         else {
-            console.log(`\n  No backup found for machine "${config.machine}". The repository is empty.\n`);
+            console.log(`\n  No backup found for machine "${machine}". The repository is empty.\n`);
         }
         return;
     }

package/dist/staging.d.ts

@@ -1,5 +1,12 @@
 export declare const STAGING_DIR: string;
 export declare function machineDir(machine: string): string;
+export declare function getStagedPath(filePath: string, machine: string): string;
 export declare function cleanStaging(machine: string): void;
 export declare function copyToStaging(files: string[], machine: string): void;
-export declare function writeRepoReadme(): void;
+export interface ComparisonResult {
+    backedUp: string[];
+    modified: string[];
+    notBackedUp: string[];
+}
+export declare function compareFiles(files: string[], machine: string): Promise<ComparisonResult>;
+export declare function writeRepoReadme(repository: string): void;

package/dist/staging.js

@@ -1,12 +1,19 @@
 import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
+import { execFileSync } from "node:child_process";
+import { simpleGit } from "simple-git";
 import { logger } from "./log.js";
 const HOME = os.homedir();
 export const STAGING_DIR = path.join(HOME, ".backdot", "repo");
 export function machineDir(machine) {
     return path.join(STAGING_DIR, machine);
 }
+export function getStagedPath(filePath, machine) {
+    const rel = path.relative(HOME, filePath);
+    const destRel = rel.startsWith("..") ? filePath.slice(1) : rel;
+    return path.join(machineDir(machine), destRel);
+}
 export function cleanStaging(machine) {
     const dir = machineDir(machine);
     if (!fs.existsSync(dir))
@@ -19,9 +26,7 @@ export function copyToStaging(files, machine) {
     fs.mkdirSync(dir, { recursive: true });
     let copied = 0;
     for (const filePath of files) {
-        const rel = path.relative(HOME, filePath);
-        const destRel = rel.startsWith("..") ? filePath.slice(1) : rel;
-        const dest = path.join(dir, destRel);
+        const dest = getStagedPath(filePath, machine);
         try {
             fs.mkdirSync(path.dirname(dest), { recursive: true });
             fs.copyFileSync(filePath, dest);
@@ -33,27 +38,81 @@ export function copyToStaging(files, machine) {
     }
     logger.info(`Copied ${copied} file(s) to staging`);
 }
-const REPO_README = `# Dotfiles Backup
+const allNotBackedUp = (files) => ({
+    backedUp: [],
+    modified: [],
+    notBackedUp: files,
+});
+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);
+    const git = simpleGit(STAGING_DIR);
+    await git.fetch("origin");
+    let branch;
+    try {
+        branch = (await git.revparse(["--abbrev-ref", "HEAD"])).trim();
+    }
+    catch {
+        return allNotBackedUp(files);
+    }
+    let committedHashes;
+    try {
+        const treeOutput = execFileSync("git", ["ls-tree", "-r", `origin/${branch}`, `${machine}/`], {
+            encoding: "utf-8",
+            cwd: STAGING_DIR,
+        });
+        committedHashes = new Map(treeOutput
+            .split("\n")
+            .map((line) => line.match(/^\d+ blob ([0-9a-f]+)\t(.+)$/))
+            .filter((m) => m !== null)
+            .map((m) => [m[2], m[1]]));
+    }
+    catch {
+        return allNotBackedUp(files);
+    }
+    let sourceHashes;
+    try {
+        const hashOutput = execFileSync("git", ["hash-object", "--", ...files], {
+            encoding: "utf-8",
+        });
+        sourceHashes = hashOutput.trim().split("\n");
+    }
+    catch {
+        return allNotBackedUp(files);
+    }
+    return files.reduce((acc, file, i) => {
+        const repoRelPath = path.relative(STAGING_DIR, getStagedPath(file, machine));
+        const committedHash = committedHashes.get(repoRelPath);
+        if (!committedHash) {
+            acc.notBackedUp.push(file);
+        }
+        else if (committedHash === sourceHashes[i]) {
+            acc.backedUp.push(file);
+        }
+        else {
+            acc.modified.push(file);
+        }
+        return acc;
+    }, { backedUp: [], modified: [], notBackedUp: [] });
+}
+function repoReadme(repository) {
+    return `# Backdot Backup
 
 This repository contains dotfiles backed up automatically using [backdot](https://github.com/sorenlouv/backdot).
 
-## Quick start
-
-Install backdot:
-
-\`\`\`bash
-npm install -g backdot
-\`\`\`
-
-Restore files from this backup:
+## Restore
 
 \`\`\`bash
-backdot --restore
+npx backdot --restore ${repository}
 \`\`\`
 
 For full documentation, configuration options, and scheduling, see the [official README](https://github.com/sorenlouv/backdot).
 `;
-export function writeRepoReadme() {
-    fs.writeFileSync(path.join(STAGING_DIR, "README.md"), REPO_README);
+}
+export function writeRepoReadme(repository) {
+    fs.writeFileSync(path.join(STAGING_DIR, "README.md"), repoReadme(repository));
     logger.info("Wrote README.md to staging directory");
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "backdot",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "description": "Lightweight CLI to backup dotfiles and gitignored files to a Git repo on a daily schedule",
   "type": "module",
   "license": "MIT",
@@ -21,18 +21,23 @@
   ],
   "scripts": {
     "build": "tsc",
+    "build:watch": "tsc --watch",
+    "release": "./scripts/release.sh",
     "start": "node dist/cli.js",
     "lint": "eslint src/",
     "lint:fix": "eslint src/ --fix",
     "format": "prettier --write src/",
     "format:check": "prettier --check src/",
-    "test": "vitest run",
+    "test": "vitest run --exclude src/e2e.test.ts",
+    "test:e2e": "npm run build && vitest run src/e2e.test.ts",
     "test:watch": "vitest"
   },
   "dependencies": {
     "@inquirer/prompts": "^8.3.0",
+    "chalk": "^5.6.2",
     "fast-glob": "^3.3.3",
     "ora": "^9.3.0",
+    "p-retry": "^7.1.1",
     "simple-git": "^3.32.2",
     "winston": "^3.19.0",
     "zod": "^4.3.6"