@pm-2001/shellup 0.1.0 → 0.2.0

package/README.md

@@ -26,6 +26,15 @@ background process, repainting when the result lands.
 > npm test                                                    4s
 ```
 
+**Suggestions as you type.** The rest of the command appears in grey, pulled from
+what you've actually run before — press <kbd>→</kbd> to accept it, <kbd>Alt</kbd>+<kbd>→</kbd>
+to take one word. When history has nothing, it falls back to the completion system, so
+`git ` still suggests a subcommand on a brand-new machine.
+
+```
+$ git pus­h origin main        ← "h origin main" is grey; → accepts
+```
+
 **Three themes**, two of which need no special font:
 
 | theme | needs a Nerd Font | |
@@ -38,7 +47,7 @@ background process, repainting when the result lands.
 [eza](https://github.com/eza-community/eza), [bat](https://github.com/sharkdp/bat),
 [fzf](https://github.com/junegunn/fzf), [zoxide](https://github.com/ajeetdsouza/zoxide),
 [fd](https://github.com/sharkdp/fd), [ripgrep](https://github.com/BurntSushi/ripgrep),
-[git-delta](https://github.com/dandavison/delta), lazygit, btop, jq, tldr.
+[git-delta](https://github.com/dandavison/delta), [zsh-autosuggestions](https://github.com/zsh-users/zsh-autosuggestions), lazygit, btop, jq, tldr.
 
 **zsh defaults worth having**: 100k lines of shared, deduplicated history; completion
 with case-insensitive matching and a menu; `auto_cd` and a directory stack; prefix-aware
@@ -83,6 +92,10 @@ leaves the file byte-for-byte as it was.
 - **`custom.zsh` is sourced last**, so anything you write there wins over shellup's
   defaults without forking anything.
 - **`compinit` checks its cache once a day** rather than rebuilding on every shell start.
+- **macOS per-session history is switched off.** `/etc/zshrc_Apple_Terminal` runs before
+  your `.zshrc` and, on a restored Terminal window, repoints `HISTFILE` into
+  `~/.zsh_sessions` — which quietly breaks a single shared history. shellup takes Apple's
+  documented opt-out and reclaims the file.
 
 ## Requirements
 

package/dist/cli.js

@@ -20,6 +20,10 @@ function has(bin) {
     return false;
   }
 }
+function hasFile(paths) {
+  const prefix = process.env.HOMEBREW_PREFIX ?? "/opt/homebrew";
+  return paths.some((path) => existsSync(path.replace("${HOMEBREW_PREFIX:-/opt/homebrew}", prefix)));
+}
 function detectPackageManager() {
   for (const pm of ["brew", "apt", "dnf", "pacman"]) if (has(pm)) return pm;
   return "none";
@@ -261,9 +265,40 @@ var TOOLS = [
     dnf: "tealdeer",
     pacman: "tealdeer",
     recommended: false
+  },
+  // Last on purpose: it wraps ZLE widgets, so it has to load after anything that
+  // defines its own (fzf, zoxide).
+  {
+    id: "autosuggestions",
+    label: "autosuggestions",
+    hint: "greys in the rest of the command as you type \u2014 press \u2192 to accept",
+    brew: "zsh-autosuggestions",
+    apt: "zsh-autosuggestions",
+    dnf: "zsh-autosuggestions",
+    pacman: "zsh-autosuggestions",
+    recommended: true,
+    sourceFiles: [
+      "${HOMEBREW_PREFIX:-/opt/homebrew}/share/zsh-autosuggestions/zsh-autosuggestions.zsh",
+      "/usr/local/share/zsh-autosuggestions/zsh-autosuggestions.zsh",
+      "/usr/share/zsh-autosuggestions/zsh-autosuggestions.zsh",
+      "/usr/share/zsh/plugins/zsh-autosuggestions/zsh-autosuggestions.zsh"
+    ],
+    // Set before sourcing, because the plugin reads some of these at load time.
+    snippet: [
+      `# 'history' replays what you actually ran; 'completion' falls back to the`,
+      `# completion system, so \`git \` suggests a subcommand on a fresh machine.`,
+      `ZSH_AUTOSUGGEST_STRATEGY=(history completion)`,
+      `ZSH_AUTOSUGGEST_HIGHLIGHT_STYLE='fg=8'`,
+      `# Stops the plugin doing work on pasted blobs, where it can't help anyway.`,
+      `ZSH_AUTOSUGGEST_BUFFER_MAX_SIZE=20`
+    ].join("\n")
   }
 ];
 var toolById = (id) => TOOLS.find((t) => t.id === id);
+function isPresent(tool) {
+  if (tool.sourceFiles) return hasFile(tool.sourceFiles);
+  return tool.bin ? has(tool.bin) : false;
+}
 function packageFor(tool, pm) {
   return pm === "brew" ? tool.brew : pm === "apt" ? tool.apt : pm === "dnf" ? tool.dnf : pm === "pacman" ? tool.pacman : void 0;
 }
@@ -288,7 +323,7 @@ function installTools(tools, pm) {
   const result = { installed: [], alreadyPresent: [], failed: [], unsupported: [], command: null };
   const wanted = [];
   for (const tool of tools) {
-    if (has(tool.bin)) {
+    if (isPresent(tool)) {
       result.alreadyPresent.push(tool.id);
       continue;
     }
@@ -310,7 +345,7 @@ function installTools(tools, pm) {
     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);
+  for (const tool of wanted) (isPresent(tool) ? result.installed : result.failed).push(tool.id);
   return result;
 }
 function applyGitConfig(entries) {
@@ -342,15 +377,29 @@ function renderTools(config) {
   const parts = [HEADER(version())];
   for (const id of config.tools) {
     const tool = toolById(id);
-    if (!tool?.snippet) continue;
-    parts.push(
-      `
+    if (!tool || !tool.snippet && !tool.sourceFiles) continue;
+    const rule = `
 # \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
+`;
+    const indent = (body) => body.split("\n").map((l) => l.trim() ? `  ${l}` : l).join("\n");
+    if (tool.sourceFiles) {
+      parts.push(
+        rule + (tool.snippet ? tool.snippet + "\n" : "") + `() {
+  local p
+  for p in \\
+` + tool.sourceFiles.map((f) => `    "${f}"`).join(" \\\n") + `
+  do
+    [[ -r $p ]] && { source $p; break }
+  done
+}
 `
-    );
+      );
+      continue;
+    }
+    parts.push(rule + `if command -v ${tool.bin} >/dev/null 2>&1; then
+` + indent(tool.snippet) + `
+fi
+`);
   }
   return parts.join("");
 }
@@ -543,6 +592,13 @@ async function init(opts = {}) {
   }
   if (existing) {
     p.log.info(`Existing setup found (theme ${pc3.cyan(existing.theme)}). This will reconfigure it.`);
+    const added = TOOLS.filter((t) => t.recommended && !existing.tools.includes(t.id));
+    if (added.length) {
+      p.log.info(
+        `New since your last run: ${added.map((t) => pc3.cyan(t.label)).join(", ")}
+  Press ${pc3.cyan("Space")} on the list below to add ${added.length > 1 ? "them" : "it"}.`
+      );
+    }
   }
   const theme2 = await p.select({
     message: "Pick a prompt theme",
@@ -569,7 +625,7 @@ async function init(opts = {}) {
     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)") : ""),
+      label: t.label + (isPresent(t) ? pc3.green("  (installed)") : ""),
       hint: t.hint
     }))
   });
@@ -600,7 +656,7 @@ async function init(opts = {}) {
     nerdFont: env.nerdFont,
     installedAt: existing?.installedAt ?? (/* @__PURE__ */ new Date()).toISOString()
   };
-  const missing = selectedTools.map((id) => toolById(id)).filter((t) => t && !has(t.bin));
+  const missing = selectedTools.map((id) => toolById(id)).filter((t) => t && !isPresent(t));
   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(", ")})`,
@@ -626,7 +682,7 @@ async function init(opts = {}) {
     );
   }
   const delta = toolById("delta");
-  if (selectedTools.includes("delta") && has(delta.bin) && delta.gitConfig) {
+  if (selectedTools.includes("delta") && isPresent(delta) && delta.gitConfig) {
     const doGit = await p.confirm({
       message: "Set git to use delta for diffs? (writes to your global ~/.gitconfig)",
       initialValue: true
@@ -694,13 +750,13 @@ ${pc4.bold("  Installation")}`);
 ${pc4.bold("  Tools")}`);
   const selected = new Set(config?.tools ?? []);
   for (const tool of TOOLS) {
-    const present = has(tool.bin);
+    const present = isPresent(tool);
     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));
+  const missing = [...selected].map((id) => toolById(id)).filter((t) => t && !isPresent(t));
   if (missing.length) problems.push(`install missing tools: ${missing.map((t) => t.label).join(", ")}`);
   console.log();
   if (problems.length) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pm-2001/shellup",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Level up your terminal in 60 seconds — a beautiful prompt, modern tool swaps, and sane defaults, installed by one command and reversible by another.",
   "keywords": [
     "terminal",

package/runtime/options.zsh

@@ -6,7 +6,18 @@
 [[ -o interactive ]] || return 0
 
 # ── History ────────────────────────────────────────────────────────────────
-HISTFILE="${HISTFILE:-$HOME/.zsh_history}"
+# macOS ships per-session history in /etc/zshrc_Apple_Terminal, which runs BEFORE
+# this file. It normally stands down when SHARE_HISTORY is set — but on a restored
+# Terminal window it repoints HISTFILE into ~/.zsh_sessions straight away, before
+# it can see our options, silently defeating the shared history set up below.
+# SHELL_SESSION_HISTORY=0 is Apple's documented opt-out; the reclaim handles the
+# window that has already been hijacked.
+SHELL_SESSION_HISTORY=0
+if [[ $HISTFILE == */.zsh_sessions/* ]]; then
+  HISTFILE="${ZDOTDIR:-$HOME}/.zsh_history"
+  [[ -r $HISTFILE ]] && fc -R "$HISTFILE"
+fi
+HISTFILE="${HISTFILE:-${ZDOTDIR:-$HOME}/.zsh_history}"
 HISTSIZE=100000
 SAVEHIST=100000
 setopt append_history          # never truncate another shell's writes