@prnv/tuck 1.0.0

package/dist/index.js

@@ -0,0 +1,2885 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command as Command12 } from "commander";
+import chalk16 from "chalk";
+
+// src/commands/init.ts
+import { Command } from "commander";
+import { join as join3 } from "path";
+import { writeFile as writeFile3 } from "fs/promises";
+import { ensureDir } from "fs-extra";
+
+// src/ui/banner.ts
+import chalk from "chalk";
+import boxen from "boxen";
+var banner = () => {
+  const art = `
+ \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2557   \u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2557  \u2588\u2588\u2557
+ \u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D\u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2551 \u2588\u2588\u2554\u255D
+    \u2588\u2588\u2551   \u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2551     \u2588\u2588\u2588\u2588\u2588\u2554\u255D
+    \u2588\u2588\u2551   \u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2551     \u2588\u2588\u2554\u2550\u2588\u2588\u2557
+    \u2588\u2588\u2551   \u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551  \u2588\u2588\u2557
+    \u255A\u2550\u255D    \u255A\u2550\u2550\u2550\u2550\u2550\u255D  \u255A\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u255D`;
+  console.log(chalk.cyan(art));
+  console.log(chalk.dim("    Modern Dotfiles Manager\n"));
+};
+var nextSteps = (steps) => {
+  const content = steps.map((step, i) => `${chalk.cyan(`${i + 1}.`)} ${step}`).join("\n");
+  console.log(
+    boxen(content, {
+      padding: 1,
+      margin: { top: 1, bottom: 0, left: 0, right: 0 },
+      borderStyle: "round",
+      borderColor: "cyan",
+      title: "Next Steps",
+      titleAlignment: "left"
+    })
+  );
+};
+
+// src/ui/logger.ts
+import chalk2 from "chalk";
+var logger = {
+  info: (msg) => {
+    console.log(chalk2.blue("\u2139"), msg);
+  },
+  success: (msg) => {
+    console.log(chalk2.green("\u2713"), msg);
+  },
+  warning: (msg) => {
+    console.log(chalk2.yellow("\u26A0"), msg);
+  },
+  error: (msg) => {
+    console.log(chalk2.red("\u2717"), msg);
+  },
+  debug: (msg) => {
+    if (process.env.DEBUG) {
+      console.log(chalk2.gray("\u2699"), chalk2.gray(msg));
+    }
+  },
+  step: (current, total, msg) => {
+    console.log(chalk2.dim(`[${current}/${total}]`), msg);
+  },
+  file: (action, path) => {
+    const icons = {
+      add: chalk2.green("+"),
+      modify: chalk2.yellow("~"),
+      delete: chalk2.red("-"),
+      sync: chalk2.blue("\u2194")
+    };
+    console.log(`  ${icons[action]} ${path}`);
+  },
+  tree: (items) => {
+    items.forEach(({ name, isLast, indent = 0 }) => {
+      const indentation = "  ".repeat(indent);
+      const prefix = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+      console.log(chalk2.dim(indentation + prefix) + name);
+    });
+  },
+  blank: () => {
+    console.log();
+  },
+  dim: (msg) => {
+    console.log(chalk2.dim(msg));
+  },
+  heading: (msg) => {
+    console.log(chalk2.bold.cyan(msg));
+  }
+};
+var formatCount = (count, singular, plural) => {
+  const word = count === 1 ? singular : plural || `${singular}s`;
+  return `${chalk2.bold(count.toString())} ${word}`;
+};
+var formatStatus = (status) => {
+  switch (status) {
+    case "modified":
+      return chalk2.yellow("modified");
+    case "added":
+      return chalk2.green("added");
+    case "deleted":
+      return chalk2.red("deleted");
+    case "untracked":
+      return chalk2.gray("untracked");
+    default:
+      return status;
+  }
+};
+
+// src/ui/prompts.ts
+import * as p from "@clack/prompts";
+import chalk3 from "chalk";
+var prompts = {
+  intro: (title) => {
+    p.intro(chalk3.bgCyan(chalk3.black(` ${title} `)));
+  },
+  outro: (message) => {
+    p.outro(chalk3.green(message));
+  },
+  confirm: async (message, initial = false) => {
+    const result = await p.confirm({ message, initialValue: initial });
+    if (p.isCancel(result)) {
+      prompts.cancel();
+    }
+    return result;
+  },
+  select: async (message, options) => {
+    const result = await p.select({
+      message,
+      options: options.map((opt) => ({
+        value: opt.value,
+        label: opt.label,
+        hint: opt.hint
+      }))
+    });
+    if (p.isCancel(result)) {
+      prompts.cancel();
+    }
+    return result;
+  },
+  multiselect: async (message, options, required = false) => {
+    const result = await p.multiselect({
+      message,
+      options: options.map((opt) => ({
+        value: opt.value,
+        label: opt.label,
+        hint: opt.hint
+      })),
+      required
+    });
+    if (p.isCancel(result)) {
+      prompts.cancel();
+    }
+    return result;
+  },
+  text: async (message, options) => {
+    const result = await p.text({
+      message,
+      placeholder: options?.placeholder,
+      defaultValue: options?.defaultValue,
+      validate: options?.validate
+    });
+    if (p.isCancel(result)) {
+      prompts.cancel();
+    }
+    return result;
+  },
+  password: async (message) => {
+    const result = await p.password({ message });
+    if (p.isCancel(result)) {
+      prompts.cancel();
+    }
+    return result;
+  },
+  spinner: () => p.spinner(),
+  note: (message, title) => {
+    p.note(message, title);
+  },
+  cancel: (message = "Operation cancelled") => {
+    p.cancel(message);
+    process.exit(0);
+  },
+  log: {
+    info: (message) => {
+      p.log.info(message);
+    },
+    success: (message) => {
+      p.log.success(message);
+    },
+    warning: (message) => {
+      p.log.warning(message);
+    },
+    error: (message) => {
+      p.log.error(message);
+    },
+    step: (message) => {
+      p.log.step(message);
+    },
+    message: (message) => {
+      p.log.message(message);
+    }
+  },
+  group: async (steps, options) => {
+    const results = await p.group(steps, {
+      onCancel: () => {
+        if (options?.onCancel) {
+          options.onCancel();
+        } else {
+          prompts.cancel();
+        }
+      }
+    });
+    return results;
+  }
+};
+
+// src/ui/spinner.ts
+import ora from "ora";
+import chalk4 from "chalk";
+var createSpinner = (initialText) => {
+  const spinner2 = ora({
+    text: initialText,
+    color: "cyan",
+    spinner: "dots"
+  });
+  return {
+    start: (text2) => {
+      if (text2) spinner2.text = text2;
+      spinner2.start();
+    },
+    stop: () => {
+      spinner2.stop();
+    },
+    succeed: (text2) => {
+      spinner2.succeed(text2 ? chalk4.green(text2) : void 0);
+    },
+    fail: (text2) => {
+      spinner2.fail(text2 ? chalk4.red(text2) : void 0);
+    },
+    warn: (text2) => {
+      spinner2.warn(text2 ? chalk4.yellow(text2) : void 0);
+    },
+    info: (text2) => {
+      spinner2.info(text2 ? chalk4.blue(text2) : void 0);
+    },
+    text: (text2) => {
+      spinner2.text = text2;
+    }
+  };
+};
+var withSpinner = async (text2, fn, options) => {
+  const spinner2 = createSpinner(text2);
+  spinner2.start();
+  try {
+    const result = await fn();
+    spinner2.succeed(options?.successText || text2);
+    return result;
+  } catch (error) {
+    spinner2.fail(options?.failText || text2);
+    throw error;
+  }
+};
+
+// src/ui/table.ts
+import chalk5 from "chalk";
+
+// src/lib/paths.ts
+import { homedir as homedir2 } from "os";
+import { join as join2, basename, dirname, relative, isAbsolute, resolve } from "path";
+import { stat, access } from "fs/promises";
+import { constants } from "fs";
+
+// src/constants.ts
+import { homedir } from "os";
+import { join } from "path";
+var VERSION = "0.1.0";
+var DESCRIPTION = "Modern dotfiles manager with a beautiful CLI";
+var HOME_DIR = homedir();
+var DEFAULT_TUCK_DIR = join(HOME_DIR, ".tuck");
+var MANIFEST_FILE = ".tuckmanifest.json";
+var CONFIG_FILE = ".tuckrc.json";
+var BACKUP_DIR = join(HOME_DIR, ".tuck-backups");
+var FILES_DIR = "files";
+var CATEGORIES = {
+  shell: {
+    patterns: [
+      ".zshrc",
+      ".bashrc",
+      ".bash_profile",
+      ".zprofile",
+      ".profile",
+      ".aliases",
+      ".zshenv",
+      ".bash_aliases",
+      ".inputrc"
+    ],
+    icon: "\u{1F41A}"
+  },
+  git: {
+    patterns: [".gitconfig", ".gitignore_global", ".gitmessage", ".gitattributes"],
+    icon: "\u{1F4E6}"
+  },
+  editors: {
+    patterns: [
+      ".vimrc",
+      ".config/nvim",
+      ".emacs",
+      ".emacs.d",
+      ".config/Code",
+      ".ideavimrc",
+      ".nanorc"
+    ],
+    icon: "\u270F\uFE0F"
+  },
+  terminal: {
+    patterns: [
+      ".tmux.conf",
+      ".config/alacritty",
+      ".config/kitty",
+      ".wezterm.lua",
+      ".config/wezterm",
+      ".config/hyper",
+      ".config/starship.toml"
+    ],
+    icon: "\u{1F4BB}"
+  },
+  ssh: {
+    patterns: [".ssh/config"],
+    icon: "\u{1F510}"
+  },
+  misc: {
+    patterns: [],
+    icon: "\u{1F4C4}"
+  }
+};
+var COMMON_DOTFILES = [
+  { path: "~/.zshrc", category: "shell" },
+  { path: "~/.bashrc", category: "shell" },
+  { path: "~/.bash_profile", category: "shell" },
+  { path: "~/.gitconfig", category: "git" },
+  { path: "~/.config/nvim", category: "editors" },
+  { path: "~/.vimrc", category: "editors" },
+  { path: "~/.tmux.conf", category: "terminal" },
+  { path: "~/.ssh/config", category: "ssh" },
+  { path: "~/.config/starship.toml", category: "terminal" }
+];
+
+// src/lib/paths.ts
+var expandPath = (path) => {
+  if (path.startsWith("~/")) {
+    return join2(homedir2(), path.slice(2));
+  }
+  if (path.startsWith("$HOME/")) {
+    return join2(homedir2(), path.slice(6));
+  }
+  return isAbsolute(path) ? path : resolve(path);
+};
+var collapsePath = (path) => {
+  const home = homedir2();
+  if (path.startsWith(home)) {
+    return "~" + path.slice(home.length);
+  }
+  return path;
+};
+var getTuckDir = (customDir) => {
+  return expandPath(customDir || DEFAULT_TUCK_DIR);
+};
+var getManifestPath = (tuckDir) => {
+  return join2(tuckDir, MANIFEST_FILE);
+};
+var getConfigPath = (tuckDir) => {
+  return join2(tuckDir, CONFIG_FILE);
+};
+var getFilesDir = (tuckDir) => {
+  return join2(tuckDir, FILES_DIR);
+};
+var getCategoryDir = (tuckDir, category) => {
+  return join2(getFilesDir(tuckDir), category);
+};
+var getDestinationPath = (tuckDir, category, filename) => {
+  return join2(getCategoryDir(tuckDir, category), filename);
+};
+var getRelativeDestination = (category, filename) => {
+  return join2(FILES_DIR, category, filename);
+};
+var sanitizeFilename = (filepath) => {
+  const base = basename(filepath);
+  return base.startsWith(".") ? base.slice(1) : base;
+};
+var detectCategory = (filepath) => {
+  const expandedPath = expandPath(filepath);
+  const relativePath = collapsePath(expandedPath);
+  for (const [category, config] of Object.entries(CATEGORIES)) {
+    for (const pattern of config.patterns) {
+      if (relativePath.endsWith(pattern) || relativePath.includes(pattern)) {
+        return category;
+      }
+      const filename = basename(expandedPath);
+      if (filename === pattern || filename === basename(pattern)) {
+        return category;
+      }
+    }
+  }
+  return "misc";
+};
+var pathExists = async (path) => {
+  try {
+    await access(path, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var isDirectory = async (path) => {
+  try {
+    const stats = await stat(path);
+    return stats.isDirectory();
+  } catch {
+    return false;
+  }
+};
+var generateFileId = (source) => {
+  const collapsed = collapsePath(source);
+  return collapsed.replace(/^~\//, "").replace(/\//g, "_").replace(/\./g, "-").replace(/^-/, "");
+};
+
+// src/lib/config.ts
+import { readFile, writeFile } from "fs/promises";
+import { cosmiconfig } from "cosmiconfig";
+
+// src/schemas/config.schema.ts
+import { z } from "zod";
+var fileStrategySchema = z.enum(["copy", "symlink"]);
+var categoryConfigSchema = z.object({
+  patterns: z.array(z.string()),
+  icon: z.string().optional()
+});
+var tuckConfigSchema = z.object({
+  repository: z.object({
+    path: z.string(),
+    defaultBranch: z.string().default("main"),
+    autoCommit: z.boolean().default(true),
+    autoPush: z.boolean().default(false)
+  }).partial().default({}),
+  files: z.object({
+    strategy: fileStrategySchema.default("copy"),
+    backupOnRestore: z.boolean().default(true),
+    backupDir: z.string().optional()
+  }).partial().default({}),
+  categories: z.record(categoryConfigSchema).optional().default({}),
+  ignore: z.array(z.string()).optional().default([]),
+  hooks: z.object({
+    preSync: z.string().optional(),
+    postSync: z.string().optional(),
+    preRestore: z.string().optional(),
+    postRestore: z.string().optional()
+  }).partial().default({}),
+  templates: z.object({
+    enabled: z.boolean().default(false),
+    variables: z.record(z.string()).default({})
+  }).partial().default({}),
+  encryption: z.object({
+    enabled: z.boolean().default(false),
+    gpgKey: z.string().optional(),
+    files: z.array(z.string()).default([])
+  }).partial().default({}),
+  ui: z.object({
+    colors: z.boolean().default(true),
+    emoji: z.boolean().default(true),
+    verbose: z.boolean().default(false)
+  }).partial().default({})
+});
+var defaultConfig = {
+  repository: {
+    defaultBranch: "main",
+    autoCommit: true,
+    autoPush: false
+  },
+  files: {
+    strategy: "copy",
+    backupOnRestore: true
+  },
+  categories: {},
+  ignore: [],
+  hooks: {},
+  templates: {
+    enabled: false,
+    variables: {}
+  },
+  encryption: {
+    enabled: false,
+    files: []
+  },
+  ui: {
+    colors: true,
+    emoji: true,
+    verbose: false
+  }
+};
+
+// src/errors.ts
+import chalk6 from "chalk";
+var TuckError = class extends Error {
+  constructor(message, code, suggestions) {
+    super(message);
+    this.code = code;
+    this.suggestions = suggestions;
+    this.name = "TuckError";
+  }
+};
+var NotInitializedError = class extends TuckError {
+  constructor() {
+    super("Tuck is not initialized in this system", "NOT_INITIALIZED", [
+      "Run `tuck init` to get started"
+    ]);
+  }
+};
+var AlreadyInitializedError = class extends TuckError {
+  constructor(path) {
+    super(`Tuck is already initialized at ${path}`, "ALREADY_INITIALIZED", [
+      "Use `tuck status` to see current state",
+      `Remove ${path} to reinitialize`
+    ]);
+  }
+};
+var FileNotFoundError = class extends TuckError {
+  constructor(path) {
+    super(`File not found: ${path}`, "FILE_NOT_FOUND", [
+      "Check that the path is correct",
+      "Use absolute paths or paths relative to home directory"
+    ]);
+  }
+};
+var FileNotTrackedError = class extends TuckError {
+  constructor(path) {
+    super(`File is not tracked: ${path}`, "FILE_NOT_TRACKED", [
+      `Run \`tuck add ${path}\` to track this file`,
+      "Run `tuck list` to see all tracked files"
+    ]);
+  }
+};
+var FileAlreadyTrackedError = class extends TuckError {
+  constructor(path) {
+    super(`File is already tracked: ${path}`, "FILE_ALREADY_TRACKED", [
+      "Run `tuck sync` to update it",
+      `Run \`tuck remove ${path}\` to untrack`
+    ]);
+  }
+};
+var GitError = class extends TuckError {
+  constructor(message, gitError) {
+    super(`Git operation failed: ${message}`, "GIT_ERROR", gitError ? [gitError] : void 0);
+  }
+};
+var ConfigError = class extends TuckError {
+  constructor(message) {
+    super(`Configuration error: ${message}`, "CONFIG_ERROR", [
+      "Run `tuck config edit` to fix configuration",
+      "Run `tuck config reset` to restore defaults"
+    ]);
+  }
+};
+var ManifestError = class extends TuckError {
+  constructor(message) {
+    super(`Manifest error: ${message}`, "MANIFEST_ERROR", [
+      "The manifest file may be corrupted",
+      "Run `tuck init --from <remote>` to restore from remote"
+    ]);
+  }
+};
+var PermissionError = class extends TuckError {
+  constructor(path, operation) {
+    super(`Permission denied: cannot ${operation} ${path}`, "PERMISSION_ERROR", [
+      "Check file permissions",
+      "Try running with appropriate permissions"
+    ]);
+  }
+};
+var handleError = (error) => {
+  if (error instanceof TuckError) {
+    console.error(chalk6.red("\u2717"), error.message);
+    if (error.suggestions && error.suggestions.length > 0) {
+      console.error();
+      console.error(chalk6.dim("Suggestions:"));
+      error.suggestions.forEach((s) => console.error(chalk6.dim(`  \u2192 ${s}`)));
+    }
+    process.exit(1);
+  }
+  if (error instanceof Error) {
+    console.error(chalk6.red("\u2717"), "An unexpected error occurred:", error.message);
+    if (process.env.DEBUG) {
+      console.error(error.stack);
+    }
+    process.exit(1);
+  }
+  console.error(chalk6.red("\u2717"), "An unknown error occurred");
+  process.exit(1);
+};
+
+// src/lib/config.ts
+var cachedConfig = null;
+var cachedTuckDir = null;
+var loadConfig = async (tuckDir) => {
+  const dir = tuckDir || getTuckDir();
+  if (cachedConfig && cachedTuckDir === dir) {
+    return cachedConfig;
+  }
+  const configPath = getConfigPath(dir);
+  if (!await pathExists(configPath)) {
+    cachedConfig = { ...defaultConfig, repository: { ...defaultConfig.repository, path: dir } };
+    cachedTuckDir = dir;
+    return cachedConfig;
+  }
+  try {
+    const content = await readFile(configPath, "utf-8");
+    const rawConfig = JSON.parse(content);
+    const result = tuckConfigSchema.safeParse(rawConfig);
+    if (!result.success) {
+      throw new ConfigError(`Invalid configuration: ${result.error.message}`);
+    }
+    cachedConfig = {
+      ...defaultConfig,
+      ...result.data,
+      repository: {
+        ...defaultConfig.repository,
+        ...result.data.repository,
+        path: dir
+      },
+      files: {
+        ...defaultConfig.files,
+        ...result.data.files,
+        backupDir: result.data.files?.backupDir || BACKUP_DIR
+      }
+    };
+    cachedTuckDir = dir;
+    return cachedConfig;
+  } catch (error) {
+    if (error instanceof ConfigError) {
+      throw error;
+    }
+    if (error instanceof SyntaxError) {
+      throw new ConfigError("Configuration file contains invalid JSON");
+    }
+    throw new ConfigError(`Failed to load configuration: ${error}`);
+  }
+};
+var saveConfig = async (config, tuckDir) => {
+  const dir = tuckDir || getTuckDir();
+  const configPath = getConfigPath(dir);
+  const existing = await loadConfig(dir);
+  const merged = {
+    ...existing,
+    ...config,
+    repository: {
+      ...existing.repository,
+      ...config.repository
+    },
+    files: {
+      ...existing.files,
+      ...config.files
+    },
+    hooks: {
+      ...existing.hooks,
+      ...config.hooks
+    },
+    templates: {
+      ...existing.templates,
+      ...config.templates
+    },
+    encryption: {
+      ...existing.encryption,
+      ...config.encryption
+    },
+    ui: {
+      ...existing.ui,
+      ...config.ui
+    }
+  };
+  const result = tuckConfigSchema.safeParse(merged);
+  if (!result.success) {
+    throw new ConfigError(`Invalid configuration: ${result.error.message}`);
+  }
+  try {
+    await writeFile(configPath, JSON.stringify(result.data, null, 2) + "\n", "utf-8");
+    cachedConfig = result.data;
+    cachedTuckDir = dir;
+  } catch (error) {
+    throw new ConfigError(`Failed to save configuration: ${error}`);
+  }
+};
+var resetConfig = async (tuckDir) => {
+  const dir = tuckDir || getTuckDir();
+  const configPath = getConfigPath(dir);
+  const resetTo = { ...defaultConfig, repository: { ...defaultConfig.repository, path: dir } };
+  try {
+    await writeFile(configPath, JSON.stringify(resetTo, null, 2) + "\n", "utf-8");
+    cachedConfig = resetTo;
+    cachedTuckDir = dir;
+  } catch (error) {
+    throw new ConfigError(`Failed to reset configuration: ${error}`);
+  }
+};
+
+// src/lib/manifest.ts
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+
+// src/schemas/manifest.schema.ts
+import { z as z2 } from "zod";
+var fileStrategySchema2 = z2.enum(["copy", "symlink"]);
+var trackedFileSchema = z2.object({
+  source: z2.string(),
+  destination: z2.string(),
+  category: z2.string(),
+  strategy: fileStrategySchema2,
+  encrypted: z2.boolean().default(false),
+  template: z2.boolean().default(false),
+  permissions: z2.string().optional(),
+  added: z2.string(),
+  modified: z2.string(),
+  checksum: z2.string()
+});
+var tuckManifestSchema = z2.object({
+  version: z2.string(),
+  created: z2.string(),
+  updated: z2.string(),
+  machine: z2.string().optional(),
+  files: z2.record(trackedFileSchema)
+});
+var createEmptyManifest = (machine) => {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    version: "1.0.0",
+    created: now,
+    updated: now,
+    machine,
+    files: {}
+  };
+};
+
+// src/lib/manifest.ts
+var cachedManifest = null;
+var cachedManifestDir = null;
+var loadManifest = async (tuckDir) => {
+  if (cachedManifest && cachedManifestDir === tuckDir) {
+    return cachedManifest;
+  }
+  const manifestPath = getManifestPath(tuckDir);
+  if (!await pathExists(manifestPath)) {
+    throw new ManifestError("Manifest file not found. Is tuck initialized?");
+  }
+  try {
+    const content = await readFile2(manifestPath, "utf-8");
+    const rawManifest = JSON.parse(content);
+    const result = tuckManifestSchema.safeParse(rawManifest);
+    if (!result.success) {
+      throw new ManifestError(`Invalid manifest: ${result.error.message}`);
+    }
+    cachedManifest = result.data;
+    cachedManifestDir = tuckDir;
+    return cachedManifest;
+  } catch (error) {
+    if (error instanceof ManifestError) {
+      throw error;
+    }
+    if (error instanceof SyntaxError) {
+      throw new ManifestError("Manifest file contains invalid JSON");
+    }
+    throw new ManifestError(`Failed to load manifest: ${error}`);
+  }
+};
+var saveManifest = async (manifest, tuckDir) => {
+  const manifestPath = getManifestPath(tuckDir);
+  manifest.updated = (/* @__PURE__ */ new Date()).toISOString();
+  const result = tuckManifestSchema.safeParse(manifest);
+  if (!result.success) {
+    throw new ManifestError(`Invalid manifest: ${result.error.message}`);
+  }
+  try {
+    await writeFile2(manifestPath, JSON.stringify(result.data, null, 2) + "\n", "utf-8");
+    cachedManifest = result.data;
+    cachedManifestDir = tuckDir;
+  } catch (error) {
+    throw new ManifestError(`Failed to save manifest: ${error}`);
+  }
+};
+var createManifest = async (tuckDir, machine) => {
+  const manifestPath = getManifestPath(tuckDir);
+  if (await pathExists(manifestPath)) {
+    throw new ManifestError("Manifest already exists");
+  }
+  const manifest = createEmptyManifest(machine);
+  try {
+    await writeFile2(manifestPath, JSON.stringify(manifest, null, 2) + "\n", "utf-8");
+    cachedManifest = manifest;
+    cachedManifestDir = tuckDir;
+    return manifest;
+  } catch (error) {
+    throw new ManifestError(`Failed to create manifest: ${error}`);
+  }
+};
+var addFileToManifest = async (tuckDir, id, file) => {
+  const manifest = await loadManifest(tuckDir);
+  if (manifest.files[id]) {
+    throw new ManifestError(`File already tracked with ID: ${id}`);
+  }
+  manifest.files[id] = file;
+  await saveManifest(manifest, tuckDir);
+};
+var updateFileInManifest = async (tuckDir, id, updates) => {
+  const manifest = await loadManifest(tuckDir);
+  if (!manifest.files[id]) {
+    throw new ManifestError(`File not found in manifest: ${id}`);
+  }
+  manifest.files[id] = {
+    ...manifest.files[id],
+    ...updates,
+    modified: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await saveManifest(manifest, tuckDir);
+};
+var removeFileFromManifest = async (tuckDir, id) => {
+  const manifest = await loadManifest(tuckDir);
+  if (!manifest.files[id]) {
+    throw new ManifestError(`File not found in manifest: ${id}`);
+  }
+  delete manifest.files[id];
+  await saveManifest(manifest, tuckDir);
+};
+var getTrackedFileBySource = async (tuckDir, source) => {
+  const manifest = await loadManifest(tuckDir);
+  for (const [id, file] of Object.entries(manifest.files)) {
+    if (file.source === source) {
+      return { id, file };
+    }
+  }
+  return null;
+};
+var getAllTrackedFiles = async (tuckDir) => {
+  const manifest = await loadManifest(tuckDir);
+  return manifest.files;
+};
+var isFileTracked = async (tuckDir, source) => {
+  const result = await getTrackedFileBySource(tuckDir, source);
+  return result !== null;
+};
+
+// src/lib/git.ts
+import simpleGit from "simple-git";
+var createGit = (dir) => {
+  return simpleGit(dir, {
+    binary: "git",
+    maxConcurrentProcesses: 6,
+    trimmed: true
+  });
+};
+var initRepo = async (dir) => {
+  try {
+    const git = createGit(dir);
+    await git.init();
+  } catch (error) {
+    throw new GitError("Failed to initialize repository", String(error));
+  }
+};
+var cloneRepo = async (url, dir) => {
+  try {
+    const git = simpleGit();
+    await git.clone(url, dir);
+  } catch (error) {
+    throw new GitError(`Failed to clone repository from ${url}`, String(error));
+  }
+};
+var addRemote = async (dir, name, url) => {
+  try {
+    const git = createGit(dir);
+    await git.addRemote(name, url);
+  } catch (error) {
+    throw new GitError("Failed to add remote", String(error));
+  }
+};
+var getRemotes = async (dir) => {
+  try {
+    const git = createGit(dir);
+    const remotes = await git.getRemotes(true);
+    return remotes.map((r) => ({ name: r.name, url: r.refs.fetch || r.refs.push || "" }));
+  } catch (error) {
+    throw new GitError("Failed to get remotes", String(error));
+  }
+};
+var getStatus = async (dir) => {
+  try {
+    const git = createGit(dir);
+    const status = await git.status();
+    return {
+      isRepo: true,
+      branch: status.current || "main",
+      tracking: status.tracking || void 0,
+      ahead: status.ahead,
+      behind: status.behind,
+      staged: status.staged,
+      modified: status.modified,
+      untracked: status.not_added,
+      deleted: status.deleted,
+      hasChanges: !status.isClean()
+    };
+  } catch (error) {
+    throw new GitError("Failed to get status", String(error));
+  }
+};
+var stageAll = async (dir) => {
+  try {
+    const git = createGit(dir);
+    await git.add(".");
+  } catch (error) {
+    throw new GitError("Failed to stage all files", String(error));
+  }
+};
+var commit = async (dir, message) => {
+  try {
+    const git = createGit(dir);
+    const result = await git.commit(message);
+    return result.commit;
+  } catch (error) {
+    throw new GitError("Failed to commit", String(error));
+  }
+};
+var push = async (dir, options) => {
+  try {
+    const git = createGit(dir);
+    const args = [];
+    if (options?.setUpstream) {
+      args.push("-u");
+    }
+    if (options?.force) {
+      args.push("--force");
+    }
+    const remote = options?.remote || "origin";
+    const branch = options?.branch;
+    if (branch) {
+      await git.push([remote, branch, ...args]);
+    } else {
+      await git.push([remote, ...args]);
+    }
+  } catch (error) {
+    throw new GitError("Failed to push", String(error));
+  }
+};
+var pull = async (dir, options) => {
+  try {
+    const git = createGit(dir);
+    const args = [];
+    if (options?.rebase) {
+      args.push("--rebase");
+    }
+    const remote = options?.remote || "origin";
+    const branch = options?.branch;
+    if (branch) {
+      await git.pull(remote, branch, args);
+    } else {
+      await git.pull(remote, void 0, args);
+    }
+  } catch (error) {
+    throw new GitError("Failed to pull", String(error));
+  }
+};
+var fetch = async (dir, remote = "origin") => {
+  try {
+    const git = createGit(dir);
+    await git.fetch(remote);
+  } catch (error) {
+    throw new GitError("Failed to fetch", String(error));
+  }
+};
+var getDiff = async (dir, options) => {
+  try {
+    const git = createGit(dir);
+    const args = [];
+    if (options?.staged) {
+      args.push("--staged");
+    }
+    if (options?.stat) {
+      args.push("--stat");
+    }
+    if (options?.files) {
+      args.push("--");
+      args.push(...options.files);
+    }
+    const result = await git.diff(args);
+    return result;
+  } catch (error) {
+    throw new GitError("Failed to get diff", String(error));
+  }
+};
+var getCurrentBranch = async (dir) => {
+  try {
+    const git = createGit(dir);
+    const branch = await git.revparse(["--abbrev-ref", "HEAD"]);
+    return branch;
+  } catch (error) {
+    throw new GitError("Failed to get current branch", String(error));
+  }
+};
+var hasRemote = async (dir, name = "origin") => {
+  try {
+    const remotes = await getRemotes(dir);
+    return remotes.some((r) => r.name === name);
+  } catch {
+    return false;
+  }
+};
+var getRemoteUrl = async (dir, name = "origin") => {
+  try {
+    const remotes = await getRemotes(dir);
+    const remote = remotes.find((r) => r.name === name);
+    return remote?.url || null;
+  } catch {
+    return null;
+  }
+};
+var setDefaultBranch = async (dir, branch) => {
+  try {
+    const git = createGit(dir);
+    await git.branch(["-M", branch]);
+  } catch (error) {
+    throw new GitError("Failed to set default branch", String(error));
+  }
+};
+
+// src/commands/init.ts
+var GITIGNORE_TEMPLATE = `# OS generated files
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Backup files
+*.bak
+*.backup
+*~
+
+# Secret files (add patterns for files you want to exclude)
+# *.secret
+# .env.local
+`;
+var README_TEMPLATE = (machine) => `# Dotfiles
+
+Managed with [tuck](https://github.com/Pranav-Karra-3301/tuck) - Modern Dotfiles Manager
+
+${machine ? `## Machine: ${machine}
+` : ""}
+
+## Quick Start
+
+\`\`\`bash
+# Restore dotfiles to a new machine
+tuck init --from <this-repo-url>
+
+# Or clone and restore manually
+git clone <this-repo-url> ~/.tuck
+tuck restore --all
+\`\`\`
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| \`tuck add <paths>\` | Track new dotfiles |
+| \`tuck sync\` | Sync changes to repository |
+| \`tuck push\` | Push to remote |
+| \`tuck pull\` | Pull from remote |
+| \`tuck restore\` | Restore dotfiles to system |
+| \`tuck status\` | Show tracking status |
+| \`tuck list\` | List tracked files |
+
+## Structure
+
+\`\`\`
+.tuck/
+\u251C\u2500\u2500 files/           # Tracked dotfiles organized by category
+\u2502   \u251C\u2500\u2500 shell/       # Shell configs (.zshrc, .bashrc, etc.)
+\u2502   \u251C\u2500\u2500 git/         # Git configs (.gitconfig, etc.)
+\u2502   \u251C\u2500\u2500 editors/     # Editor configs (nvim, vim, etc.)
+\u2502   \u251C\u2500\u2500 terminal/    # Terminal configs (tmux, alacritty, etc.)
+\u2502   \u2514\u2500\u2500 misc/        # Other dotfiles
+\u251C\u2500\u2500 .tuckmanifest.json  # Tracks all managed files
+\u2514\u2500\u2500 .tuckrc.json        # Tuck configuration
+\`\`\`
+`;
+var createDirectoryStructure = async (tuckDir) => {
+  await ensureDir(tuckDir);
+  await ensureDir(getFilesDir(tuckDir));
+  for (const category of Object.keys(CATEGORIES)) {
+    await ensureDir(getCategoryDir(tuckDir, category));
+  }
+};
+var createDefaultFiles = async (tuckDir, machine) => {
+  const gitignorePath = join3(tuckDir, ".gitignore");
+  await writeFile3(gitignorePath, GITIGNORE_TEMPLATE, "utf-8");
+  const readmePath = join3(tuckDir, "README.md");
+  await writeFile3(readmePath, README_TEMPLATE(machine), "utf-8");
+};
+var initFromScratch = async (tuckDir, options) => {
+  if (await pathExists(getManifestPath(tuckDir))) {
+    throw new AlreadyInitializedError(tuckDir);
+  }
+  await withSpinner("Creating directory structure...", async () => {
+    await createDirectoryStructure(tuckDir);
+  });
+  await withSpinner("Initializing git repository...", async () => {
+    await initRepo(tuckDir);
+    await setDefaultBranch(tuckDir, "main");
+  });
+  await withSpinner("Creating manifest...", async () => {
+    const hostname = (await import("os")).hostname();
+    await createManifest(tuckDir, hostname);
+  });
+  await withSpinner("Creating configuration...", async () => {
+    await saveConfig(
+      {
+        ...defaultConfig,
+        repository: { ...defaultConfig.repository, path: tuckDir }
+      },
+      tuckDir
+    );
+  });
+  if (!options.bare) {
+    await withSpinner("Creating default files...", async () => {
+      const hostname = (await import("os")).hostname();
+      await createDefaultFiles(tuckDir, hostname);
+    });
+  }
+  if (options.remote) {
+    await withSpinner("Adding remote...", async () => {
+      await addRemote(tuckDir, "origin", options.remote);
+    });
+  }
+};
+var initFromRemote = async (tuckDir, remoteUrl) => {
+  await withSpinner(`Cloning from ${remoteUrl}...`, async () => {
+    await cloneRepo(remoteUrl, tuckDir);
+  });
+  if (!await pathExists(getManifestPath(tuckDir))) {
+    logger.warning("No manifest found in cloned repository. Creating new manifest...");
+    const hostname = (await import("os")).hostname();
+    await createManifest(tuckDir, hostname);
+  }
+  if (!await pathExists(getConfigPath(tuckDir))) {
+    logger.warning("No config found in cloned repository. Creating default config...");
+    await saveConfig(
+      {
+        ...defaultConfig,
+        repository: { ...defaultConfig.repository, path: tuckDir }
+      },
+      tuckDir
+    );
+  }
+};
+var runInteractiveInit = async () => {
+  banner();
+  prompts.intro("tuck init");
+  const dirInput = await prompts.text("Where should tuck store your dotfiles?", {
+    defaultValue: "~/.tuck"
+  });
+  const tuckDir = getTuckDir(dirInput);
+  if (await pathExists(getManifestPath(tuckDir))) {
+    prompts.log.error(`Tuck is already initialized at ${collapsePath(tuckDir)}`);
+    prompts.outro("Use `tuck status` to see current state");
+    return;
+  }
+  const hasExisting = await prompts.select("Do you have an existing dotfiles repository?", [
+    { value: "no", label: "No, start fresh" },
+    { value: "yes", label: "Yes, clone from URL" }
+  ]);
+  if (hasExisting === "yes") {
+    const repoUrl = await prompts.text("Enter repository URL:", {
+      placeholder: "git@github.com:user/dotfiles.git",
+      validate: (value) => {
+        if (!value) return "Repository URL is required";
+        if (!value.includes("github.com") && !value.includes("gitlab.com") && !value.includes("git@")) {
+          return "Please enter a valid git URL";
+        }
+        return void 0;
+      }
+    });
+    await initFromRemote(tuckDir, repoUrl);
+    prompts.log.success("Repository cloned successfully!");
+    const shouldRestore = await prompts.confirm("Would you like to restore dotfiles now?", true);
+    if (shouldRestore) {
+      prompts.log.info("Run `tuck restore --all` to restore all dotfiles");
+    }
+  } else {
+    const existingDotfiles = [];
+    for (const df of COMMON_DOTFILES) {
+      const fullPath = expandPath(df.path);
+      if (await pathExists(fullPath)) {
+        existingDotfiles.push({
+          path: df.path,
+          label: `${df.path} (${df.category})`
+        });
+      }
+    }
+    await initFromScratch(tuckDir, {});
+    if (existingDotfiles.length > 0) {
+      const selectedFiles = await prompts.multiselect(
+        "Would you like to track some common dotfiles?",
+        existingDotfiles.map((f) => ({
+          value: f.path,
+          label: f.label
+        }))
+      );
+      if (selectedFiles.length > 0) {
+        prompts.log.step(
+          `Run the following to track these files:
+  tuck add ${selectedFiles.join(" ")}`
+        );
+      }
+    }
+    const wantsRemote = await prompts.confirm("Would you like to set up a remote repository?");
+    if (wantsRemote) {
+      const remoteUrl = await prompts.text("Enter remote URL:", {
+        placeholder: "git@github.com:user/dotfiles.git"
+      });
+      if (remoteUrl) {
+        await addRemote(tuckDir, "origin", remoteUrl);
+        prompts.log.success("Remote added successfully");
+      }
+    }
+  }
+  prompts.outro("Tuck initialized successfully!");
+  nextSteps([
+    `Add files:    tuck add ~/.zshrc`,
+    `Sync changes: tuck sync`,
+    `Push remote:  tuck push`
+  ]);
+};
+var runInit = async (options) => {
+  const tuckDir = getTuckDir(options.dir);
+  if (options.from) {
+    await initFromRemote(tuckDir, options.from);
+    logger.success(`Tuck initialized from ${options.from}`);
+    logger.info("Run `tuck restore --all` to restore dotfiles");
+    return;
+  }
+  await initFromScratch(tuckDir, {
+    remote: options.remote,
+    bare: options.bare
+  });
+  logger.success(`Tuck initialized at ${collapsePath(tuckDir)}`);
+  nextSteps([
+    `Add files:    tuck add ~/.zshrc`,
+    `Sync changes: tuck sync`,
+    `Push remote:  tuck push`
+  ]);
+};
+var initCommand = new Command("init").description("Initialize tuck repository").option("-d, --dir <path>", "Directory for tuck repository", "~/.tuck").option("-r, --remote <url>", "Git remote URL to set up").option("--bare", "Initialize without any default files").option("--from <url>", "Clone from existing tuck repository").action(async (options) => {
+  if (!options.remote && !options.bare && !options.from && options.dir === "~/.tuck") {
+    await runInteractiveInit();
+  } else {
+    await runInit(options);
+  }
+});
+
+// src/commands/add.ts
+import { Command as Command2 } from "commander";
+
+// src/lib/files.ts
+import { createHash } from "crypto";
+import { readFile as readFile3, stat as stat2, readdir, copyFile, symlink, unlink, rm } from "fs/promises";
+import { copy, ensureDir as ensureDir2 } from "fs-extra";
+import { join as join4, dirname as dirname2 } from "path";
+var getFileChecksum = async (filepath) => {
+  const expandedPath = expandPath(filepath);
+  if (await isDirectory(expandedPath)) {
+    const files = await getDirectoryFiles(expandedPath);
+    const hashes = [];
+    for (const file of files) {
+      const content2 = await readFile3(file);
+      hashes.push(createHash("sha256").update(content2).digest("hex"));
+    }
+    return createHash("sha256").update(hashes.join("")).digest("hex");
+  }
+  const content = await readFile3(expandedPath);
+  return createHash("sha256").update(content).digest("hex");
+};
+var getFileInfo = async (filepath) => {
+  const expandedPath = expandPath(filepath);
+  if (!await pathExists(expandedPath)) {
+    throw new FileNotFoundError(filepath);
+  }
+  try {
+    const stats = await stat2(expandedPath);
+    const permissions = (stats.mode & 511).toString(8).padStart(3, "0");
+    return {
+      path: expandedPath,
+      isDirectory: stats.isDirectory(),
+      isSymlink: stats.isSymbolicLink(),
+      size: stats.size,
+      permissions,
+      modified: stats.mtime
+    };
+  } catch (error) {
+    throw new PermissionError(filepath, "read");
+  }
+};
+var getDirectoryFiles = async (dirpath) => {
+  const expandedPath = expandPath(dirpath);
+  const files = [];
+  const entries = await readdir(expandedPath, { withFileTypes: true });
+  for (const entry of entries) {
+    const entryPath = join4(expandedPath, entry.name);
+    if (entry.isDirectory()) {
+      const subFiles = await getDirectoryFiles(entryPath);
+      files.push(...subFiles);
+    } else if (entry.isFile()) {
+      files.push(entryPath);
+    }
+  }
+  return files.sort();
+};
+var getDirectoryFileCount = async (dirpath) => {
+  const files = await getDirectoryFiles(dirpath);
+  return files.length;
+};
+var copyFileOrDir = async (source, destination, options) => {
+  const expandedSource = expandPath(source);
+  const expandedDest = expandPath(destination);
+  if (!await pathExists(expandedSource)) {
+    throw new FileNotFoundError(source);
+  }
+  await ensureDir2(dirname2(expandedDest));
+  const sourceIsDir = await isDirectory(expandedSource);
+  try {
+    if (sourceIsDir) {
+      await copy(expandedSource, expandedDest, { overwrite: options?.overwrite ?? true });
+      const fileCount = await getDirectoryFileCount(expandedDest);
+      const files = await getDirectoryFiles(expandedDest);
+      let totalSize = 0;
+      for (const file of files) {
+        const stats = await stat2(file);
+        totalSize += stats.size;
+      }
+      return { source: expandedSource, destination: expandedDest, fileCount, totalSize };
+    } else {
+      await copyFile(expandedSource, expandedDest);
+      const stats = await stat2(expandedDest);
+      return { source: expandedSource, destination: expandedDest, fileCount: 1, totalSize: stats.size };
+    }
+  } catch (error) {
+    throw new PermissionError(destination, "write");
+  }
+};
+var createSymlink = async (target, linkPath, options) => {
+  const expandedTarget = expandPath(target);
+  const expandedLink = expandPath(linkPath);
+  if (!await pathExists(expandedTarget)) {
+    throw new FileNotFoundError(target);
+  }
+  await ensureDir2(dirname2(expandedLink));
+  if (options?.overwrite && await pathExists(expandedLink)) {
+    await unlink(expandedLink);
+  }
+  try {
+    await symlink(expandedTarget, expandedLink);
+  } catch (error) {
+    throw new PermissionError(linkPath, "create symlink");
+  }
+};
+var deleteFileOrDir = async (filepath) => {
+  const expandedPath = expandPath(filepath);
+  if (!await pathExists(expandedPath)) {
+    return;
+  }
+  try {
+    if (await isDirectory(expandedPath)) {
+      await rm(expandedPath, { recursive: true });
+    } else {
+      await unlink(expandedPath);
+    }
+  } catch (error) {
+    throw new PermissionError(filepath, "delete");
+  }
+};
+
+// src/commands/add.ts
+var validateAndPrepareFiles = async (paths, tuckDir, options) => {
+  const filesToAdd = [];
+  for (const path of paths) {
+    const expandedPath = expandPath(path);
+    const collapsedPath = collapsePath(expandedPath);
+    if (!await pathExists(expandedPath)) {
+      throw new FileNotFoundError(path);
+    }
+    if (await isFileTracked(tuckDir, collapsedPath)) {
+      throw new FileAlreadyTrackedError(path);
+    }
+    const isDir = await isDirectory(expandedPath);
+    const fileCount = isDir ? await getDirectoryFileCount(expandedPath) : 1;
+    const category = options.category || detectCategory(expandedPath);
+    const filename = options.name || sanitizeFilename(expandedPath);
+    const destination = getDestinationPath(tuckDir, category, filename);
+    filesToAdd.push({
+      source: collapsedPath,
+      destination,
+      category,
+      filename,
+      isDir,
+      fileCount
+    });
+  }
+  return filesToAdd;
+};
+var addFiles = async (filesToAdd, tuckDir, options) => {
+  const config = await loadConfig(tuckDir);
+  const strategy = options.symlink ? "symlink" : config.files.strategy || "copy";
+  for (const file of filesToAdd) {
+    const expandedSource = expandPath(file.source);
+    await withSpinner(`Copying ${file.source}...`, async () => {
+      await copyFileOrDir(expandedSource, file.destination, { overwrite: true });
+    });
+    const checksum = await getFileChecksum(file.destination);
+    const info = await getFileInfo(expandedSource);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const id = generateFileId(file.source);
+    await addFileToManifest(tuckDir, id, {
+      source: file.source,
+      destination: getRelativeDestination(file.category, file.filename),
+      category: file.category,
+      strategy,
+      encrypted: options.encrypt || false,
+      template: options.template || false,
+      permissions: info.permissions,
+      added: now,
+      modified: now,
+      checksum
+    });
+    const categoryInfo = CATEGORIES[file.category];
+    const icon = categoryInfo?.icon || "\u{1F4C4}";
+    logger.success(`Added ${file.source}`);
+    logger.dim(`  ${icon} Category: ${file.category}`);
+    if (file.isDir) {
+      logger.dim(`  \u{1F4C1} Directory with ${file.fileCount} files`);
+    }
+  }
+};
+var runInteractiveAdd = async (tuckDir) => {
+  prompts.intro("tuck add");
+  const pathsInput = await prompts.text("Enter file paths to track (space-separated):", {
+    placeholder: "~/.zshrc ~/.gitconfig",
+    validate: (value) => {
+      if (!value.trim()) return "At least one path is required";
+      return void 0;
+    }
+  });
+  const paths = pathsInput.split(/\s+/).filter(Boolean);
+  let filesToAdd;
+  try {
+    filesToAdd = await validateAndPrepareFiles(paths, tuckDir, {});
+  } catch (error) {
+    if (error instanceof Error) {
+      prompts.log.error(error.message);
+    }
+    prompts.cancel();
+    return;
+  }
+  for (const file of filesToAdd) {
+    prompts.log.step(`${file.source}`);
+    const categoryOptions = Object.entries(CATEGORIES).map(([name, config]) => ({
+      value: name,
+      label: `${config.icon} ${name}`,
+      hint: file.category === name ? "(auto-detected)" : void 0
+    }));
+    categoryOptions.sort((a, b) => {
+      if (a.value === file.category) return -1;
+      if (b.value === file.category) return 1;
+      return 0;
+    });
+    const selectedCategory = await prompts.select("Category:", categoryOptions);
+    file.category = selectedCategory;
+    file.destination = getDestinationPath(tuckDir, file.category, file.filename);
+  }
+  const confirm2 = await prompts.confirm(
+    `Add ${filesToAdd.length} ${filesToAdd.length === 1 ? "file" : "files"}?`,
+    true
+  );
+  if (!confirm2) {
+    prompts.cancel("Operation cancelled");
+    return;
+  }
+  await addFiles(filesToAdd, tuckDir, {});
+  prompts.outro(`Added ${filesToAdd.length} ${filesToAdd.length === 1 ? "file" : "files"}`);
+  logger.info("Run 'tuck sync' to commit changes");
+};
+var runAdd = async (paths, options) => {
+  const tuckDir = getTuckDir();
+  try {
+    await loadManifest(tuckDir);
+  } catch {
+    throw new NotInitializedError();
+  }
+  if (paths.length === 0) {
+    await runInteractiveAdd(tuckDir);
+    return;
+  }
+  const filesToAdd = await validateAndPrepareFiles(paths, tuckDir, options);
+  await addFiles(filesToAdd, tuckDir, options);
+  logger.blank();
+  logger.success(`Added ${filesToAdd.length} ${filesToAdd.length === 1 ? "item" : "items"}`);
+  logger.info("Run 'tuck sync' to commit changes");
+};
+var addCommand = new Command2("add").description("Track new dotfiles").argument("[paths...]", "Paths to dotfiles to track").option("-c, --category <name>", "Category to organize under").option("-n, --name <name>", "Custom name for the file in manifest").option("--symlink", "Create symlink instead of copy").option("--encrypt", "Encrypt this file (requires GPG setup)").option("--template", "Treat as template with variable substitution").action(async (paths, options) => {
+  await runAdd(paths, options);
+});
+
+// src/commands/remove.ts
+import { Command as Command3 } from "commander";
+import { join as join5 } from "path";
+var validateAndPrepareFiles2 = async (paths, tuckDir) => {
+  const filesToRemove = [];
+  for (const path of paths) {
+    const expandedPath = expandPath(path);
+    const collapsedPath = collapsePath(expandedPath);
+    const tracked = await getTrackedFileBySource(tuckDir, collapsedPath);
+    if (!tracked) {
+      throw new FileNotTrackedError(path);
+    }
+    filesToRemove.push({
+      id: tracked.id,
+      source: tracked.file.source,
+      destination: join5(tuckDir, tracked.file.destination)
+    });
+  }
+  return filesToRemove;
+};
+var removeFiles = async (filesToRemove, tuckDir, options) => {
+  for (const file of filesToRemove) {
+    await removeFileFromManifest(tuckDir, file.id);
+    if (options.delete) {
+      if (await pathExists(file.destination)) {
+        await withSpinner(`Deleting ${file.source} from repository...`, async () => {
+          await deleteFileOrDir(file.destination);
+        });
+      }
+    }
+    logger.success(`Removed ${file.source} from tracking`);
+    if (options.delete) {
+      logger.dim("  Also deleted from repository");
+    }
+  }
+};
+var runInteractiveRemove = async (tuckDir) => {
+  prompts.intro("tuck remove");
+  const trackedFiles = await getAllTrackedFiles(tuckDir);
+  const fileEntries = Object.entries(trackedFiles);
+  if (fileEntries.length === 0) {
+    prompts.log.warning("No files are currently tracked");
+    prompts.outro("");
+    return;
+  }
+  const selectedFiles = await prompts.multiselect(
+    "Select files to stop tracking:",
+    fileEntries.map(([id, file]) => ({
+      value: id,
+      label: file.source,
+      hint: file.category
+    })),
+    true
+  );
+  if (selectedFiles.length === 0) {
+    prompts.cancel("No files selected");
+    return;
+  }
+  const shouldDelete = await prompts.confirm("Also delete files from repository?");
+  const confirm2 = await prompts.confirm(
+    `Remove ${selectedFiles.length} ${selectedFiles.length === 1 ? "file" : "files"} from tracking?`,
+    true
+  );
+  if (!confirm2) {
+    prompts.cancel("Operation cancelled");
+    return;
+  }
+  const filesToRemove = selectedFiles.map((id) => {
+    const file = trackedFiles[id];
+    return {
+      id,
+      source: file.source,
+      destination: join5(tuckDir, file.destination)
+    };
+  });
+  await removeFiles(filesToRemove, tuckDir, { delete: shouldDelete });
+  prompts.outro(`Removed ${selectedFiles.length} ${selectedFiles.length === 1 ? "file" : "files"}`);
+  logger.info("Run 'tuck sync' to commit changes");
+};
+var runRemove = async (paths, options) => {
+  const tuckDir = getTuckDir();
+  try {
+    await loadManifest(tuckDir);
+  } catch {
+    throw new NotInitializedError();
+  }
+  if (paths.length === 0) {
+    await runInteractiveRemove(tuckDir);
+    return;
+  }
+  const filesToRemove = await validateAndPrepareFiles2(paths, tuckDir);
+  await removeFiles(filesToRemove, tuckDir, options);
+  logger.blank();
+  logger.success(`Removed ${filesToRemove.length} ${filesToRemove.length === 1 ? "item" : "items"} from tracking`);
+  logger.info("Run 'tuck sync' to commit changes");
+};
+var removeCommand = new Command3("remove").description("Stop tracking dotfiles").argument("[paths...]", "Paths to dotfiles to untrack").option("--delete", "Also delete from tuck repository").option("--keep-original", "Don't restore symlinks to regular files").action(async (paths, options) => {
+  await runRemove(paths, options);
+});
+
+// src/commands/sync.ts
+import { Command as Command4 } from "commander";
+import chalk8 from "chalk";
+import { join as join6 } from "path";
+
+// src/lib/hooks.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+import chalk7 from "chalk";
+var execAsync = promisify(exec);
+var runHook = async (hookType, tuckDir, options) => {
+  if (options?.skipHooks) {
+    return { success: true, skipped: true };
+  }
+  const config = await loadConfig(tuckDir);
+  const command = config.hooks[hookType];
+  if (!command) {
+    return { success: true };
+  }
+  if (!options?.trustHooks) {
+    console.log();
+    console.log(chalk7.yellow.bold("\u26A0\uFE0F  Hook Execution Warning"));
+    console.log(chalk7.dim("\u2500".repeat(50)));
+    console.log(chalk7.white(`Hook type: ${chalk7.cyan(hookType)}`));
+    console.log(chalk7.white("Command:"));
+    console.log(chalk7.red(`  ${command}`));
+    console.log(chalk7.dim("\u2500".repeat(50)));
+    console.log(
+      chalk7.yellow(
+        "SECURITY: Hooks can execute arbitrary commands on your system."
+      )
+    );
+    console.log(
+      chalk7.yellow(
+        "Only proceed if you trust the source of this configuration."
+      )
+    );
+    console.log();
+    const confirmed = await prompts.confirm(
+      "Execute this hook?",
+      false
+      // Default to NO for safety
+    );
+    if (!confirmed) {
+      logger.warning(`Hook ${hookType} skipped by user`);
+      return { success: true, skipped: true };
+    }
+  }
+  if (!options?.silent) {
+    logger.dim(`Running ${hookType} hook...`);
+  }
+  try {
+    const { stdout, stderr } = await execAsync(command, {
+      cwd: tuckDir,
+      timeout: 3e4,
+      // 30 second timeout
+      env: {
+        ...process.env,
+        TUCK_DIR: tuckDir,
+        TUCK_HOOK: hookType
+      }
+    });
+    if (stdout && !options?.silent) {
+      logger.dim(stdout.trim());
+    }
+    if (stderr && !options?.silent) {
+      logger.warning(stderr.trim());
+    }
+    return { success: true, output: stdout };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    if (!options?.silent) {
+      logger.error(`Hook ${hookType} failed: ${errorMessage}`);
+    }
+    return { success: false, error: errorMessage };
+  }
+};
+var runPreSyncHook = async (tuckDir, options) => {
+  return runHook("preSync", tuckDir, options);
+};
+var runPostSyncHook = async (tuckDir, options) => {
+  return runHook("postSync", tuckDir, options);
+};
+var runPreRestoreHook = async (tuckDir, options) => {
+  return runHook("preRestore", tuckDir, options);
+};
+var runPostRestoreHook = async (tuckDir, options) => {
+  return runHook("postRestore", tuckDir, options);
+};
+
+// src/commands/sync.ts
+var detectChanges = async (tuckDir) => {
+  const files = await getAllTrackedFiles(tuckDir);
+  const changes = [];
+  for (const [, file] of Object.entries(files)) {
+    const sourcePath = expandPath(file.source);
+    if (!await pathExists(sourcePath)) {
+      changes.push({
+        path: file.source,
+        status: "deleted",
+        source: file.source,
+        destination: file.destination
+      });
+      continue;
+    }
+    try {
+      const sourceChecksum = await getFileChecksum(sourcePath);
+      if (sourceChecksum !== file.checksum) {
+        changes.push({
+          path: file.source,
+          status: "modified",
+          source: file.source,
+          destination: file.destination
+        });
+      }
+    } catch {
+      changes.push({
+        path: file.source,
+        status: "modified",
+        source: file.source,
+        destination: file.destination
+      });
+    }
+  }
+  return changes;
+};
+var generateCommitMessage = (result) => {
+  const parts = [];
+  if (result.added.length > 0) {
+    parts.push(`Add: ${result.added.join(", ")}`);
+  }
+  if (result.modified.length > 0) {
+    parts.push(`Update: ${result.modified.join(", ")}`);
+  }
+  if (result.deleted.length > 0) {
+    parts.push(`Remove: ${result.deleted.join(", ")}`);
+  }
+  if (parts.length === 0) {
+    return "Sync dotfiles";
+  }
+  const totalCount = result.added.length + result.modified.length + result.deleted.length;
+  if (parts.length === 1 && totalCount <= 3) {
+    return parts[0];
+  }
+  return `Sync: ${totalCount} file${totalCount > 1 ? "s" : ""} changed`;
+};
+var syncFiles = async (tuckDir, changes, options) => {
+  const result = {
+    modified: [],
+    added: [],
+    deleted: []
+  };
+  const hookOptions = {
+    skipHooks: options.noHooks,
+    trustHooks: options.trustHooks
+  };
+  await runPreSyncHook(tuckDir, hookOptions);
+  for (const change of changes) {
+    const sourcePath = expandPath(change.source);
+    const destPath = join6(tuckDir, change.destination);
+    if (change.status === "modified") {
+      await withSpinner(`Syncing ${change.path}...`, async () => {
+        await copyFileOrDir(sourcePath, destPath, { overwrite: true });
+        const newChecksum = await getFileChecksum(destPath);
+        const files = await getAllTrackedFiles(tuckDir);
+        const fileId = Object.entries(files).find(([, f]) => f.source === change.source)?.[0];
+        if (fileId) {
+          await updateFileInManifest(tuckDir, fileId, {
+            checksum: newChecksum,
+            modified: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        }
+      });
+      result.modified.push(change.path.split("/").pop() || change.path);
+    } else if (change.status === "deleted") {
+      logger.warning(`Source file deleted: ${change.path}`);
+      result.deleted.push(change.path.split("/").pop() || change.path);
+    }
+  }
+  if (!options.noCommit && (result.modified.length > 0 || result.deleted.length > 0)) {
+    await withSpinner("Staging changes...", async () => {
+      await stageAll(tuckDir);
+    });
+    const message = options.message || generateCommitMessage(result);
+    await withSpinner("Committing...", async () => {
+      result.commitHash = await commit(tuckDir, message);
+    });
+  }
+  await runPostSyncHook(tuckDir, hookOptions);
+  return result;
+};
+var runInteractiveSync = async (tuckDir) => {
+  prompts.intro("tuck sync");
+  const spinner2 = prompts.spinner();
+  spinner2.start("Detecting changes...");
+  const changes = await detectChanges(tuckDir);
+  spinner2.stop("Changes detected");
+  if (changes.length === 0) {
+    const gitStatus = await getStatus(tuckDir);
+    if (gitStatus.hasChanges) {
+      prompts.log.info("No dotfile changes, but repository has uncommitted changes");
+      const commitAnyway = await prompts.confirm("Commit repository changes?");
+      if (commitAnyway) {
+        const message2 = await prompts.text("Commit message:", {
+          defaultValue: "Update dotfiles"
+        });
+        await stageAll(tuckDir);
+        const hash = await commit(tuckDir, message2);
+        prompts.log.success(`Committed: ${hash.slice(0, 7)}`);
+      }
+    } else {
+      prompts.log.success("Everything is up to date");
+    }
+    return;
+  }
+  console.log();
+  console.log(chalk8.bold("Changes detected:"));
+  for (const change of changes) {
+    if (change.status === "modified") {
+      console.log(chalk8.yellow(`  ~ ${change.path}`));
+    } else if (change.status === "deleted") {
+      console.log(chalk8.red(`  - ${change.path}`));
+    }
+  }
+  console.log();
+  const confirm2 = await prompts.confirm("Sync these changes?", true);
+  if (!confirm2) {
+    prompts.cancel("Operation cancelled");
+    return;
+  }
+  const autoMessage = generateCommitMessage({
+    modified: changes.filter((c) => c.status === "modified").map((c) => c.path),
+    added: [],
+    deleted: changes.filter((c) => c.status === "deleted").map((c) => c.path)
+  });
+  const message = await prompts.text("Commit message:", {
+    defaultValue: autoMessage
+  });
+  const result = await syncFiles(tuckDir, changes, { message });
+  console.log();
+  if (result.commitHash) {
+    prompts.log.success(`Committed: ${result.commitHash.slice(0, 7)}`);
+  }
+  prompts.outro("Synced successfully!");
+  logger.info("Run 'tuck push' to upload to remote");
+};
+var runSync = async (messageArg, options) => {
+  const tuckDir = getTuckDir();
+  try {
+    await loadManifest(tuckDir);
+  } catch {
+    throw new NotInitializedError();
+  }
+  if (!messageArg && !options.message && !options.all && !options.noCommit && !options.amend) {
+    await runInteractiveSync(tuckDir);
+    return;
+  }
+  const changes = await detectChanges(tuckDir);
+  if (changes.length === 0) {
+    logger.info("No changes detected");
+    return;
+  }
+  logger.heading("Changes detected:");
+  for (const change of changes) {
+    logger.file(change.status === "modified" ? "modify" : "delete", change.path);
+  }
+  logger.blank();
+  const message = messageArg || options.message;
+  const result = await syncFiles(tuckDir, changes, { ...options, message });
+  logger.blank();
+  logger.success(`Synced ${changes.length} file${changes.length > 1 ? "s" : ""}`);
+  if (result.commitHash) {
+    logger.info(`Commit: ${result.commitHash.slice(0, 7)}`);
+  }
+  logger.info("Run 'tuck push' to upload to remote");
+};
+var syncCommand = new Command4("sync").description("Sync changes to repository").argument("[message]", "Commit message").option("-m, --message <msg>", "Commit message").option("-a, --all", "Sync all tracked files, not just changed").option("--no-commit", "Stage changes but don't commit").option("--amend", "Amend previous commit").option("--no-hooks", "Skip execution of pre/post sync hooks").option("--trust-hooks", "Trust and run hooks without confirmation (use with caution)").action(async (messageArg, options) => {
+  await runSync(messageArg, options);
+});
+
+// src/commands/push.ts
+import { Command as Command5 } from "commander";
+import chalk9 from "chalk";
+var runInteractivePush = async (tuckDir) => {
+  prompts.intro("tuck push");
+  const hasRemoteRepo = await hasRemote(tuckDir);
+  if (!hasRemoteRepo) {
+    prompts.log.warning("No remote configured");
+    const addRemoteNow = await prompts.confirm("Would you like to add a remote?");
+    if (!addRemoteNow) {
+      prompts.cancel("No remote to push to");
+      return;
+    }
+    const remoteUrl2 = await prompts.text("Enter remote URL:", {
+      placeholder: "git@github.com:user/dotfiles.git",
+      validate: (value) => {
+        if (!value) return "Remote URL is required";
+        return void 0;
+      }
+    });
+    await addRemote(tuckDir, "origin", remoteUrl2);
+    prompts.log.success("Remote added");
+  }
+  const status = await getStatus(tuckDir);
+  const branch = await getCurrentBranch(tuckDir);
+  const remoteUrl = await getRemoteUrl(tuckDir);
+  if (status.ahead === 0 && status.tracking) {
+    prompts.log.success("Already up to date with remote");
+    return;
+  }
+  console.log();
+  console.log(chalk9.dim("Remote:"), remoteUrl);
+  console.log(chalk9.dim("Branch:"), branch);
+  if (status.ahead > 0) {
+    console.log(chalk9.dim("Commits:"), chalk9.green(`\u2191 ${status.ahead} to push`));
+  }
+  if (status.behind > 0) {
+    console.log(chalk9.dim("Warning:"), chalk9.yellow(`\u2193 ${status.behind} commits behind remote`));
+    const pullFirst = await prompts.confirm("Pull changes first?", true);
+    if (pullFirst) {
+      prompts.log.info("Run 'tuck pull' first, then push");
+      return;
+    }
+  }
+  console.log();
+  const confirm2 = await prompts.confirm("Push to remote?", true);
+  if (!confirm2) {
+    prompts.cancel("Operation cancelled");
+    return;
+  }
+  const needsUpstream = !status.tracking;
+  await withSpinner("Pushing...", async () => {
+    await push(tuckDir, {
+      setUpstream: needsUpstream,
+      branch: needsUpstream ? branch : void 0
+    });
+  });
+  prompts.log.success("Pushed successfully!");
+  if (remoteUrl) {
+    let viewUrl = remoteUrl;
+    if (remoteUrl.startsWith("git@github.com:")) {
+      viewUrl = remoteUrl.replace("git@github.com:", "https://github.com/").replace(".git", "");
+    }
+    console.log();
+    console.log(chalk9.dim("View at:"), chalk9.cyan(viewUrl));
+  }
+  prompts.outro("");
+};
+var runPush = async (options) => {
+  const tuckDir = getTuckDir();
+  try {
+    await loadManifest(tuckDir);
+  } catch {
+    throw new NotInitializedError();
+  }
+  if (!options.force && !options.setUpstream) {
+    await runInteractivePush(tuckDir);
+    return;
+  }
+  const hasRemoteRepo = await hasRemote(tuckDir);
+  if (!hasRemoteRepo) {
+    throw new GitError("No remote configured", "Run 'tuck init -r <url>' or add a remote manually");
+  }
+  const branch = await getCurrentBranch(tuckDir);
+  await withSpinner("Pushing...", async () => {
+    await push(tuckDir, {
+      force: options.force,
+      setUpstream: Boolean(options.setUpstream),
+      branch: options.setUpstream || branch
+    });
+  });
+  logger.success("Pushed successfully!");
+};
+var pushCommand = new Command5("push").description("Push changes to remote repository").option("-f, --force", "Force push").option("--set-upstream <name>", "Set upstream branch").action(async (options) => {
+  await runPush(options);
+});
+
+// src/commands/pull.ts
+import { Command as Command6 } from "commander";
+import chalk10 from "chalk";
+var runInteractivePull = async (tuckDir) => {
+  prompts.intro("tuck pull");
+  const hasRemoteRepo = await hasRemote(tuckDir);
+  if (!hasRemoteRepo) {
+    prompts.log.error("No remote configured");
+    prompts.note("Run 'tuck init -r <url>' or add a remote manually", "Tip");
+    return;
+  }
+  await withSpinner("Fetching...", async () => {
+    await fetch(tuckDir);
+  });
+  const status = await getStatus(tuckDir);
+  const branch = await getCurrentBranch(tuckDir);
+  const remoteUrl = await getRemoteUrl(tuckDir);
+  console.log();
+  console.log(chalk10.dim("Remote:"), remoteUrl);
+  console.log(chalk10.dim("Branch:"), branch);
+  if (status.behind === 0) {
+    prompts.log.success("Already up to date");
+    return;
+  }
+  console.log(chalk10.dim("Commits:"), chalk10.yellow(`\u2193 ${status.behind} to pull`));
+  if (status.ahead > 0) {
+    console.log(
+      chalk10.dim("Note:"),
+      chalk10.yellow(`You also have ${status.ahead} local commit${status.ahead > 1 ? "s" : ""} to push`)
+    );
+  }
+  if (status.modified.length > 0 || status.staged.length > 0) {
+    console.log();
+    prompts.log.warning("You have uncommitted changes");
+    console.log(chalk10.dim("Modified:"), status.modified.join(", "));
+    const continueAnyway = await prompts.confirm("Pull anyway? (may cause merge conflicts)");
+    if (!continueAnyway) {
+      prompts.cancel("Commit or stash your changes first with 'tuck sync'");
+      return;
+    }
+  }
+  console.log();
+  const useRebase = await prompts.confirm("Use rebase instead of merge?");
+  await withSpinner("Pulling...", async () => {
+    await pull(tuckDir, { rebase: useRebase });
+  });
+  prompts.log.success("Pulled successfully!");
+  const shouldRestore = await prompts.confirm("Restore updated dotfiles to system?", true);
+  if (shouldRestore) {
+    prompts.note("Run 'tuck restore --all' to restore all dotfiles", "Next step");
+  }
+  prompts.outro("");
+};
+var runPull = async (options) => {
+  const tuckDir = getTuckDir();
+  try {
+    await loadManifest(tuckDir);
+  } catch {
+    throw new NotInitializedError();
+  }
+  if (!options.rebase && !options.restore) {
+    await runInteractivePull(tuckDir);
+    return;
+  }
+  const hasRemoteRepo = await hasRemote(tuckDir);
+  if (!hasRemoteRepo) {
+    throw new GitError("No remote configured", "Run 'tuck init -r <url>' or add a remote manually");
+  }
+  await withSpinner("Fetching...", async () => {
+    await fetch(tuckDir);
+  });
+  await withSpinner("Pulling...", async () => {
+    await pull(tuckDir, { rebase: options.rebase });
+  });
+  logger.success("Pulled successfully!");
+  if (options.restore) {
+    logger.info("Run 'tuck restore --all' to restore dotfiles");
+  }
+};
+var pullCommand = new Command6("pull").description("Pull changes from remote").option("--rebase", "Pull with rebase").option("--restore", "Also restore files to system after pull").action(async (options) => {
+  await runPull(options);
+});
+
+// src/commands/restore.ts
+import { Command as Command7 } from "commander";
+import chalk11 from "chalk";
+import { join as join8 } from "path";
+
+// src/lib/backup.ts
+import { join as join7 } from "path";
+import { copy as copy2, ensureDir as ensureDir3, pathExists as pathExists2 } from "fs-extra";
+var getBackupDir = () => {
+  return expandPath(BACKUP_DIR);
+};
+var formatDateForBackup = (date) => {
+  return date.toISOString().slice(0, 10);
+};
+var getTimestampedBackupDir = (date) => {
+  const backupRoot = getBackupDir();
+  const timestamp = formatDateForBackup(date);
+  return join7(backupRoot, timestamp);
+};
+var createBackup = async (sourcePath, customBackupDir) => {
+  const expandedSource = expandPath(sourcePath);
+  const date = /* @__PURE__ */ new Date();
+  if (!await pathExists(expandedSource)) {
+    throw new Error(`Source path does not exist: ${sourcePath}`);
+  }
+  const backupRoot = customBackupDir ? expandPath(customBackupDir) : getTimestampedBackupDir(date);
+  await ensureDir3(backupRoot);
+  const collapsed = collapsePath(expandedSource);
+  const backupName = collapsed.replace(/^~\//, "").replace(/\//g, "_").replace(/^\./, "dot-");
+  const timestamp = date.toISOString().replace(/[:.]/g, "-").slice(11, 19);
+  const backupPath = join7(backupRoot, `${backupName}_${timestamp}`);
+  await copy2(expandedSource, backupPath, { overwrite: true });
+  return {
+    originalPath: expandedSource,
+    backupPath,
+    date
+  };
+};
+
+// src/commands/restore.ts
+var prepareFilesToRestore = async (tuckDir, paths) => {
+  const allFiles = await getAllTrackedFiles(tuckDir);
+  const filesToRestore = [];
+  if (paths && paths.length > 0) {
+    for (const path of paths) {
+      const expandedPath = expandPath(path);
+      const collapsedPath = collapsePath(expandedPath);
+      const tracked = await getTrackedFileBySource(tuckDir, collapsedPath);
+      if (!tracked) {
+        throw new FileNotFoundError(`Not tracked: ${path}`);
+      }
+      filesToRestore.push({
+        id: tracked.id,
+        source: tracked.file.source,
+        destination: join8(tuckDir, tracked.file.destination),
+        category: tracked.file.category,
+        existsAtTarget: await pathExists(expandedPath)
+      });
+    }
+  } else {
+    for (const [id, file] of Object.entries(allFiles)) {
+      const targetPath = expandPath(file.source);
+      filesToRestore.push({
+        id,
+        source: file.source,
+        destination: join8(tuckDir, file.destination),
+        category: file.category,
+        existsAtTarget: await pathExists(targetPath)
+      });
+    }
+  }
+  return filesToRestore;
+};
+var restoreFiles = async (tuckDir, files, options) => {
+  const config = await loadConfig(tuckDir);
+  const useSymlink = options.symlink || config.files.strategy === "symlink";
+  const shouldBackup = options.backup ?? config.files.backupOnRestore;
+  const hookOptions = {
+    skipHooks: options.noHooks,
+    trustHooks: options.trustHooks
+  };
+  await runPreRestoreHook(tuckDir, hookOptions);
+  let restoredCount = 0;
+  for (const file of files) {
+    const targetPath = expandPath(file.source);
+    if (!await pathExists(file.destination)) {
+      logger.warning(`Source not found in repository: ${file.source}`);
+      continue;
+    }
+    if (options.dryRun) {
+      if (file.existsAtTarget) {
+        logger.file("modify", `${file.source} (would overwrite)`);
+      } else {
+        logger.file("add", `${file.source} (would create)`);
+      }
+      continue;
+    }
+    if (shouldBackup && file.existsAtTarget) {
+      await withSpinner(`Backing up ${file.source}...`, async () => {
+        await createBackup(targetPath);
+      });
+    }
+    await withSpinner(`Restoring ${file.source}...`, async () => {
+      if (useSymlink) {
+        await createSymlink(file.destination, targetPath, { overwrite: true });
+      } else {
+        await copyFileOrDir(file.destination, targetPath, { overwrite: true });
+      }
+    });
+    restoredCount++;
+  }
+  await runPostRestoreHook(tuckDir, hookOptions);
+  return restoredCount;
+};
+var runInteractiveRestore = async (tuckDir) => {
+  prompts.intro("tuck restore");
+  const files = await prepareFilesToRestore(tuckDir);
+  if (files.length === 0) {
+    prompts.log.warning("No files to restore");
+    prompts.note("Run 'tuck add <path>' to track files first", "Tip");
+    return;
+  }
+  const fileOptions = files.map((file) => {
+    const categoryConfig = CATEGORIES[file.category] || { icon: "\u{1F4C4}" };
+    const status = file.existsAtTarget ? chalk11.yellow("(exists, will backup)") : "";
+    return {
+      value: file.id,
+      label: `${categoryConfig.icon} ${file.source} ${status}`,
+      hint: file.category
+    };
+  });
+  const selectedIds = await prompts.multiselect("Select files to restore:", fileOptions, true);
+  if (selectedIds.length === 0) {
+    prompts.cancel("No files selected");
+    return;
+  }
+  const selectedFiles = files.filter((f) => selectedIds.includes(f.id));
+  const existingFiles = selectedFiles.filter((f) => f.existsAtTarget);
+  if (existingFiles.length > 0) {
+    console.log();
+    prompts.log.warning(
+      `${existingFiles.length} file${existingFiles.length > 1 ? "s" : ""} will be backed up:`
+    );
+    existingFiles.forEach((f) => console.log(chalk11.dim(`  ${f.source}`)));
+    console.log();
+  }
+  const useSymlink = await prompts.select("Restore method:", [
+    { value: false, label: "Copy files", hint: "Recommended" },
+    { value: true, label: "Create symlinks", hint: "Files stay in tuck repo" }
+  ]);
+  const confirm2 = await prompts.confirm(
+    `Restore ${selectedFiles.length} file${selectedFiles.length > 1 ? "s" : ""}?`,
+    true
+  );
+  if (!confirm2) {
+    prompts.cancel("Operation cancelled");
+    return;
+  }
+  const restoredCount = await restoreFiles(tuckDir, selectedFiles, {
+    symlink: useSymlink,
+    backup: true
+  });
+  console.log();
+  prompts.outro(`Restored ${restoredCount} file${restoredCount > 1 ? "s" : ""}`);
+};
+var runRestore = async (paths, options) => {
+  const tuckDir = getTuckDir();
+  try {
+    await loadManifest(tuckDir);
+  } catch {
+    throw new NotInitializedError();
+  }
+  if (paths.length === 0 && !options.all) {
+    await runInteractiveRestore(tuckDir);
+    return;
+  }
+  const files = await prepareFilesToRestore(tuckDir, options.all ? void 0 : paths);
+  if (files.length === 0) {
+    logger.warning("No files to restore");
+    return;
+  }
+  if (options.dryRun) {
+    logger.heading("Dry run - would restore:");
+  } else {
+    logger.heading("Restoring:");
+  }
+  const restoredCount = await restoreFiles(tuckDir, files, options);
+  logger.blank();
+  if (options.dryRun) {
+    logger.info(`Would restore ${files.length} file${files.length > 1 ? "s" : ""}`);
+  } else {
+    logger.success(`Restored ${restoredCount} file${restoredCount > 1 ? "s" : ""}`);
+  }
+};
+var restoreCommand = new Command7("restore").description("Restore dotfiles to the system").argument("[paths...]", "Paths to restore (or use --all)").option("-a, --all", "Restore all tracked files").option("--symlink", "Create symlinks instead of copies").option("--backup", "Backup existing files before restore").option("--no-backup", "Skip backup of existing files").option("--dry-run", "Show what would be done").option("--no-hooks", "Skip execution of pre/post restore hooks").option("--trust-hooks", "Trust and run hooks without confirmation (use with caution)").action(async (paths, options) => {
+  await runRestore(paths, options);
+});
+
+// src/commands/status.ts
+import { Command as Command8 } from "commander";
+import chalk12 from "chalk";
+var detectFileChanges = async (tuckDir) => {
+  const files = await getAllTrackedFiles(tuckDir);
+  const changes = [];
+  for (const [, file] of Object.entries(files)) {
+    const sourcePath = expandPath(file.source);
+    if (!await pathExists(sourcePath)) {
+      changes.push({
+        path: file.source,
+        status: "deleted",
+        source: file.source,
+        destination: file.destination
+      });
+      continue;
+    }
+    try {
+      const sourceChecksum = await getFileChecksum(sourcePath);
+      if (sourceChecksum !== file.checksum) {
+        changes.push({
+          path: file.source,
+          status: "modified",
+          source: file.source,
+          destination: file.destination
+        });
+      }
+    } catch {
+      changes.push({
+        path: file.source,
+        status: "modified",
+        source: file.source,
+        destination: file.destination
+      });
+    }
+  }
+  return changes;
+};
+var getFullStatus = async (tuckDir) => {
+  const manifest = await loadManifest(tuckDir);
+  const gitStatus = await getStatus(tuckDir);
+  const branch = await getCurrentBranch(tuckDir);
+  const hasRemoteRepo = await hasRemote(tuckDir);
+  const remoteUrl = hasRemoteRepo ? await getRemoteUrl(tuckDir) : void 0;
+  let remoteStatus = "no-remote";
+  if (hasRemoteRepo) {
+    if (gitStatus.ahead > 0 && gitStatus.behind > 0) {
+      remoteStatus = "diverged";
+    } else if (gitStatus.ahead > 0) {
+      remoteStatus = "ahead";
+    } else if (gitStatus.behind > 0) {
+      remoteStatus = "behind";
+    } else {
+      remoteStatus = "up-to-date";
+    }
+  }
+  const fileChanges = await detectFileChanges(tuckDir);
+  return {
+    tuckDir,
+    branch,
+    remote: remoteUrl || void 0,
+    remoteStatus,
+    ahead: gitStatus.ahead,
+    behind: gitStatus.behind,
+    trackedCount: Object.keys(manifest.files).length,
+    changes: fileChanges,
+    gitChanges: {
+      staged: gitStatus.staged,
+      modified: gitStatus.modified,
+      untracked: gitStatus.untracked
+    }
+  };
+};
+var printStatus = (status) => {
+  prompts.intro("tuck status");
+  console.log();
+  console.log(chalk12.dim("Repository:"), collapsePath(status.tuckDir));
+  console.log(chalk12.dim("Branch:"), chalk12.cyan(status.branch));
+  if (status.remote) {
+    console.log(chalk12.dim("Remote:"), status.remote);
+    let remoteInfo = "";
+    switch (status.remoteStatus) {
+      case "up-to-date":
+        remoteInfo = chalk12.green("up to date");
+        break;
+      case "ahead":
+        remoteInfo = chalk12.yellow(`${status.ahead} commit${status.ahead > 1 ? "s" : ""} ahead`);
+        break;
+      case "behind":
+        remoteInfo = chalk12.yellow(`${status.behind} commit${status.behind > 1 ? "s" : ""} behind`);
+        break;
+      case "diverged":
+        remoteInfo = chalk12.red(`diverged (${status.ahead} ahead, ${status.behind} behind)`);
+        break;
+    }
+    console.log(chalk12.dim("Status:"), remoteInfo);
+  } else {
+    console.log(chalk12.dim("Remote:"), chalk12.yellow("not configured"));
+  }
+  console.log();
+  console.log(chalk12.dim("Tracked files:"), status.trackedCount);
+  if (status.changes.length > 0) {
+    console.log();
+    console.log(chalk12.bold("Changes detected:"));
+    for (const change of status.changes) {
+      const statusText = formatStatus(change.status);
+      console.log(`  ${statusText}: ${chalk12.cyan(change.path)}`);
+    }
+  }
+  const hasGitChanges = status.gitChanges.staged.length > 0 || status.gitChanges.modified.length > 0 || status.gitChanges.untracked.length > 0;
+  if (hasGitChanges) {
+    console.log();
+    console.log(chalk12.bold("Repository changes:"));
+    if (status.gitChanges.staged.length > 0) {
+      console.log(chalk12.green("  Staged:"));
+      status.gitChanges.staged.forEach((f) => console.log(chalk12.green(`    + ${f}`)));
+    }
+    if (status.gitChanges.modified.length > 0) {
+      console.log(chalk12.yellow("  Modified:"));
+      status.gitChanges.modified.forEach((f) => console.log(chalk12.yellow(`    ~ ${f}`)));
+    }
+    if (status.gitChanges.untracked.length > 0) {
+      console.log(chalk12.dim("  Untracked:"));
+      status.gitChanges.untracked.forEach((f) => console.log(chalk12.dim(`    ? ${f}`)));
+    }
+  }
+  console.log();
+  if (status.changes.length > 0) {
+    prompts.note("Run 'tuck sync' to commit changes", "Next step");
+  } else if (status.remoteStatus === "ahead") {
+    prompts.note("Run 'tuck push' to push changes to remote", "Next step");
+  } else if (status.remoteStatus === "behind") {
+    prompts.note("Run 'tuck pull' to pull changes from remote", "Next step");
+  } else if (status.trackedCount === 0) {
+    prompts.note("Run 'tuck add <path>' to start tracking files", "Next step");
+  } else {
+    prompts.outro("Everything is up to date");
+  }
+};
+var printShortStatus = (status) => {
+  const parts = [];
+  parts.push(`[${status.branch}]`);
+  if (status.remoteStatus === "ahead") {
+    parts.push(`\u2191${status.ahead}`);
+  } else if (status.remoteStatus === "behind") {
+    parts.push(`\u2193${status.behind}`);
+  } else if (status.remoteStatus === "diverged") {
+    parts.push(`\u2191${status.ahead}\u2193${status.behind}`);
+  }
+  if (status.changes.length > 0) {
+    const modified = status.changes.filter((c) => c.status === "modified").length;
+    const deleted = status.changes.filter((c) => c.status === "deleted").length;
+    if (modified > 0) parts.push(`~${modified}`);
+    if (deleted > 0) parts.push(`-${deleted}`);
+  }
+  parts.push(`(${status.trackedCount} tracked)`);
+  console.log(parts.join(" "));
+};
+var printJsonStatus = (status) => {
+  console.log(JSON.stringify(status, null, 2));
+};
+var runStatus = async (options) => {
+  const tuckDir = getTuckDir();
+  try {
+    await loadManifest(tuckDir);
+  } catch {
+    throw new NotInitializedError();
+  }
+  const status = await getFullStatus(tuckDir);
+  if (options.json) {
+    printJsonStatus(status);
+  } else if (options.short) {
+    printShortStatus(status);
+  } else {
+    printStatus(status);
+  }
+};
+var statusCommand = new Command8("status").description("Show current tracking status").option("--short", "Short format").option("--json", "Output as JSON").action(async (options) => {
+  await runStatus(options);
+});
+
+// src/commands/list.ts
+import { Command as Command9 } from "commander";
+import chalk13 from "chalk";
+var groupByCategory = async (tuckDir) => {
+  const files = await getAllTrackedFiles(tuckDir);
+  const groups = /* @__PURE__ */ new Map();
+  for (const [id, file] of Object.entries(files)) {
+    const category = file.category;
+    const categoryConfig = CATEGORIES[category] || { icon: "\u{1F4C4}" };
+    if (!groups.has(category)) {
+      groups.set(category, {
+        name: category,
+        icon: categoryConfig.icon,
+        files: []
+      });
+    }
+    groups.get(category).files.push({
+      id,
+      source: file.source,
+      destination: file.destination,
+      isDir: file.destination.endsWith("/") || file.destination.includes("nvim")
+    });
+  }
+  return Array.from(groups.values()).sort((a, b) => a.name.localeCompare(b.name)).map((group2) => ({
+    ...group2,
+    files: group2.files.sort((a, b) => a.source.localeCompare(b.source))
+  }));
+};
+var printList = (groups) => {
+  prompts.intro("tuck list");
+  if (groups.length === 0) {
+    prompts.log.warning("No files are currently tracked");
+    prompts.note("Run 'tuck add <path>' to start tracking files", "Tip");
+    return;
+  }
+  let totalFiles = 0;
+  for (const group2 of groups) {
+    const fileCount = group2.files.length;
+    totalFiles += fileCount;
+    console.log();
+    console.log(
+      chalk13.bold(`${group2.icon} ${group2.name}`) + chalk13.dim(` (${formatCount(fileCount, "file")})`)
+    );
+    group2.files.forEach((file, index) => {
+      const isLast = index === group2.files.length - 1;
+      const prefix = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+      const name = file.source.split("/").pop() || file.source;
+      const arrow = chalk13.dim(" \u2192 ");
+      const dest = chalk13.dim(file.source);
+      console.log(chalk13.dim(prefix) + chalk13.cyan(name) + arrow + dest);
+    });
+  }
+  console.log();
+  prompts.outro(`Total: ${formatCount(totalFiles, "tracked item")}`);
+};
+var printPathsOnly = (groups) => {
+  for (const group2 of groups) {
+    for (const file of group2.files) {
+      console.log(file.source);
+    }
+  }
+};
+var printJson = (groups) => {
+  const output = groups.reduce(
+    (acc, group2) => {
+      acc[group2.name] = group2.files.map((f) => ({
+        source: f.source,
+        destination: f.destination
+      }));
+      return acc;
+    },
+    {}
+  );
+  console.log(JSON.stringify(output, null, 2));
+};
+var runList = async (options) => {
+  const tuckDir = getTuckDir();
+  try {
+    await loadManifest(tuckDir);
+  } catch {
+    throw new NotInitializedError();
+  }
+  let groups = await groupByCategory(tuckDir);
+  if (options.category) {
+    groups = groups.filter((g) => g.name === options.category);
+    if (groups.length === 0) {
+      logger.warning(`No files found in category: ${options.category}`);
+      return;
+    }
+  }
+  if (options.json) {
+    printJson(groups);
+  } else if (options.paths) {
+    printPathsOnly(groups);
+  } else {
+    printList(groups);
+  }
+};
+var listCommand = new Command9("list").description("List all tracked files").option("-c, --category <name>", "Filter by category").option("--paths", "Show only paths").option("--json", "Output as JSON").action(async (options) => {
+  await runList(options);
+});
+
+// src/commands/diff.ts
+import { Command as Command10 } from "commander";
+import chalk14 from "chalk";
+import { join as join9 } from "path";
+import { readFile as readFile4 } from "fs/promises";
+var getFileDiff = async (tuckDir, source) => {
+  const tracked = await getTrackedFileBySource(tuckDir, source);
+  if (!tracked) {
+    throw new FileNotFoundError(`Not tracked: ${source}`);
+  }
+  const systemPath = expandPath(source);
+  const repoPath = join9(tuckDir, tracked.file.destination);
+  const diff = {
+    source,
+    destination: tracked.file.destination,
+    hasChanges: false
+  };
+  if (!await pathExists(systemPath)) {
+    diff.hasChanges = true;
+    if (await pathExists(repoPath)) {
+      diff.repoContent = await readFile4(repoPath, "utf-8");
+    }
+    return diff;
+  }
+  if (!await pathExists(repoPath)) {
+    diff.hasChanges = true;
+    diff.systemContent = await readFile4(systemPath, "utf-8");
+    return diff;
+  }
+  const systemChecksum = await getFileChecksum(systemPath);
+  const repoChecksum = await getFileChecksum(repoPath);
+  if (systemChecksum !== repoChecksum) {
+    diff.hasChanges = true;
+    diff.systemContent = await readFile4(systemPath, "utf-8");
+    diff.repoContent = await readFile4(repoPath, "utf-8");
+  }
+  return diff;
+};
+var formatUnifiedDiff = (source, systemContent, repoContent) => {
+  const lines = [];
+  lines.push(chalk14.bold(`--- a/${source} (system)`));
+  lines.push(chalk14.bold(`+++ b/${source} (repository)`));
+  if (!systemContent && repoContent) {
+    lines.push(chalk14.red("File missing on system"));
+    lines.push(chalk14.dim("Repository content:"));
+    repoContent.split("\n").forEach((line) => {
+      lines.push(chalk14.green(`+ ${line}`));
+    });
+  } else if (systemContent && !repoContent) {
+    lines.push(chalk14.yellow("File not yet synced to repository"));
+    lines.push(chalk14.dim("System content:"));
+    systemContent.split("\n").forEach((line) => {
+      lines.push(chalk14.red(`- ${line}`));
+    });
+  } else if (systemContent && repoContent) {
+    const systemLines = systemContent.split("\n");
+    const repoLines = repoContent.split("\n");
+    const maxLines = Math.max(systemLines.length, repoLines.length);
+    let inDiff = false;
+    let diffStart = 0;
+    for (let i = 0; i < maxLines; i++) {
+      const sysLine = systemLines[i];
+      const repoLine = repoLines[i];
+      if (sysLine !== repoLine) {
+        if (!inDiff) {
+          inDiff = true;
+          diffStart = i;
+          lines.push(chalk14.cyan(`@@ -${i + 1} +${i + 1} @@`));
+        }
+        if (sysLine !== void 0) {
+          lines.push(chalk14.red(`- ${sysLine}`));
+        }
+        if (repoLine !== void 0) {
+          lines.push(chalk14.green(`+ ${repoLine}`));
+        }
+      } else if (inDiff) {
+        lines.push(chalk14.dim(`  ${sysLine || ""}`));
+        if (i - diffStart > 3) {
+          inDiff = false;
+        }
+      }
+    }
+  }
+  return lines.join("\n");
+};
+var runDiff = async (paths, options) => {
+  const tuckDir = getTuckDir();
+  try {
+    await loadManifest(tuckDir);
+  } catch {
+    throw new NotInitializedError();
+  }
+  if (options.staged) {
+    const diff = await getDiff(tuckDir, { staged: true, stat: options.stat });
+    if (diff) {
+      console.log(diff);
+    } else {
+      logger.info("No staged changes");
+    }
+    return;
+  }
+  if (paths.length === 0) {
+    const allFiles = await getAllTrackedFiles(tuckDir);
+    const changedFiles = [];
+    for (const [, file] of Object.entries(allFiles)) {
+      const diff = await getFileDiff(tuckDir, file.source);
+      if (diff.hasChanges) {
+        changedFiles.push(diff);
+      }
+    }
+    if (changedFiles.length === 0) {
+      logger.success("No differences found");
+      return;
+    }
+    if (options.stat) {
+      prompts.intro("tuck diff");
+      console.log();
+      console.log(chalk14.bold(`${changedFiles.length} file${changedFiles.length > 1 ? "s" : ""} changed:`));
+      console.log();
+      for (const diff of changedFiles) {
+        console.log(chalk14.yellow(`  ~ ${diff.source}`));
+      }
+      console.log();
+      return;
+    }
+    for (const diff of changedFiles) {
+      console.log();
+      console.log(formatUnifiedDiff(diff.source, diff.systemContent, diff.repoContent));
+      console.log();
+    }
+    return;
+  }
+  for (const path of paths) {
+    const expandedPath = expandPath(path);
+    const collapsedPath = collapsePath(expandedPath);
+    const diff = await getFileDiff(tuckDir, collapsedPath);
+    if (!diff.hasChanges) {
+      logger.info(`No changes: ${path}`);
+      continue;
+    }
+    if (options.stat) {
+      console.log(chalk14.yellow(`~ ${path}`));
+    } else {
+      console.log(formatUnifiedDiff(path, diff.systemContent, diff.repoContent));
+      console.log();
+    }
+  }
+};
+var diffCommand = new Command10("diff").description("Show differences between system and repository").argument("[paths...]", "Specific files to diff").option("--staged", "Show staged git changes").option("--stat", "Show diffstat only").action(async (paths, options) => {
+  await runDiff(paths, options);
+});
+
+// src/commands/config.ts
+import { Command as Command11 } from "commander";
+import chalk15 from "chalk";
+import { spawn } from "child_process";
+var printConfig = (config) => {
+  console.log(JSON.stringify(config, null, 2));
+};
+var getNestedValue = (obj, path) => {
+  const keys = path.split(".");
+  let current = obj;
+  for (const key of keys) {
+    if (current === null || current === void 0) {
+      return void 0;
+    }
+    if (typeof current !== "object") {
+      return void 0;
+    }
+    current = current[key];
+  }
+  return current;
+};
+var setNestedValue = (obj, path, value) => {
+  const keys = path.split(".");
+  let current = obj;
+  for (let i = 0; i < keys.length - 1; i++) {
+    const key = keys[i];
+    if (!(key in current) || typeof current[key] !== "object") {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+  current[keys[keys.length - 1]] = value;
+};
+var parseValue = (value) => {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+};
+var runConfigGet = async (key) => {
+  const tuckDir = getTuckDir();
+  const config = await loadConfig(tuckDir);
+  const value = getNestedValue(config, key);
+  if (value === void 0) {
+    logger.error(`Key not found: ${key}`);
+    return;
+  }
+  if (typeof value === "object") {
+    console.log(JSON.stringify(value, null, 2));
+  } else {
+    console.log(value);
+  }
+};
+var runConfigSet = async (key, value) => {
+  const tuckDir = getTuckDir();
+  const config = await loadConfig(tuckDir);
+  const parsedValue = parseValue(value);
+  const configObj = config;
+  setNestedValue(configObj, key, parsedValue);
+  await saveConfig(config, tuckDir);
+  logger.success(`Set ${key} = ${JSON.stringify(parsedValue)}`);
+};
+var runConfigList = async () => {
+  const tuckDir = getTuckDir();
+  const config = await loadConfig(tuckDir);
+  prompts.intro("tuck config");
+  console.log();
+  console.log(chalk15.dim("Configuration file:"), collapsePath(getConfigPath(tuckDir)));
+  console.log();
+  printConfig(config);
+};
+var runConfigEdit = async () => {
+  const tuckDir = getTuckDir();
+  const configPath = getConfigPath(tuckDir);
+  const editor = process.env.EDITOR || process.env.VISUAL || "vim";
+  logger.info(`Opening ${collapsePath(configPath)} in ${editor}...`);
+  return new Promise((resolve2, reject) => {
+    const child = spawn(editor, [configPath], {
+      stdio: "inherit"
+    });
+    child.on("exit", (code) => {
+      if (code === 0) {
+        logger.success("Configuration updated");
+        resolve2();
+      } else {
+        reject(new ConfigError(`Editor exited with code ${code}`));
+      }
+    });
+    child.on("error", (err) => {
+      reject(new ConfigError(`Failed to open editor: ${err.message}`));
+    });
+  });
+};
+var runConfigReset = async () => {
+  const tuckDir = getTuckDir();
+  const confirm2 = await prompts.confirm("Reset configuration to defaults? This cannot be undone.", false);
+  if (!confirm2) {
+    prompts.cancel("Operation cancelled");
+    return;
+  }
+  await resetConfig(tuckDir);
+  logger.success("Configuration reset to defaults");
+};
+var configCommand = new Command11("config").description("Manage tuck configuration").addCommand(
+  new Command11("get").description("Get a config value").argument("<key>", 'Config key (e.g., "repository.autoCommit")').action(async (key) => {
+    const tuckDir = getTuckDir();
+    try {
+      await loadManifest(tuckDir);
+    } catch {
+      throw new NotInitializedError();
+    }
+    await runConfigGet(key);
+  })
+).addCommand(
+  new Command11("set").description("Set a config value").argument("<key>", "Config key").argument("<value>", "Value to set (JSON or string)").action(async (key, value) => {
+    const tuckDir = getTuckDir();
+    try {
+      await loadManifest(tuckDir);
+    } catch {
+      throw new NotInitializedError();
+    }
+    await runConfigSet(key, value);
+  })
+).addCommand(
+  new Command11("list").description("List all config").action(async () => {
+    const tuckDir = getTuckDir();
+    try {
+      await loadManifest(tuckDir);
+    } catch {
+      throw new NotInitializedError();
+    }
+    await runConfigList();
+  })
+).addCommand(
+  new Command11("edit").description("Open config in editor").action(async () => {
+    const tuckDir = getTuckDir();
+    try {
+      await loadManifest(tuckDir);
+    } catch {
+      throw new NotInitializedError();
+    }
+    await runConfigEdit();
+  })
+).addCommand(
+  new Command11("reset").description("Reset to defaults").action(async () => {
+    const tuckDir = getTuckDir();
+    try {
+      await loadManifest(tuckDir);
+    } catch {
+      throw new NotInitializedError();
+    }
+    await runConfigReset();
+  })
+);
+
+// src/index.ts
+var program = new Command12();
+program.name("tuck").description(DESCRIPTION).version(VERSION, "-v, --version", "Display version number").configureOutput({
+  outputError: (str, write) => write(chalk16.red(str))
+});
+program.addCommand(initCommand);
+program.addCommand(addCommand);
+program.addCommand(removeCommand);
+program.addCommand(syncCommand);
+program.addCommand(pushCommand);
+program.addCommand(pullCommand);
+program.addCommand(restoreCommand);
+program.addCommand(statusCommand);
+program.addCommand(listCommand);
+program.addCommand(diffCommand);
+program.addCommand(configCommand);
+process.on("uncaughtException", handleError);
+process.on("unhandledRejection", (reason) => {
+  handleError(reason instanceof Error ? reason : new Error(String(reason)));
+});
+program.parseAsync(process.argv).catch(handleError);
+//# sourceMappingURL=index.js.map