@pm-2001/shellup 0.1.0

package/dist/cli.js

@@ -0,0 +1,883 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import pc8 from "picocolors";
+
+// src/commands/init.ts
+import * as p from "@clack/prompts";
+import pc3 from "picocolors";
+
+// src/core/detect.ts
+import { execFileSync } from "child_process";
+import { existsSync, readdirSync } from "fs";
+import { homedir, platform } from "os";
+import { join, basename } from "path";
+function has(bin) {
+  try {
+    execFileSync("command", ["-v", bin], { stdio: "ignore", shell: "/bin/sh" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function detectPackageManager() {
+  for (const pm of ["brew", "apt", "dnf", "pacman"]) if (has(pm)) return pm;
+  return "none";
+}
+function detectNerdFont() {
+  const os = platform();
+  if (os === "darwin") {
+    const dirs = [join(homedir(), "Library", "Fonts"), "/Library/Fonts"];
+    for (const dir of dirs) {
+      if (!existsSync(dir)) continue;
+      try {
+        if (readdirSync(dir).some((f) => /nerd|nf-|powerline/i.test(basename(f)))) return true;
+      } catch {
+      }
+    }
+    return false;
+  }
+  try {
+    const out = execFileSync("fc-list", [], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+    return /nerd font|powerline/i.test(out);
+  } catch {
+    return false;
+  }
+}
+function detect() {
+  const os = platform();
+  const shell = process.env.SHELL ?? "";
+  const colorterm = process.env.COLORTERM ?? "";
+  return {
+    os: os === "darwin" ? "macos" : os === "linux" ? "linux" : "other",
+    shell,
+    isZsh: shell.includes("zsh"),
+    rcFile: join(homedir(), ".zshrc"),
+    packageManager: detectPackageManager(),
+    nerdFont: detectNerdFont(),
+    terminal: process.env.TERM_PROGRAM ?? process.env.TERM ?? "unknown",
+    trueColor: colorterm === "truecolor" || colorterm === "24bit"
+  };
+}
+
+// src/core/config.ts
+import { readFileSync, writeFileSync, existsSync as existsSync2, mkdirSync } from "fs";
+
+// src/core/paths.ts
+import { homedir as homedir2 } from "os";
+import { join as join2, dirname } from "path";
+import { fileURLToPath } from "url";
+var HOME = homedir2();
+var PKG_ROOT = join2(dirname(fileURLToPath(import.meta.url)), "..");
+var CONFIG_DIR = process.env.SHELLUP_HOME ?? join2(HOME, ".config", "shellup");
+var CONFIG_FILE = join2(CONFIG_DIR, "config.json");
+var INIT_FILE = join2(CONFIG_DIR, "init.zsh");
+var GENERATED_DIR = join2(CONFIG_DIR, "generated");
+var RUNTIME_DIR = join2(CONFIG_DIR, "runtime");
+var BACKUP_DIR = join2(CONFIG_DIR, "backups");
+function tilde(p4) {
+  return p4.startsWith(HOME) ? "~" + p4.slice(HOME.length) : p4;
+}
+
+// src/core/config.ts
+var DEFAULT_CONFIG = {
+  version: 1,
+  theme: "minimal",
+  tools: [],
+  aliases: true,
+  keybindings: true,
+  functions: true,
+  nerdFont: false,
+  shell: "zsh",
+  installedAt: (/* @__PURE__ */ new Date()).toISOString()
+};
+function configExists() {
+  return existsSync2(CONFIG_FILE);
+}
+function loadConfig() {
+  if (!configExists()) return null;
+  try {
+    return { ...DEFAULT_CONFIG, ...JSON.parse(readFileSync(CONFIG_FILE, "utf8")) };
+  } catch {
+    return null;
+  }
+}
+function saveConfig(config) {
+  mkdirSync(CONFIG_DIR, { recursive: true });
+  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n", "utf8");
+}
+
+// src/core/tools.ts
+var TOOLS = [
+  {
+    id: "eza",
+    bin: "eza",
+    label: "eza",
+    hint: "ls with colors, icons and git status",
+    brew: "eza",
+    apt: "eza",
+    dnf: "eza",
+    pacman: "eza",
+    recommended: true,
+    snippet: [
+      `alias ls='eza --group-directories-first'`,
+      `alias ll='eza -l --group-directories-first --git --time-style=long-iso'`,
+      `alias la='eza -la --group-directories-first --git --time-style=long-iso'`,
+      `alias lt='eza --tree --level=2 --group-directories-first'`
+    ].join("\n")
+  },
+  {
+    id: "bat",
+    bin: "bat",
+    label: "bat",
+    hint: "cat with syntax highlighting",
+    brew: "bat",
+    apt: "bat",
+    dnf: "bat",
+    pacman: "bat",
+    recommended: true,
+    // bat detects a non-tty stdout and behaves like plain cat, so aliasing is pipe-safe.
+    snippet: [
+      `export BAT_THEME="\${BAT_THEME:-ansi}"`,
+      `alias cat='bat --style=plain --paging=never'`,
+      `export MANPAGER="sh -c 'col -bx | bat -l man -p'"`
+    ].join("\n")
+  },
+  {
+    id: "fzf",
+    bin: "fzf",
+    label: "fzf",
+    hint: "fuzzy finder \u2014 powers Ctrl-R history search",
+    brew: "fzf",
+    apt: "fzf",
+    dnf: "fzf",
+    pacman: "fzf",
+    recommended: true,
+    snippet: [
+      `# fzf >=0.48 ships its own shell integration; older builds keep it in the prefix.`,
+      `if fzf --zsh >/dev/null 2>&1; then`,
+      `  source <(fzf --zsh)`,
+      `elif [[ -d "\${HOMEBREW_PREFIX:-/opt/homebrew}/opt/fzf/shell" ]]; then`,
+      `  source "\${HOMEBREW_PREFIX:-/opt/homebrew}/opt/fzf/shell/key-bindings.zsh"`,
+      `  source "\${HOMEBREW_PREFIX:-/opt/homebrew}/opt/fzf/shell/completion.zsh" 2>/dev/null`,
+      `fi`,
+      `export FZF_DEFAULT_OPTS="--height 40% --layout=reverse --border=rounded --info=inline"`,
+      `command -v fd >/dev/null 2>&1 && export FZF_DEFAULT_COMMAND='fd --type f --hidden --follow --exclude .git'`
+    ].join("\n")
+  },
+  {
+    id: "zoxide",
+    bin: "zoxide",
+    label: "zoxide",
+    hint: "cd that learns \u2014 jump with `z name`",
+    brew: "zoxide",
+    apt: "zoxide",
+    dnf: "zoxide",
+    pacman: "zoxide",
+    recommended: true,
+    snippet: `eval "$(zoxide init zsh)"`
+  },
+  {
+    id: "fd",
+    bin: "fd",
+    label: "fd",
+    hint: "find, but fast and sane",
+    brew: "fd",
+    apt: "fd-find",
+    dnf: "fd-find",
+    pacman: "fd",
+    recommended: true
+  },
+  {
+    id: "ripgrep",
+    bin: "rg",
+    label: "ripgrep",
+    hint: "grep, but fast (rg)",
+    brew: "ripgrep",
+    apt: "ripgrep",
+    dnf: "ripgrep",
+    pacman: "ripgrep",
+    recommended: true
+  },
+  {
+    id: "delta",
+    bin: "delta",
+    label: "git-delta",
+    hint: "side-by-side syntax-highlighted git diffs",
+    brew: "git-delta",
+    apt: "git-delta",
+    dnf: "git-delta",
+    pacman: "git-delta",
+    recommended: true,
+    gitConfig: [
+      ["core.pager", "delta"],
+      ["interactive.diffFilter", "delta --color-only"],
+      ["delta.navigate", "true"],
+      ["delta.line-numbers", "true"],
+      ["merge.conflictstyle", "zdiff3"]
+    ]
+  },
+  {
+    id: "lazygit",
+    bin: "lazygit",
+    label: "lazygit",
+    hint: "full git UI in the terminal (lg)",
+    brew: "lazygit",
+    apt: "lazygit",
+    dnf: "lazygit",
+    pacman: "lazygit",
+    recommended: false,
+    snippet: `alias lg='lazygit'`
+  },
+  {
+    id: "btop",
+    bin: "btop",
+    label: "btop",
+    hint: "the good-looking top",
+    brew: "btop",
+    apt: "btop",
+    dnf: "btop",
+    pacman: "btop",
+    recommended: false
+  },
+  {
+    id: "jq",
+    bin: "jq",
+    label: "jq",
+    hint: "slice and query JSON",
+    brew: "jq",
+    apt: "jq",
+    dnf: "jq",
+    pacman: "jq",
+    recommended: false
+  },
+  {
+    id: "tldr",
+    bin: "tldr",
+    label: "tldr",
+    hint: "man pages with actual examples",
+    brew: "tealdeer",
+    apt: "tealdeer",
+    dnf: "tealdeer",
+    pacman: "tealdeer",
+    recommended: false
+  }
+];
+var toolById = (id) => TOOLS.find((t) => t.id === id);
+function packageFor(tool, pm) {
+  return pm === "brew" ? tool.brew : pm === "apt" ? tool.apt : pm === "dnf" ? tool.dnf : pm === "pacman" ? tool.pacman : void 0;
+}
+
+// src/core/install.ts
+import { execFileSync as execFileSync2 } from "child_process";
+function installCommand(pm, pkgs) {
+  switch (pm) {
+    case "brew":
+      return ["brew", ["install", ...pkgs]];
+    case "apt":
+      return ["sudo", ["apt-get", "install", "-y", ...pkgs]];
+    case "dnf":
+      return ["sudo", ["dnf", "install", "-y", ...pkgs]];
+    case "pacman":
+      return ["sudo", ["pacman", "-S", "--noconfirm", ...pkgs]];
+    default:
+      return null;
+  }
+}
+function installTools(tools, pm) {
+  const result = { installed: [], alreadyPresent: [], failed: [], unsupported: [], command: null };
+  const wanted = [];
+  for (const tool of tools) {
+    if (has(tool.bin)) {
+      result.alreadyPresent.push(tool.id);
+      continue;
+    }
+    if (!packageFor(tool, pm)) {
+      result.unsupported.push(tool.id);
+      continue;
+    }
+    wanted.push(tool);
+  }
+  if (wanted.length === 0) return result;
+  const pkgs = wanted.map((t) => packageFor(t, pm));
+  const cmd = installCommand(pm, pkgs);
+  if (!cmd) {
+    result.unsupported.push(...wanted.map((t) => t.id));
+    return result;
+  }
+  result.command = [cmd[0], ...cmd[1]].join(" ");
+  try {
+    execFileSync2(cmd[0], cmd[1], { stdio: ["ignore", "pipe", "pipe"], timeout: 15 * 60 * 1e3 });
+  } catch {
+  }
+  for (const tool of wanted) (has(tool.bin) ? result.installed : result.failed).push(tool.id);
+  return result;
+}
+function applyGitConfig(entries) {
+  try {
+    for (const [key, value] of entries) {
+      execFileSync2("git", ["config", "--global", key, value], { stdio: "ignore" });
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/core/render.ts
+import { writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, cpSync, existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
+import { join as join3 } from "path";
+function version() {
+  try {
+    return JSON.parse(readFileSync2(join3(PKG_ROOT, "package.json"), "utf8")).version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+var HEADER = (v) => `# Generated by shellup v${v} on ${(/* @__PURE__ */ new Date()).toISOString()}
+# Do not edit \u2014 regenerated by \`shellup apply\`.
+# Put your own overrides in ~/.config/shellup/custom.zsh, which is never touched.
+`;
+function renderTools(config) {
+  const parts = [HEADER(version())];
+  for (const id of config.tools) {
+    const tool = toolById(id);
+    if (!tool?.snippet) continue;
+    parts.push(
+      `
+# \u2500\u2500 ${tool.label} ${"\u2500".repeat(Math.max(0, 68 - tool.label.length))}
+if command -v ${tool.bin} >/dev/null 2>&1; then
+` + tool.snippet.split("\n").map((l) => l.trim() ? `  ${l}` : l).join("\n") + `
+fi
+`
+    );
+  }
+  return parts.join("");
+}
+function renderInit(config) {
+  const lines = [
+    HEADER(version()),
+    "",
+    `export SHELLUP_DIR="\${SHELLUP_DIR:-${CONFIG_DIR.replace(process.env.HOME ?? "", "$HOME")}}"`,
+    `export SHELLUP_VERSION="${version()}"`,
+    "",
+    "# Non-interactive shells (scripts, scp, rsync) get nothing: sourcing a prompt",
+    "# engine there is wasted work and can break protocols that expect clean stdout.",
+    "[[ -o interactive ]] || return 0",
+    "",
+    'shellup_source() { [ -r "$1" ] && source "$1"; }',
+    ""
+  ];
+  if (config.functions || config.aliases || config.keybindings) lines.push("# \u2500\u2500 defaults");
+  lines.push(`shellup_source "$SHELLUP_DIR/runtime/options.zsh"`);
+  lines.push("");
+  lines.push("# \u2500\u2500 prompt (engine first, then the theme that renders its variables)");
+  lines.push(`shellup_source "$SHELLUP_DIR/runtime/prompt.zsh"`);
+  lines.push(`shellup_source "$SHELLUP_DIR/runtime/themes/${config.theme}.zsh"`);
+  lines.push("");
+  if (config.aliases) lines.push(`shellup_source "$SHELLUP_DIR/runtime/aliases.zsh"`);
+  if (config.functions) lines.push(`shellup_source "$SHELLUP_DIR/runtime/functions.zsh"`);
+  if (config.keybindings) lines.push(`shellup_source "$SHELLUP_DIR/runtime/keybindings.zsh"`);
+  lines.push("");
+  lines.push("# \u2500\u2500 tool integrations (last, so tools like fzf bind their own keys over ours)");
+  lines.push(`shellup_source "$SHELLUP_DIR/generated/tools.zsh"`);
+  lines.push("");
+  lines.push("# \u2500\u2500 yours, always last and never regenerated");
+  lines.push(`shellup_source "$SHELLUP_DIR/custom.zsh"`);
+  lines.push("");
+  return lines.join("\n");
+}
+function apply(config) {
+  mkdirSync2(CONFIG_DIR, { recursive: true });
+  mkdirSync2(GENERATED_DIR, { recursive: true });
+  cpSync(join3(PKG_ROOT, "runtime"), RUNTIME_DIR, { recursive: true });
+  writeFileSync2(join3(GENERATED_DIR, "tools.zsh"), renderTools(config), "utf8");
+  writeFileSync2(INIT_FILE, renderInit(config), "utf8");
+  const custom = join3(CONFIG_DIR, "custom.zsh");
+  if (!existsSync3(custom)) {
+    writeFileSync2(
+      custom,
+      "# Your own shell config. shellup never overwrites this file.\n# It is sourced last, so anything here wins over shellup's defaults.\n\n",
+      "utf8"
+    );
+  }
+}
+
+// src/core/shellrc.ts
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, existsSync as existsSync4, mkdirSync as mkdirSync3, copyFileSync } from "fs";
+import { join as join4 } from "path";
+var START = "# >>> shellup >>>";
+var END = "# <<< shellup <<<";
+function block() {
+  return [
+    START,
+    "# Managed by shellup \u2014 edit ~/.config/shellup/config.json, then run `shellup apply`.",
+    `[ -f "${INIT_FILE.replace(process.env.HOME ?? "", "$HOME")}" ] && source "${INIT_FILE.replace(process.env.HOME ?? "", "$HOME")}"`,
+    END
+  ].join("\n");
+}
+function hasBlock(rcFile) {
+  return existsSync4(rcFile) && readFileSync3(rcFile, "utf8").includes(START);
+}
+function backupRc(rcFile) {
+  if (!existsSync4(rcFile)) return null;
+  mkdirSync3(BACKUP_DIR, { recursive: true });
+  const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const dest = join4(BACKUP_DIR, `zshrc.${stamp}.bak`);
+  copyFileSync(rcFile, dest);
+  return dest;
+}
+function stripBlock(content) {
+  const lines = content.split("\n");
+  const out = [];
+  let inside = false;
+  for (const line2 of lines) {
+    if (line2.trim() === START) {
+      inside = true;
+      if (out.length && out[out.length - 1].trim() === "") out.pop();
+      continue;
+    }
+    if (line2.trim() === END) {
+      inside = false;
+      continue;
+    }
+    if (!inside) out.push(line2);
+  }
+  return out.join("\n");
+}
+function installBlock(rcFile) {
+  const existed = existsSync4(rcFile);
+  const original = existed ? readFileSync3(rcFile, "utf8") : "";
+  const replaced = original.includes(START);
+  const backup = backupRc(rcFile);
+  let next = replaced ? stripBlock(original) : original;
+  if (next.length && !next.endsWith("\n")) next += "\n";
+  next += (next.trim() ? "\n" : "") + block() + "\n";
+  writeFileSync3(rcFile, next, "utf8");
+  return { backup, replaced };
+}
+function removeBlock(rcFile) {
+  if (!hasBlock(rcFile)) return { backup: null, removed: false };
+  const backup = backupRc(rcFile);
+  writeFileSync3(rcFile, stripBlock(readFileSync3(rcFile, "utf8")), "utf8");
+  return { backup, removed: true };
+}
+
+// src/themes/index.ts
+import pc from "picocolors";
+var THEMES = [
+  {
+    name: "minimal",
+    label: "minimal",
+    hint: "clean two-line prompt, no special font needed",
+    requiresNerdFont: false,
+    preview: [
+      `${pc.blue("~/dev/shellup")} ${pc.dim("on")} ${pc.magenta("main")} ${pc.green("+2")} ${pc.yellow("!1")}`,
+      `${pc.green(">")} npm test${" ".repeat(18)}${pc.dim("4s")}`
+    ]
+  },
+  {
+    name: "neon",
+    label: "neon",
+    hint: "bright boxed prompt, still font-safe",
+    requiresNerdFont: false,
+    preview: [
+      `${pc.dim("\u256D\u2500")} ${pc.cyan("~/dev/shellup")} ${pc.dim("\xB7")} ${pc.magenta("\u2325 main")} ${pc.yellow("\u271A1")} ${pc.cyan("\u21E12")}`,
+      `${pc.dim("\u2570\u2500")}${pc.magenta("\u276F")} npm test${" ".repeat(15)}${pc.dim("4s")}`
+    ]
+  },
+  {
+    name: "powerline",
+    label: "powerline",
+    hint: "segmented arrows and icons \u2014 requires a Nerd Font",
+    requiresNerdFont: true,
+    preview: [
+      `${pc.bgBlue(pc.black(" ~/dev/shellup "))}${pc.bgGreen(pc.black("   main +2 "))}`,
+      `${pc.green("\u276F")} npm test${" ".repeat(18)}${pc.dim("4s")}`
+    ]
+  }
+];
+var themeByName = (name) => THEMES.find((t) => t.name === name);
+
+// src/core/ui.ts
+import pc2 from "picocolors";
+var dim = pc2.dim;
+var bold = pc2.bold;
+var SYM = { ok: "\u2714", warn: "!", bad: "\u2716", info: "\xB7" };
+function banner(version2) {
+  return `${pc2.bgCyan(pc2.black(" shellup "))} ${dim("v" + version2)}`;
+}
+
+// src/commands/init.ts
+function bail(value) {
+  if (p.isCancel(value)) {
+    p.cancel("Nothing was changed.");
+    process.exit(0);
+  }
+}
+async function init(opts = {}) {
+  console.log();
+  p.intro(banner(version()));
+  const env = detect();
+  const existing = loadConfig();
+  p.note(
+    [
+      `${pc3.dim("os".padEnd(10))} ${env.os}`,
+      `${pc3.dim("shell".padEnd(10))} ${env.shell || "unknown"}${env.isZsh ? "" : pc3.yellow("  (not zsh)")}`,
+      `${pc3.dim("packages".padEnd(10))} ${env.packageManager === "none" ? pc3.yellow("none found") : env.packageManager}`,
+      `${pc3.dim("font".padEnd(10))} ${env.nerdFont ? pc3.green("Nerd Font found") : pc3.yellow("no Nerd Font")}`,
+      `${pc3.dim("terminal".padEnd(10))} ${env.terminal}`
+    ].join("\n"),
+    "Detected"
+  );
+  if (!env.isZsh) {
+    const go = await p.confirm({
+      message: `Your login shell isn't zsh. shellup only configures zsh \u2014 install anyway?`,
+      initialValue: false
+    });
+    bail(go);
+    if (!go) {
+      p.outro("Run `chsh -s $(which zsh)` first, then try again.");
+      return;
+    }
+  }
+  if (existing) {
+    p.log.info(`Existing setup found (theme ${pc3.cyan(existing.theme)}). This will reconfigure it.`);
+  }
+  const theme2 = await p.select({
+    message: "Pick a prompt theme",
+    initialValue: existing?.theme ?? (env.nerdFont ? "powerline" : "minimal"),
+    options: THEMES.map((t) => ({
+      value: t.name,
+      label: t.label + (t.requiresNerdFont && !env.nerdFont ? pc3.yellow("  \u2014 needs a Nerd Font") : ""),
+      hint: t.hint
+    }))
+  });
+  bail(theme2);
+  const chosen = THEMES.find((t) => t.name === theme2);
+  p.note(chosen.preview.join("\n"), `Preview \u2014 ${chosen.label}`);
+  if (chosen.requiresNerdFont && !env.nerdFont) {
+    p.log.warn(
+      `${chosen.label} draws with Nerd Font glyphs. Without one you'll see boxes.
+` + (env.packageManager === "brew" ? `  Install one:  ${pc3.cyan("brew install --cask font-jetbrains-mono-nerd-font")}` : `  Get one at:   ${pc3.cyan("https://nerdfonts.com")}`) + `
+  Then set it as your terminal font.`
+    );
+  }
+  const selectedTools = await p.multiselect({
+    message: "Which tools should shellup set up?",
+    required: false,
+    initialValues: existing?.tools ?? TOOLS.filter((t) => t.recommended).map((t) => t.id),
+    options: TOOLS.map((t) => ({
+      value: t.id,
+      label: t.label + (has(t.bin) ? pc3.green("  (installed)") : ""),
+      hint: t.hint
+    }))
+  });
+  bail(selectedTools);
+  const extras = await p.multiselect({
+    message: "Shell defaults to enable",
+    required: false,
+    initialValues: [
+      ...existing?.aliases ?? true ? ["aliases"] : [],
+      ...existing?.functions ?? true ? ["functions"] : [],
+      ...existing?.keybindings ?? true ? ["keybindings"] : []
+    ],
+    options: [
+      { value: "aliases", label: "Aliases", hint: "git shortcuts, ..  ...  , safety rails on cp/mv" },
+      { value: "functions", label: "Functions", hint: "mkcd, extract, serve, onport, bak, cdr" },
+      { value: "keybindings", label: "Keybindings", hint: "prefix history search on \u2191, word jumps, Ctrl-Z toggle" }
+    ]
+  });
+  bail(extras);
+  const config = {
+    ...DEFAULT_CONFIG,
+    ...existing ?? {},
+    theme: theme2,
+    tools: selectedTools,
+    aliases: extras.includes("aliases"),
+    functions: extras.includes("functions"),
+    keybindings: extras.includes("keybindings"),
+    nerdFont: env.nerdFont,
+    installedAt: existing?.installedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const missing = selectedTools.map((id) => toolById(id)).filter((t) => t && !has(t.bin));
+  if (missing.length && env.packageManager !== "none") {
+    const doInstall = opts.yes || await p.confirm({
+      message: `Install ${missing.length} missing tool${missing.length > 1 ? "s" : ""} with ${env.packageManager}? (${missing.map((t) => t.label).join(", ")})`,
+      initialValue: true
+    });
+    bail(doInstall);
+    if (doInstall) {
+      const s2 = p.spinner();
+      s2.start(`Installing with ${env.packageManager}\u2026`);
+      const res = installTools(missing, env.packageManager);
+      s2.stop(
+        res.installed.length ? `Installed ${res.installed.join(", ")}` : "Nothing new installed"
+      );
+      if (res.failed.length) {
+        p.log.warn(`Could not install: ${res.failed.join(", ")}
+  Try manually: ${pc3.dim(res.command ?? "")}`);
+      }
+    }
+  } else if (missing.length) {
+    p.log.warn(
+      `No supported package manager found, so these stay uninstalled: ${missing.map((t) => t.label).join(", ")}
+  Their config is still written and activates automatically once they're on PATH.`
+    );
+  }
+  const delta = toolById("delta");
+  if (selectedTools.includes("delta") && has(delta.bin) && delta.gitConfig) {
+    const doGit = await p.confirm({
+      message: "Set git to use delta for diffs? (writes to your global ~/.gitconfig)",
+      initialValue: true
+    });
+    bail(doGit);
+    if (doGit) {
+      applyGitConfig(delta.gitConfig) ? p.log.success("git configured to use delta") : p.log.warn("Could not write git config \u2014 is git installed?");
+    }
+  }
+  const s = p.spinner();
+  s.start("Writing config");
+  apply(config);
+  saveConfig(config);
+  const { backup, replaced } = installBlock(env.rcFile);
+  s.stop("Config written");
+  p.note(
+    [
+      `${pc3.dim("config".padEnd(10))} ${tilde(CONFIG_DIR)}`,
+      `${pc3.dim("zshrc".padEnd(10))} ${replaced ? "managed block updated" : "3-line managed block added"}`,
+      backup ? `${pc3.dim("backup".padEnd(10))} ${tilde(backup)}` : `${pc3.dim("backup".padEnd(10))} ${pc3.dim("no existing .zshrc")}`,
+      `${pc3.dim("yours".padEnd(10))} ${tilde(CONFIG_DIR + "/custom.zsh")} ${pc3.dim("(never overwritten)")}`
+    ].join("\n"),
+    "Done"
+  );
+  p.outro(`Restart your shell to see it:  ${pc3.cyan("exec zsh")}`);
+}
+
+// src/commands/doctor.ts
+import pc4 from "picocolors";
+import { existsSync as existsSync5 } from "fs";
+var line = (state, label, detail) => {
+  const mark = state === "ok" ? pc4.green(SYM.ok) : state === "warn" ? pc4.yellow(SYM.warn) : pc4.red(SYM.bad);
+  return `  ${mark}  ${label.padEnd(22)} ${pc4.dim(detail)}`;
+};
+function doctor() {
+  const env = detect();
+  const config = loadConfig();
+  const problems = [];
+  console.log(`
+${banner(version())}
+`);
+  console.log(pc4.bold("  Environment"));
+  console.log(line(env.isZsh ? "ok" : "bad", "shell", env.shell || "unknown"));
+  if (!env.isZsh) problems.push("shellup configures zsh; switch with `chsh -s $(which zsh)`");
+  console.log(line("ok", "os", env.os));
+  console.log(line(env.packageManager === "none" ? "warn" : "ok", "package manager", env.packageManager));
+  console.log(line("ok", "terminal", env.terminal));
+  console.log(line(env.trueColor ? "ok" : "warn", "truecolor", env.trueColor ? "yes" : "not advertised (COLORTERM unset)"));
+  console.log(line(env.nerdFont ? "ok" : "warn", "nerd font", env.nerdFont ? "found" : "none found"));
+  console.log(`
+${pc4.bold("  Installation")}`);
+  console.log(line(config ? "ok" : "bad", "config", config ? tilde(CONFIG_DIR) : "not set up \u2014 run `shellup init`"));
+  if (!config) problems.push("run `shellup init` to set up");
+  console.log(line(existsSync5(INIT_FILE) ? "ok" : "bad", "init.zsh", existsSync5(INIT_FILE) ? tilde(INIT_FILE) : "missing \u2014 run `shellup apply`"));
+  console.log(line(hasBlock(env.rcFile) ? "ok" : "bad", "zshrc hook", hasBlock(env.rcFile) ? "managed block present" : "missing \u2014 run `shellup apply`"));
+  if (config) {
+    const theme2 = themeByName(config.theme);
+    const themeState = theme2?.requiresNerdFont && !env.nerdFont ? "warn" : "ok";
+    console.log(
+      line(themeState, "theme", config.theme + (themeState === "warn" ? " \u2014 needs a Nerd Font, glyphs will show as boxes" : ""))
+    );
+    if (themeState === "warn") problems.push("install a Nerd Font, or run `shellup theme minimal`");
+  }
+  console.log(`
+${pc4.bold("  Tools")}`);
+  const selected = new Set(config?.tools ?? []);
+  for (const tool of TOOLS) {
+    const present = has(tool.bin);
+    if (!selected.has(tool.id) && !present) continue;
+    const state = present ? "ok" : "warn";
+    const detail = present ? selected.has(tool.id) ? "installed, integration active" : "installed, not managed by shellup" : "selected but not installed \u2014 integration is dormant";
+    console.log(line(state, tool.label, detail));
+  }
+  const missing = [...selected].map((id) => toolById(id)).filter((t) => t && !has(t.bin));
+  if (missing.length) problems.push(`install missing tools: ${missing.map((t) => t.label).join(", ")}`);
+  console.log();
+  if (problems.length) {
+    console.log(pc4.bold(pc4.yellow("  To fix")));
+    for (const problem of problems) console.log(`  ${pc4.dim("\u2192")} ${problem}`);
+  } else {
+    console.log(`  ${pc4.green(SYM.ok)}  ${pc4.bold("Everything looks healthy.")}`);
+  }
+  console.log();
+}
+
+// src/commands/theme.ts
+import * as p2 from "@clack/prompts";
+import pc5 from "picocolors";
+async function theme(name) {
+  const config = loadConfig();
+  if (!config) {
+    console.error(pc5.red("shellup isn't set up yet. Run `shellup init` first."));
+    process.exitCode = 1;
+    return;
+  }
+  if (name) {
+    const meta2 = themeByName(name);
+    if (!meta2) {
+      console.error(
+        pc5.red(`Unknown theme "${name}".`) + ` Available: ${THEMES.map((t) => pc5.cyan(t.name)).join(", ")}`
+      );
+      process.exitCode = 1;
+      return;
+    }
+    apply({ ...config, theme: meta2.name });
+    saveConfig({ ...config, theme: meta2.name });
+    console.log(`
+  Theme set to ${pc5.cyan(meta2.name)}. Reload with ${pc5.cyan("exec zsh")}.
+`);
+    return;
+  }
+  console.log();
+  p2.intro(banner(version()));
+  const env = detect();
+  const picked = await p2.select({
+    message: "Pick a prompt theme",
+    initialValue: config.theme,
+    options: THEMES.map((t) => ({
+      value: t.name,
+      label: t.label + (t.requiresNerdFont && !env.nerdFont ? pc5.yellow("  \u2014 needs a Nerd Font") : ""),
+      hint: t.hint
+    }))
+  });
+  if (p2.isCancel(picked)) {
+    p2.cancel("Theme unchanged.");
+    return;
+  }
+  const meta = themeByName(picked);
+  p2.note(meta.preview.join("\n"), `Preview \u2014 ${meta.label}`);
+  apply({ ...config, theme: picked });
+  saveConfig({ ...config, theme: picked });
+  p2.outro(`Theme set to ${pc5.cyan(picked)}. Reload with ${pc5.cyan("exec zsh")}.`);
+}
+
+// src/commands/apply.ts
+import pc6 from "picocolors";
+function applyCommand() {
+  const config = loadConfig();
+  if (!config) {
+    console.error(pc6.red("Nothing to apply \u2014 run `shellup init` first."));
+    process.exitCode = 1;
+    return;
+  }
+  apply(config);
+  const { backup, replaced } = installBlock(detect().rcFile);
+  console.log(
+    `
+  ${pc6.green("\u2714")} Regenerated ${pc6.dim(tilde(CONFIG_DIR))}
+  ${pc6.green("\u2714")} ${replaced ? "Managed block refreshed" : "Managed block added"} in ${pc6.dim("~/.zshrc")}` + (backup ? `
+  ${pc6.dim("\xB7 backup: " + tilde(backup))}` : "") + `
+
+  Reload with ${pc6.cyan("exec zsh")}.
+`
+  );
+}
+
+// src/commands/uninstall.ts
+import * as p3 from "@clack/prompts";
+import pc7 from "picocolors";
+import { rmSync, existsSync as existsSync6 } from "fs";
+async function uninstall() {
+  console.log();
+  p3.intro(banner(version()));
+  const env = detect();
+  const go = await p3.confirm({
+    message: `Remove shellup's block from ~/.zshrc?`,
+    initialValue: true
+  });
+  if (p3.isCancel(go) || !go) {
+    p3.cancel("Nothing was changed.");
+    return;
+  }
+  const { backup, removed } = removeBlock(env.rcFile);
+  p3.log.success(removed ? "Removed the managed block from ~/.zshrc" : "No managed block found in ~/.zshrc");
+  if (backup) p3.log.info(`Your .zshrc as it was a moment ago: ${tilde(backup)}`);
+  const purge = await p3.confirm({
+    message: `Also delete ${tilde(CONFIG_DIR)}? (this includes your custom.zsh and rc backups)`,
+    initialValue: false
+  });
+  if (p3.isCancel(purge)) {
+    p3.outro("Left the config directory in place.");
+    return;
+  }
+  if (purge) {
+    if (existsSync6(CONFIG_DIR)) rmSync(CONFIG_DIR, { recursive: true, force: true });
+    p3.log.success(`Deleted ${tilde(CONFIG_DIR)}`);
+  } else {
+    p3.log.info(`Kept ${tilde(CONFIG_DIR)} \u2014 reinstate any time with ${pc7.cyan("shellup apply")}`);
+    p3.log.info(`Backups of your .zshrc are in ${tilde(BACKUP_DIR)}`);
+  }
+  p3.outro(`Done. Reload with ${pc7.cyan("exec zsh")}.`);
+}
+
+// src/cli.ts
+function help() {
+  console.log(`
+  ${pc8.bgCyan(pc8.black(" shellup "))} ${pc8.dim("v" + version())}   ${pc8.dim("a beautiful, fast zsh in one command")}
+
+  ${pc8.bold("Usage")}
+    ${pc8.cyan("shellup")} ${pc8.dim("<command>")}
+
+  ${pc8.bold("Commands")}
+    ${pc8.cyan("init")}              Set up your shell \u2014 interactive, backs up your .zshrc
+    ${pc8.cyan("doctor")}            Check what's wired up and what isn't
+    ${pc8.cyan("theme")} ${pc8.dim("[name]")}      Switch prompt theme ${pc8.dim("(" + THEMES.map((t) => t.name).join(", ") + ")")}
+    ${pc8.cyan("apply")}             Regenerate shell files from config.json
+    ${pc8.cyan("uninstall")}         Remove the .zshrc block, optionally the config too
+
+  ${pc8.bold("Flags")}
+    ${pc8.cyan("-y, --yes")}         Skip the install confirmation during init
+    ${pc8.cyan("-v, --version")}     Print version
+    ${pc8.cyan("-h, --help")}        This message
+
+  ${pc8.dim("Config lives in ~/.config/shellup. Your own overrides go in custom.zsh,")}
+  ${pc8.dim("which shellup sources last and never overwrites.")}
+`);
+}
+async function main() {
+  const argv = process.argv.slice(2);
+  const flags = new Set(argv.filter((a) => a.startsWith("-")));
+  const [command, ...rest] = argv.filter((a) => !a.startsWith("-"));
+  if (flags.has("-v") || flags.has("--version")) {
+    console.log(version());
+    return;
+  }
+  if (flags.has("-h") || flags.has("--help")) return help();
+  switch (command) {
+    case void 0:
+    case "init":
+      return init({ yes: flags.has("-y") || flags.has("--yes") });
+    case "doctor":
+      return doctor();
+    case "theme":
+      return theme(rest[0]);
+    case "apply":
+      return applyCommand();
+    case "uninstall":
+      return uninstall();
+    case "help":
+      return help();
+    default:
+      console.error(`
+  ${pc8.red("Unknown command:")} ${command}
+  Run ${pc8.cyan("shellup --help")} to see what's available.
+`);
+      process.exitCode = 1;
+  }
+}
+main().catch((err) => {
+  console.error(`
+  ${pc8.red("shellup failed:")} ${err instanceof Error ? err.message : String(err)}
+`);
+  process.exitCode = 1;
+});