Make the installer zero-friction

- No arguments needed: setup.sh detects the shell from $SHELL, falling
  back to installed shells with existing rc files
- git is now optional: falls back to a curl/wget tarball download,
  staged so a failed fetch can't leave a half-install; re-running with
  git available upgrades the install to a checkout
- Missing rc files are created instead of skipped with "re-run"
- doctor/update handle git-less installs gracefully
- New hermetic test suite for setup.sh, run in CI on ubuntu and
  macOS system bash 3.2

Author: aymenkrifa

.github/workflows/ci.yml

@@ -26,6 +26,7 @@ jobs:
           bash -n _constants.sh
           bash -n tests/test_activator.sh
           bash -n tests/test_subcommands.sh
+          bash -n tests/test_setup.sh
           bash -n bench/bench.sh
 
       - name: Syntax check (zsh)
@@ -45,6 +46,7 @@ jobs:
           shellcheck --shell=bash --severity=warning _constants.sh
           shellcheck --shell=bash --severity=warning tests/test_activator.sh
           shellcheck --shell=bash --severity=warning tests/test_subcommands.sh
+          shellcheck --shell=bash --severity=warning tests/test_setup.sh
 
       - name: Activator tests (bash)
         run: bash tests/test_activator.sh
@@ -58,6 +60,11 @@ jobs:
       - name: Subcommand tests (zsh)
         run: zsh tests/test_subcommands.sh
 
+      # setup.sh is bash-only (piped installs run it under bash), so this
+      # suite has no zsh variant.
+      - name: Setup tests (bash)
+        run: bash tests/test_setup.sh
+
   test-macos:
     runs-on: macos-latest
     steps:
@@ -76,3 +83,8 @@ jobs:
 
       - name: Subcommand tests (zsh)
         run: zsh tests/test_subcommands.sh
+
+      # The system bash 3.2 is exactly what a piped install runs under on
+      # macOS, so this is the highest-value environment for the installer.
+      - name: Setup tests (system bash 3.2)
+        run: /bin/bash tests/test_setup.sh

CONTRIBUTING.md

@@ -27,23 +27,27 @@ Shell scripts in this repo — including the tests and the benchmark — are lin
 shellcheck --severity=warning setup.sh bench/bench.sh
 shellcheck --shell=bash --severity=warning activator.sh autoactivator_config.sh _constants.sh tests/*.sh
 bash -n setup.sh activator.sh autoactivator_config.sh _constants.sh tests/*.sh bench/bench.sh
-zsh -n activator.sh autoactivator_config.sh _constants.sh tests/*.sh bench/bench.sh
+zsh -n activator.sh autoactivator_config.sh _constants.sh tests/test_activator.sh tests/test_subcommands.sh bench/bench.sh
 ```
 
+(`setup.sh` and `tests/test_setup.sh` are bash-only — piped installs always run under bash — so they are excluded from the `zsh -n` check.)
+
 `activator.sh` is sourced by both `bash` and `zsh`, so any zsh-specific syntax must be guarded by `[[ -n "$ZSH_VERSION" ]]` and any bash-specific syntax by `[[ -n "$BASH_VERSION" ]]`.
 
 ## Tests
 
-The repo has two black-box test suites, neither of which needs Python or an external test framework:
+The repo has three black-box test suites, none of which needs Python or an external test framework:
 
 - [`tests/test_activator.sh`](tests/test_activator.sh) builds a fake project tree in a temp directory, sources `activator.sh`, and asserts behavior by invoking `_check_for_venv` directly.
 - [`tests/test_subcommands.sh`](tests/test_subcommands.sh) sources the full config under a throwaway `$HOME` and exercises the `autoactivator` subcommands.
+- [`tests/test_setup.sh`](tests/test_setup.sh) runs the installer end-to-end against a local fixture repo and tarball under throwaway `$HOME`s — no network. It is bash-only, like the installer itself.
 
-Run both under both shells before opening a PR:
+Run them before opening a PR (the first two under both shells):
 
 ```bash
 bash tests/test_activator.sh   && zsh tests/test_activator.sh
 bash tests/test_subcommands.sh && zsh tests/test_subcommands.sh
+bash tests/test_setup.sh
 ```
 
 CI runs all of these on every push and pull request, on Linux and on macOS (where the system bash 3.2 exercises the cacheless code path).

README.md

@@ -32,18 +32,18 @@ If you activate a venv by hand, AutoActivator leaves it alone — no automatic s
 ## Requirements
 
 - **bash** or **zsh**
-- **git** — used for installation and updates
+- **git** — recommended for installation and updates; without it, the installer falls back to a tarball download (needs **curl** or **wget**, plus **tar**)
 - Linux or macOS (both covered by CI, including macOS's stock bash 3.2)
 
 No Python required.
 
 ## Installation
 
 ```bash
-curl -sSL https://autoactivator.aymenkrifa.com/setup.sh | bash -s <shell>
+curl -sSL https://autoactivator.aymenkrifa.com/setup.sh | bash
 ```
 
-Replace `<shell>` with `bash`, `zsh`, or both:
+No arguments needed — the installer detects your shell from `$SHELL` and wires up the matching rc file (creating it if it doesn't exist). Want a specific shell (or both)? Pass it explicitly:
 
 ```bash
 # zsh only
@@ -62,7 +62,7 @@ curl -sSL https://autoactivator.aymenkrifa.com/setup.sh | bash -s zsh bash
 ```bash
 git clone https://github.com/aymenkrifa/autoactivator.git ~/.autoactivator
 chmod +x ~/.autoactivator/setup.sh
-~/.autoactivator/setup.sh <shell>
+~/.autoactivator/setup.sh   # optionally pass a shell: ~/.autoactivator/setup.sh zsh
 ```
 
 </details>
@@ -82,6 +82,8 @@ autoactivator update
 
 This pulls the latest changes and re-sources the hook in your current shell. The update will refuse to run if you have local modifications in `~/.autoactivator`.
 
+Installed without git? `autoactivator update` will point you back to the install one-liner — re-running it refreshes the install in place (and upgrades it to a git checkout once git is available).
+
 ## Tool support
 
 AutoActivator finds venvs that live **inside the project tree**. Here's how that maps to the common Python tools:

RELEASING.md

@@ -1,8 +1,8 @@
 # Releasing
 
 AutoActivator ships as source — installs happen via `setup.sh` (`git clone` /
-`git pull`), so a release is a **git tag + a GitHub Release**, with no build
-artifacts. The `autoactivator version` command derives its output from
+`git pull`, with a tarball fallback when git is absent), so a release is a
+**git tag + a GitHub Release**, with no build artifacts. The `autoactivator version` command derives its output from
 `git describe --tags`, so nothing in the code hardcodes the version.
 
 ## Versioning

autoactivator_config.sh

@@ -224,6 +224,8 @@ _autoactivator_cmd_doctor() {
         else
             _autoactivator_check warn "local modifications in $_AUTOACTIVATOR_DIR — \`update\` will refuse to run"
         fi
+    elif [ -f "$_AUTOACTIVATOR_DIR/autoactivator_config.sh" ]; then
+        _autoactivator_check ok "install present at $_AUTOACTIVATOR_DIR (tarball install — update by re-running the installer)"
     else
         _autoactivator_check fail "repo NOT found at $_AUTOACTIVATOR_DIR"
     fi
@@ -321,7 +323,9 @@ _autoactivator_cmd_uninstall() {
 
 _autoactivator_cmd_update() {
     if [ ! -d "$_AUTOACTIVATOR_DIR/.git" ]; then
-        _autoactivator_msg 2 "not a git checkout at $_AUTOACTIVATOR_DIR — cannot update."
+        _autoactivator_msg 2 "not a git checkout at $_AUTOACTIVATOR_DIR (installed without git)."
+        _autoactivator_msg 2 "update by re-running the installer:"
+        _autoactivator_msg 2 "  curl -sSL https://autoactivator.aymenkrifa.com/setup.sh | bash"
         return 1
     fi
 

docs/index.html

@@ -188,12 +188,13 @@ <h1><span class="a">Auto</span><span class="b">Activator</span></h1>
     </div>
 
     <div class="tabs" role="tablist" aria-label="Choose your shell">
-      <button data-shell="zsh" class="on" aria-pressed="true">zsh</button>
+      <button data-shell="" class="on" aria-pressed="true">auto</button>
+      <button data-shell="zsh" aria-pressed="false">zsh</button>
       <button data-shell="bash" aria-pressed="false">bash</button>
       <button data-shell="zsh bash" aria-pressed="false">both</button>
     </div>
     <div class="install">
-      <code id="cmdline">curl -sSL https://autoactivator.aymenkrifa.com/setup.sh | bash -s <b id="shellarg">zsh</b></code>
+      <code id="cmdline">curl -sSL https://autoactivator.aymenkrifa.com/setup.sh | bash<b id="shellarg"></b></code>
       <button id="copy" aria-label="Copy install command">copy</button>
     </div>
   </section>
@@ -224,7 +225,11 @@ <h3 class="sub">And it's fast — a cd hook has no business being slow</h3>
 
   <section id="install">
     <h2>Install</h2>
-    <p class="lede">You need <b>bash</b> or <b>zsh</b>, <b>git</b>, and Linux or macOS — both covered by CI, including macOS's stock bash 3.2. No Python required.</p>
+    <p class="lede">You need <b>bash</b> or <b>zsh</b> and Linux or macOS — both covered by CI, including macOS's stock bash 3.2. <b>git</b> is recommended; without it the installer falls back to a tarball via <b>curl</b>/<b>wget</b> + <b>tar</b>. No Python required.</p>
+
+<pre data-label="auto-detect (recommended)">curl -sSL https://autoactivator.aymenkrifa.com/setup.sh | bash</pre>
+
+    <p class="lede fine">No arguments needed — the installer detects your shell from <code>$SHELL</code> and creates the rc file if it's missing. Want a specific shell (or both)?</p>
 
 <pre class="grouped" data-label="zsh">curl -sSL https://autoactivator.aymenkrifa.com/setup.sh | bash -s <span class="y">zsh</span></pre>
 
@@ -236,7 +241,7 @@ <h2>Install</h2>
 
     <h3 class="sub">Update &amp; uninstall</h3>
 <pre class="grouped" data-label="update">autoactivator <span class="s">update</span></pre>
-    <p class="lede fine">Pulls the latest version and re-sources the hook in your current shell.</p>
+    <p class="lede fine">Pulls the latest version and re-sources the hook in your current shell. Installed without git? Re-run the install one-liner instead — it refreshes the install in place (and upgrades it to a git checkout once git is available).</p>
 
 <pre data-label="uninstall">autoactivator <span class="s">uninstall</span></pre>
     <p class="lede fine">Removes the hook from your rc files, backing them up first — add <code>--purge</code> to also delete <code>~/.autoactivator</code>.</p>
@@ -338,7 +343,7 @@ <h2>Security note</h2>
     t.addEventListener('click', function(){
       tabs.forEach(function(o){ o.classList.remove('on'); o.setAttribute('aria-pressed','false'); });
       t.classList.add('on'); t.setAttribute('aria-pressed','true');
-      shellarg.textContent = t.dataset.shell;
+      shellarg.textContent = t.dataset.shell ? ' -s ' + t.dataset.shell : '';
     });
   });
 

docs/setup.sh

@@ -4,8 +4,11 @@ set -e
 APP_NAME="AutoActivator"
 TARGET_DIR="$HOME/.autoactivator"
 REPO_URL="${AUTOACTIVATOR_REPO_URL:-https://github.com/aymenkrifa/autoactivator}"
+TARBALL_URL="${AUTOACTIVATOR_TARBALL_URL:-${REPO_URL%.git}/archive/refs/heads/main.tar.gz}"
+ONELINER="curl -sSL https://autoactivator.aymenkrifa.com/setup.sh | bash"
 
 die() { echo "Error: $*" >&2; exit 1; }
+have() { command -v "$1" >/dev/null 2>&1; }
 
 rc_for_shell() {
   case "$1" in
@@ -14,51 +17,102 @@ rc_for_shell() {
   esac
 }
 
-[ $# -gt 0 ] || die "Usage: $(basename "$0") <shell> [<shell>...]  (shells: bash, zsh)"
-
-for s in "$@"; do
-  case "$s" in
-    bash|zsh) ;;
-    *) die "Unsupported shell '$s'. Must be 'bash' or 'zsh'." ;;
-  esac
-done
+# Fetch and unpack a source tarball into $TARGET_DIR when git is missing.
+# Staged in a temp dir beside the target so a failed download or extract
+# can never leave a half-install at $TARGET_DIR.
+tarball_install() {
+  if ! { have curl || have wget; } || ! have tar; then
+    die "git is not installed, and the tarball fallback needs curl or wget, plus tar. Install git (recommended), or curl/wget and tar, then re-run."
+  fi
+  echo "git not found — downloading $APP_NAME as a tarball instead ..."
+  TMP_STAGE=$(mktemp -d "$HOME/.autoactivator.new.XXXXXX")
+  trap 'rm -rf "$TMP_STAGE"' EXIT
+  if have curl; then
+    curl -fsSL "$TARBALL_URL" -o "$TMP_STAGE/src.tar.gz"
+  else
+    wget -qO "$TMP_STAGE/src.tar.gz" "$TARBALL_URL"
+  fi
+  mkdir "$TMP_STAGE/src"
+  tar -xzf "$TMP_STAGE/src.tar.gz" -C "$TMP_STAGE/src" --strip-components=1
+  rm -rf "$TARGET_DIR"
+  mv "$TMP_STAGE/src" "$TARGET_DIR"
+}
 
 case "$(uname -s)" in
   Linux|Darwin) ;;
   *) die "Unsupported OS: $(uname -s). Only Linux and macOS are supported." ;;
 esac
 
-command -v git >/dev/null 2>&1 || die "git is not installed. https://git-scm.com/"
+shells=()
+if [ $# -gt 0 ]; then
+  for s in "$@"; do
+    case "$s" in
+      bash|zsh) shells+=("$s") ;;
+      *) die "Unsupported shell '$s'. Usage: $(basename "$0") [<shell>...]  (shells: bash, zsh; no arguments = auto-detect)" ;;
+    esac
+  done
+else
+  # No arguments: detect the user's shell. $0 is useless here (piped
+  # installs always run under bash), but login shells leave $SHELL behind.
+  s="${SHELL##*/}"
+  if { [ "$s" = bash ] || [ "$s" = zsh ]; } && have "$s"; then
+    echo "No shell specified — detected $s from \$SHELL."
+    shells=("$s")
+  else
+    # $SHELL unset or unsupported: fall back to every supported shell
+    # that is installed and already has an rc file.
+    for s in bash zsh; do
+      if have "$s" && [ -f "$(rc_for_shell "$s")" ]; then
+        shells+=("$s")
+      fi
+    done
+    [ ${#shells[@]} -eq 0 ] || echo "No shell specified — detected: ${shells[*]}."
+  fi
+  [ ${#shells[@]} -gt 0 ] || die "Could not auto-detect your shell (SHELL=${SHELL:-unset}). Re-run with an explicit shell, e.g.: $ONELINER -s zsh"
+fi
 
 if [ -d "$TARGET_DIR/.git" ]; then
+  have git || die "$TARGET_DIR is a git checkout but git is no longer installed. Install git, or remove the directory (rm -rf $TARGET_DIR) and re-run."
   echo "$APP_NAME is already cloned at $TARGET_DIR. Pulling latest..."
   git -C "$TARGET_DIR" pull --ff-only origin main
 elif [ -e "$TARGET_DIR" ]; then
-  die "$TARGET_DIR exists but is not a git checkout. Move or remove it and re-run."
-else
+  [ -f "$TARGET_DIR/autoactivator_config.sh" ] || die "$TARGET_DIR exists but is not an $APP_NAME install. Move or remove it and re-run."
+  if have git; then
+    # A previous tarball install: replace it with a git checkout so
+    # 'autoactivator update' works from now on.
+    echo "Upgrading $TARGET_DIR to a git checkout ..."
+    rm -rf "$TARGET_DIR"
+    git clone "$REPO_URL" "$TARGET_DIR"
+  else
+    echo "Refreshing the existing install at $TARGET_DIR ..."
+    tarball_install
+  fi
+elif have git; then
   echo "Cloning $REPO_URL to $TARGET_DIR ..."
   git clone "$REPO_URL" "$TARGET_DIR"
+else
+  tarball_install
 fi
 
 CONFIG_PATH="$TARGET_DIR/autoactivator_config.sh"
-[ -f "$CONFIG_PATH" ] || die "Expected $CONFIG_PATH after clone but it's missing."
+[ -f "$CONFIG_PATH" ] || die "Expected $CONFIG_PATH after install but it's missing."
 
 CONSTANTS_PATH="$TARGET_DIR/_constants.sh"
-[ -f "$CONSTANTS_PATH" ] || die "Expected $CONSTANTS_PATH after clone but it's missing."
+[ -f "$CONSTANTS_PATH" ] || die "Expected $CONSTANTS_PATH after install but it's missing."
 # shellcheck source=_constants.sh disable=SC1091
 . "$CONSTANTS_PATH"
 
 installed=()
-for shell in "$@"; do
-  if ! command -v "$shell" >/dev/null 2>&1; then
+for shell in "${shells[@]}"; do
+  if ! have "$shell"; then
     echo "Skipping $shell: not installed on this system."
     continue
   fi
 
   rc=$(rc_for_shell "$shell")
   if [ ! -f "$rc" ]; then
-    echo "Skipping $shell: $rc does not exist. Run 'touch $rc' and re-run."
-    continue
+    touch "$rc"
+    echo "Created $rc (didn't exist)."
   fi
 
   backup="$rc.pre-autoactivator"
@@ -85,4 +139,10 @@ done
 
 echo
 echo "$APP_NAME installed for: ${installed[*]}"
-echo "Restart your terminal for the changes to take effect."
+echo
+echo "Activate it now — run:"
+for shell in "${installed[@]}"; do
+  rc=$(rc_for_shell "$shell")
+  printf '  %-5s source ~%s\n' "$shell:" "${rc#"$HOME"}"
+done
+echo "(or just open a new terminal)"