@crystalplatforms/adm 0.2.3 → 0.3.0

package/src/pkg/package-names.js

@@ -0,0 +1,229 @@
+// Per-distro package-name mapping: tool id → package name per manager.
+//
+//   PACKAGE_NAMES[id][manager] = 'package-name'      explicit mapping
+//   PACKAGE_NAMES[id][manager] = { manual: 'reason'} not packaged for that manager
+//
+// Managers with no entry for a tool default to the tool id itself
+// (most package names equal the tool id). resolvePackageName therefore ALWAYS
+// returns { name } or { manual } — never undefined (completeness contract).
+//
+// Only deviations from the tool id are listed here; the identity default keeps
+// the table maintainable. When a tool is genuinely absent from a manager's
+// official repos, an explicit { manual } entry explains how to get it.
+//
+// ── winget ids (HITL finding, 0.3.0) ────────────────────────────────────
+// winget requires Publisher.Package ids (Git.Git, not "git") — the identity
+// default is essentially ALWAYS wrong on winget, so every winget-route tool
+// carries an explicit entry below. All ids verified against the live winget
+// catalog (winget show --id <id> --exact) on winget 1.29.
+const PACKAGE_NAMES = {
+  // ── language runtimes ─────────────────────────────────────────
+  python3: { brew: 'python', pacman: 'python', winget: 'Python.Python.3.13' },
+  pyenv: {
+    apt: { manual: 'pyenv is not in Debian/Ubuntu repos — install via script: curl -fsSL https://pyenv.run | sh' },
+    dnf: { manual: 'pyenv is not in Fedora repos — install via script: curl -fsSL https://pyenv.run | sh' },
+    pacman: { manual: 'pyenv lives in the AUR — install manually: https://aur.archlinux.org/packages/pyenv' },
+    zypper: { manual: 'pyenv is not in openSUSE repos — install via script: curl -fsSL https://pyenv.run | sh' },
+    apk: { manual: 'pyenv is not in Alpine repos — install via script: curl -fsSL https://pyenv.run | sh' },
+    winget: 'pyenv-win.pyenv-win',
+  },
+  go: { apt: 'golang-go', winget: 'GoLang.Go' },
+  jdk: {
+    brew: 'openjdk',
+    apt: 'default-jdk',
+    dnf: 'java-21-openjdk-devel',
+    pacman: 'jdk-openjdk',
+    zypper: 'java-21-openjdk-devel',
+    apk: 'openjdk21-jdk',
+    winget: 'EclipseAdoptium.Temurin.21.JDK',
+  },
+  dotnet: {
+    brew: 'dotnet',
+    apt: 'dotnet-sdk-8.0',
+    dnf: 'dotnet-sdk',
+    pacman: 'dotnet-sdk',
+    zypper: 'dotnet-sdk',
+    apk: 'dotnet8-sdk',
+    winget: 'Microsoft.DotNet.SDK.8',
+    choco: 'dotnet-sdk',
+    scoop: 'dotnet-sdk',
+  },
+  scala: {
+    dnf: { manual: 'scala is not in official Fedora repos — use Coursier or SDKMAN: https://get-coursier.io' },
+    apk: { manual: 'scala is not in Alpine repos — use Coursier: https://get-coursier.io' },
+    winget: 'VirtusLab.ScalaCLI',
+  },
+  kotlin: { dnf: { manual: 'kotlin is not in official Fedora repos — install via sdkman: https://sdkman.io' }, apk: { manual: 'kotlin is not in Alpine repos — install manually: https://kotlinlang.org/docs/getting-started.html' }, winget: 'Kotlin.Kotlin' },
+  clojure: {
+    apt: { manual: 'install from the Clojure apt repo: https://clojure.org/guides/install_clojure' },
+    dnf: { manual: 'install from the Clojure rpm repo: https://clojure.org/guides/install_clojure' },
+    zypper: { manual: 'install from the Clojure rpm repo: https://clojure.org/guides/install_clojure' },
+    apk: { manual: 'clojure is not in Alpine repos — install via script: https://clojure.org/guides/install_clojure' },
+    winget: 'Clojure.ClojureCLI',
+  },
+  sbt: {
+    dnf: { manual: 'install from the sbt rpm repo: https://www.scala-sbt.org/download' },
+    pacman: { manual: 'sbt lives in the AUR — https://aur.archlinux.org/packages/sbt' },
+    zypper: { manual: 'install from the sbt rpm repo: https://www.scala-sbt.org/download' },
+    apk: { manual: 'sbt is not in Alpine repos — https://www.scala-sbt.org/download' },
+    winget: 'sbt.sbt',
+  },
+  graalvm: {
+    brew: { manual: 'install the cask: brew install --cask graalvm/tap/graalvm-jdk' },
+    apt: { manual: 'download from https://www.graalvm.org/downloads/' },
+    dnf: { manual: 'download from https://www.graalvm.org/downloads/' },
+    pacman: { manual: 'download from https://www.graalvm.org/downloads/' },
+    zypper: { manual: 'download from https://www.graalvm.org/downloads/' },
+    apk: { manual: 'download from https://www.graalvm.org/downloads/' },
+    winget: { manual: 'no official GraalVM winget package — download a JDK build from https://www.graalvm.org/downloads/' },
+  },
+  ruby: { winget: 'RubyInstallerTeam.RubyWithDevKit.3.4' },
+  php: { brew: 'php', apt: 'php-cli', dnf: 'php-cli', zypper: 'php8', winget: 'PHP.PHP.8.4' },
+  symfony: {
+    brew: 'symfony-cli/tap',
+    apt: 'symfony-cli',
+    dnf: 'symfony-cli',
+    pacman: { manual: 'install via the Symfony installer script: https://symfony.com/download' },
+    zypper: { manual: 'install via the Symfony installer script: https://symfony.com/download' },
+    apk: { manual: 'install via the Symfony installer script: https://symfony.com/download' },
+    choco: 'symfony-cli',
+    scoop: 'symfony-cli',
+    winget: 'Symfony-cli.Symfony-cli',
+  },
+  'wp-cli': { apt: { manual: 'install via the official phar: https://wp-cli.org/#installing' }, dnf: { manual: 'install via the official phar: https://wp-cli.org/#installing' }, pacman: { manual: 'install via the official phar: https://wp-cli.org/#installing' }, zypper: { manual: 'install via the official phar: https://wp-cli.org/#installing' }, apk: { manual: 'install via the official phar: https://wp-cli.org/#installing' }, winget: { manual: 'wp-cli is a phar — download from https://wp-cli.org/#installing' } },
+
+  // ── jvm ecosystem ─────────────────────────────────────────────
+  gradle: { winget: 'Gradle.Gradle' },
+  maven: { winget: 'Apache.Maven' },
+  ant: { winget: 'ApacheAnt.ApacheAnt' },
+  leiningen: { winget: 'Leiningen.Leiningen' },
+  jbang: { apt: { manual: 'jbang is not in Debian/Ubuntu repos — https://www.jbang.dev/download/' }, dnf: { manual: 'jbang is not in Fedora repos — https://www.jbang.dev/download/' }, pacman: { manual: 'jbang is not in official Arch repos — https://www.jbang.dev/download/' }, zypper: { manual: 'jbang is not in openSUSE repos — https://www.jbang.dev/download/' }, apk: { manual: 'jbang is not in Alpine repos — https://www.jbang.dev/download/' }, winget: 'jbangdev.jbang' },
+  'spring-boot': { apt: { manual: 'install via sdkman: https://sdkman.io' }, dnf: { manual: 'install via sdkman: https://sdkman.io' }, pacman: { manual: 'install via sdkman: https://sdkman.io' }, zypper: { manual: 'install via sdkman: https://sdkman.io' }, apk: { manual: 'install via sdkman: https://sdkman.io' }, winget: { manual: 'no official Spring Boot CLI winget package — install via sdkman: https://sdkman.io' } },
+  quarkus: { apt: { manual: 'quarkus CLI is not in Debian/Ubuntu repos — https://quarkus.io/guides/cli-tooling' }, dnf: { manual: 'quarkus CLI is not in Fedora repos — https://quarkus.io/guides/cli-tooling' }, pacman: { manual: 'quarkus CLI is not in official Arch repos — https://quarkus.io/guides/cli-tooling' }, zypper: { manual: 'quarkus CLI is not in openSUSE repos — https://quarkus.io/guides/cli-tooling' }, apk: { manual: 'quarkus CLI is not in Alpine repos — https://quarkus.io/guides/cli-tooling' }, winget: { manual: 'no official Quarkus CLI winget package — see https://quarkus.io/guides/cli-tooling' } },
+  micronaut: { apt: { manual: 'install via sdkman: https://sdkman.io' }, dnf: { manual: 'install via sdkman: https://sdkman.io' }, pacman: { manual: 'install via sdkman: https://sdkman.io' }, zypper: { manual: 'install via sdkman: https://sdkman.io' }, apk: { manual: 'install via sdkman: https://sdkman.io' }, winget: { manual: 'no official Micronaut CLI winget package — install via sdkman: https://sdkman.io' } },
+  visualvm: { apt: { manual: 'download from https://visualvm.github.io/' }, dnf: { manual: 'download from https://visualvm.github.io/' }, pacman: { manual: 'download from https://visualvm.github.io/' }, zypper: { manual: 'download from https://visualvm.github.io/' }, apk: { manual: 'download from https://visualvm.github.io/' }, winget: 'VisualVM.VisualVM' },
+  jmeter: { apt: { manual: 'download from https://jmeter.apache.org/download_jmeter.cgi' }, dnf: { manual: 'download from https://jmeter.apache.org/download_jmeter.cgi' }, pacman: { manual: 'download from https://jmeter.apache.org/download_jmeter.cgi' }, zypper: { manual: 'download from https://jmeter.apache.org/download_jmeter.cgi' }, apk: { manual: 'download from https://jmeter.apache.org/download_jmeter.cgi' }, winget: 'Apache.JMeter' },
+  jolokia: { apt: { manual: 'download from https://jolokia.org/' }, dnf: { manual: 'download from https://jolokia.org/' }, pacman: { manual: 'jolokia lives in the AUR' }, zypper: { manual: 'download from https://jolokia.org/' }, apk: { manual: 'download from https://jolokia.org/' }, winget: { manual: 'jolokia is a JVM agent, not a CLI — add it to your app: https://jolokia.org' } },
+  flyway: { apt: { manual: 'download from https://documentation.red-gate.com/fd/quickstart-maven-224919678.html or use the download bundle' }, dnf: { manual: 'download from https://www.red-gate.com/products/flyway/ (download bundle)' }, pacman: { manual: 'flyway lives in the AUR — https://aur.archlinux.org/packages/flyway' }, zypper: { manual: 'download from https://www.red-gate.com/products/flyway/ (download bundle)' }, apk: { manual: 'download from https://www.red-gate.com/products/flyway/ (download bundle)' }, winget: 'Redgate.Flyway' },
+  liquibase: { apt: { manual: 'download from https://www.liquibase.org/download' }, dnf: { manual: 'download from https://www.liquibase.org/download' }, pacman: { manual: 'download from https://www.liquibase.org/download' }, zypper: { manual: 'download from https://www.liquibase.org/download' }, apk: { manual: 'download from https://www.liquibase.org/download' }, winget: 'Liquibase.Liquibase' },
+  coursier: { apt: { manual: 'install via script: curl -fL https://github.com/coursier/coursier/raw/stable/installs/cs-x86_64-pc-linux.gz | gzip -d > cs && chmod +x cs' }, dnf: { manual: 'install via script: https://get-coursier.io/docs/cli-installation' }, pacman: { manual: 'coursier lives in the AUR' }, zypper: { manual: 'install via script: https://get-coursier.io/docs/cli-installation' }, apk: { manual: 'install via script: https://get-coursier.io/docs/cli-installation' }, winget: { manual: 'install via the coursier bootstrapper: https://get-coursier.io/docs/cli-installation' } },
+  mill: { apt: { manual: 'mill is not in Debian/Ubuntu repos — https://mill-build.org/mill/cli_installation.html' }, dnf: { manual: 'mill is not in Fedora repos — https://mill-build.org/mill/cli_installation.html' }, pacman: { manual: 'mill lives in the AUR' }, zypper: { manual: 'mill is not in openSUSE repos — https://mill-build.org/mill/cli_installation.html' }, apk: { manual: 'mill is not in Alpine repos — https://mill-build.org/mill/cli_installation.html' }, winget: { manual: 'no official mill winget package — see https://mill-build.org/mill/cli_installation.html' } },
+  ammonite: { apt: { manual: 'install via script: https://ammonite.io/#Ammonite-ops' }, dnf: { manual: 'install via script: https://ammonite.io/#Ammonite-ops' }, pacman: { manual: 'install via script: https://ammonite.io/#Ammonite-ops' }, zypper: { manual: 'install via script: https://ammonite.io/#Ammonite-ops' }, apk: { manual: 'install via script: https://ammonite.io/#Ammonite-ops' }, winget: { manual: 'install via script: https://ammonite.io/#Ammonite-ops' } },
+  ktlint: { apt: { manual: 'ktlint is not in Debian/Ubuntu repos — https://pinterest.github.io/ktlint/install/cli/' }, dnf: { manual: 'ktlint is not in Fedora repos — https://pinterest.github.io/ktlint/install/cli/' }, pacman: { manual: 'ktlint lives in the AUR' }, zypper: { manual: 'ktlint is not in openSUSE repos — https://pinterest.github.io/ktlint/install/cli/' }, apk: { manual: 'ktlint is not in Alpine repos — https://pinterest.github.io/ktlint/install/cli/' }, winget: { manual: 'no official ktlint winget package — see https://pinterest.github.io/ktlint/install/cli/' } },
+  detekt: { apt: { manual: 'detekt is not in Debian/Ubuntu repos — https://detekt.dev/docs/gettingstarted/cli/' }, dnf: { manual: 'detekt is not in Fedora repos — https://detekt.dev/docs/gettingstarted/cli/' }, pacman: { manual: 'detekt lives in the AUR' }, zypper: { manual: 'detekt is not in openSUSE repos — https://detekt.dev/docs/gettingstarted/cli/' }, apk: { manual: 'detekt is not in Alpine repos — https://detekt.dev/docs/gettingstarted/cli/' }, winget: { manual: 'no official detekt winget package — see https://detekt.dev/docs/gettingstarted/cli/' } },
+
+  // ── c/c++ ─────────────────────────────────────────────────────
+  gcc: { winget: 'BrechtSanders.WinLibs.POSIX.UCRT' },
+  clang: { winget: 'LLVM.LLVM' },
+  cmake: { winget: 'Kitware.CMake' },
+  make: { winget: 'ezwinports.make' },
+  ninja: { winget: 'Ninja-build.Ninja' },
+  'clang-format': { dnf: 'clang-tools-extra', pacman: 'clang', zypper: 'clang', apk: 'clang', winget: { manual: 'clang-format ships with the LLVM toolchain — install it via ADM (tool "clang") or: winget install LLVM.LLVM' } },
+  'clang-tidy': { dnf: 'clang-tools-extra', pacman: 'clang', zypper: 'clang', apk: 'clang', winget: { manual: 'clang-tidy ships with the LLVM toolchain — install it via ADM (tool "clang") or: winget install LLVM.LLVM' } },
+  cppcheck: { winget: 'Cppcheck.Cppcheck' },
+  gdb: { winget: { manual: 'gdb ships with the WinLibs GCC toolchain — install it via ADM (tool "gcc") or MSYS2: https://www.msys2.org' } },
+  lldb: { winget: { manual: 'lldb ships with LLVM toolchain distributions — install via ADM (tool "clang") or: scoop install llvm' } },
+  ccache: { winget: 'Ccache.Ccache' },
+  valgrind: { winget: { manual: 'valgrind is a Unix profiler — use WSL: wsl -e bash -c "sudo apt install valgrind"' } },
+  distcc: { winget: { manual: 'distcc is a Unix distributed compiler — use WSL: https://distcc.github.io' } },
+  bear: { winget: { manual: 'bear (compilation DB generator) is a Unix tool — use WSL: https://github.com/rizsotto/Bear' } },
+  doxygen: { winget: 'Doxygen.Doxygen' },
+  bazelisk: { apt: { manual: 'download the binary from https://github.com/bazelbuild/bazelisk/releases' }, dnf: { manual: 'download the binary from https://github.com/bazelbuild/bazelisk/releases' }, pacman: { manual: 'download the binary from https://github.com/bazelbuild/bazelisk/releases' }, zypper: { manual: 'download the binary from https://github.com/bazelbuild/bazelisk/releases' }, apk: { manual: 'download the binary from https://github.com/bazelbuild/bazelisk/releases' }, winget: { manual: 'no official bazelisk winget package — download from https://github.com/bazelbuild/bazelisk/releases or: choco install bazelisk' } },
+
+  // ── universal ─────────────────────────────────────────────────
+  // Windows winget ids differ from the tool ids — explicit mapping below
+  // (every id verified against the live winget catalog).
+  curl: { winget: 'cURL.cURL' },
+  jq: { winget: 'jqlang.jq' },
+  yq: { winget: 'MikeFarah.yq' },
+  git: { winget: 'Git.Git' },
+  gh: { winget: 'GitHub.cli' },
+  hub: { winget: 'GitHub.hub' },
+  'git-lfs': { winget: 'GitHub.GitLFS' },
+  gitflow: {
+    dnf: { manual: 'gitflow is not in official Fedora repos — https://github.com/petervanderdoes/gitflow-avh/wiki/Installation' },
+    zypper: { manual: 'gitflow is not in openSUSE repos — https://github.com/petervanderdoes/gitflow-avh/wiki/Installation' },
+    apk: { manual: 'gitflow is not in Alpine repos — https://github.com/petervanderdoes/gitflow-avh/wiki/Installation' },
+    winget: { manual: 'no git-flow winget package — via Chocolatey: choco install gitflow.avhEdition' },
+    choco: 'gitflow.avhEdition',
+  },
+  tig: { winget: { manual: 'tig is a Unix TUI — use WSL: wsl -e bash -c "sudo apt install tig"' } },
+  kubectl: { winget: 'Kubernetes.kubectl' },
+  k9s: { apt: { manual: 'download from https://github.com/derailed/k9s/releases' }, dnf: { manual: 'download from https://github.com/derailed/k9s/releases' }, zypper: { manual: 'download from https://github.com/derailed/k9s/releases' }, winget: 'Derailed.k9s' },
+  terraform: { winget: 'Hashicorp.Terraform' },
+  packer: { winget: 'Hashicorp.Packer' },
+  vagrant: { apt: { manual: 'install from the HashiCorp apt repo: https://developer.hashicorp.com/vagrant/install' }, dnf: { manual: 'install from the HashiCorp rpm repo: https://developer.hashicorp.com/vagrant/install' }, apk: { manual: 'vagrant is not in Alpine repos — https://developer.hashicorp.com/vagrant/install' }, winget: 'HashiCorp.Vagrant' },
+  'ansible-dev': { apt: { manual: 'ansible-dev is not in Debian/Ubuntu repos — install ansible via pip instead' }, dnf: { manual: 'ansible-dev is not in Fedora repos — install ansible via pip instead' }, pacman: { manual: 'ansible-dev is not in official Arch repos — install ansible via pip instead' }, zypper: { manual: 'ansible-dev is not in openSUSE repos — install ansible via pip instead' }, apk: { manual: 'ansible-dev is not in Alpine repos — install ansible via pip instead' }, winget: { manual: 'no ansible winget package — install via pip: pip install ansible' } },
+  neovim: { winget: 'Neovim.Neovim' },
+  zsh: { winget: { manual: 'zsh is a Unix shell — use WSL: wsl -e bash -c "sudo apt install zsh"' } },
+  'starship-brew': {
+    brew: 'starship',
+    apt: { manual: 'install via script: curl -sS https://starship.rs/install.sh | sh' },
+    dnf: { manual: 'install via script: curl -sS https://starship.rs/install.sh | sh' },
+    zypper: { manual: 'install via script: curl -sS https://starship.rs/install.sh | sh' },
+    apk: { manual: 'install via script: curl -sS https://starship.rs/install.sh | sh' },
+    winget: 'Starship.Starship',
+  },
+  htop: { winget: { manual: 'htop is a Unix TUI — use WSL: wsl -e bash -c "sudo apt install htop"' } },
+  ncdu: { winget: { manual: 'ncdu is a Unix TUI — use WSL: wsl -e bash -c "sudo apt install ncdu"' } },
+  // GnuWin32.Tree runs an INTERACTIVE setup wizard — headless winget install
+  // aborts with "You cancelled the installation" (HITL finding, 0.3.0).
+  tree: { winget: { manual: 'the winget tree package uses an interactive installer — use WSL: wsl -e bash -c "sudo apt install tree", or scoop: scoop install tree' } },
+  openssl: { winget: 'ShiningLight.OpenSSL.Light' },
+  // rsync is a Unix tool — no native Windows package exists anywhere
+  rsync: { winget: { manual: 'rsync is a Unix tool and has no native Windows build — use WSL: wsl -e rsync <args>, or try Rclone for cloud sync: winget install Rclone.Rclone' }, choco: { manual: 'rsync on Windows requires WSL/Cygwin — recommended: wsl -e rsync <args>' } },
+  // wget's winget manifest is permanently outdated (installer hash mismatch)
+  // and Windows 10+ ships curl anyway — route to manual guidance.
+  wget: { winget: { manual: 'the winget wget package is currently broken (installer hash mismatch). Windows 10+ already has curl built in: curl -O <url>. Or install wget via scoop: scoop install wget' } },
+  ffmpeg: { winget: 'Gyan.FFmpeg' },
+  tmux: { winget: { manual: 'tmux is a Unix terminal multiplexer and is not available on Windows — use WSL: wsl -e bash -c "sudo apt install tmux"' }, choco: { manual: 'tmux on Windows requires WSL/Cygwin — recommended: wsl -e bash -c "sudo apt install tmux"' } },
+  lazydocker: { winget: 'JesseDuffield.Lazydocker', apt: { manual: 'download from https://github.com/jesseduffield/lazydocker/releases' }, dnf: { manual: 'download from https://github.com/jesseduffield/lazydocker/releases' }, zypper: { manual: 'download from https://github.com/jesseduffield/lazydocker/releases' }, apk: { manual: 'download from https://github.com/jesseduffield/lazydocker/releases' } },
+  docker: {
+    apt: 'docker.io',
+    dnf: 'moby-engine',
+    winget: 'Docker.DockerDesktop',
+    choco: 'docker-desktop',
+    scoop: 'docker',
+  },
+  'docker-compose': {
+    apt: 'docker-compose-v2',
+    apk: 'docker-cli-compose',
+    winget: { manual: 'docker compose ships with Docker Desktop (winget install Docker.DockerDesktop)' },
+  },
+  watchman: {
+    apt: { manual: 'watchman is not in Debian/Ubuntu repos — build from source: https://facebook.github.io/watchman/docs/install' },
+    dnf: { manual: 'watchman is not in Fedora repos — build from source: https://facebook.github.io/watchman/docs/install' },
+    pacman: { manual: 'watchman lives in the AUR' },
+    zypper: { manual: 'watchman is not in openSUSE repos — build from source: https://facebook.github.io/watchman/docs/install' },
+    apk: { manual: 'watchman is not in Alpine repos — build from source: https://facebook.github.io/watchman/docs/install' },
+    winget: 'facebook.watchman',
+  },
+  imagemagick: { dnf: 'ImageMagick', zypper: 'ImageMagick', winget: 'ImageMagick.ImageMagick' },
+  shellcheck: { winget: { manual: 'no official shellcheck winget package — via scoop: scoop install shellcheck, or use WSL' } },
+  shfmt: { winget: { manual: 'no shfmt winget package — download from https://github.com/mvdan/sh/releases or: scoop install shfmt' } },
+  hadolint: { apt: { manual: 'download from https://github.com/hadolint/hadolint/releases' }, dnf: { manual: 'download from https://github.com/hadolint/hadolint/releases' }, pacman: { manual: 'hadolint lives in the AUR' }, zypper: { manual: 'download from https://github.com/hadolint/hadolint/releases' }, apk: { manual: 'download from https://github.com/hadolint/hadolint/releases' }, winget: 'hadolint.hadolint' },
+  tfsec: { apt: { manual: 'tfsec is not in Debian/Ubuntu repos — download from https://github.com/aquasecurity/tfsec/releases (now part of trivy)' }, dnf: { manual: 'tfsec is not in Fedora repos — download from https://github.com/aquasecurity/tfsec/releases (now part of trivy)' }, pacman: { manual: 'tfsec lives in the AUR' }, zypper: { manual: 'download from https://github.com/aquasecurity/tfsec/releases (now part of trivy)' }, winget: { manual: 'tfsec is deprecated in favor of trivy — install the ADM tool "trivy" instead' } },
+  trivy: { apt: { manual: 'install from the Aqua apt repo: https://trivy.dev/latest/getting-started/installation/' }, dnf: { manual: 'install from the Aqua rpm repo: https://trivy.dev/latest/getting-started/installation/' }, pacman: { manual: 'trivy lives in the AUR' }, zypper: { manual: 'install from the Aqua rpm repo: https://trivy.dev/latest/getting-started/installation/' }, winget: 'Aquasecurity.Trivy' },
+  sonarqube: { apt: { manual: 'sonarqube runs from the zip bundle or docker: https://docs.sonarsource.com/sonarqube/latest/setup-and-upgrade/install-the-server/' }, dnf: { manual: 'sonarqube runs from the zip bundle or docker: https://docs.sonarsource.com/sonarqube/latest/setup-and-upgrade/install-the-server/' }, pacman: { manual: 'sonarqube runs from the zip bundle or docker: https://docs.sonarsource.com/sonarqube/latest/setup-and-upgrade/install-the-server/' }, zypper: { manual: 'sonarqube runs from the zip bundle or docker: https://docs.sonarsource.com/sonarqube/latest/setup-and-upgrade/install-the-server/' }, apk: { manual: 'sonarqube runs from the zip bundle or docker: https://docs.sonarsource.com/sonarqube/latest/setup-and-upgrade/install-the-server/' }, winget: { manual: 'sonarqube runs from the zip bundle or docker: https://docs.sonarsource.com/sonarqube/latest/setup-and-upgrade/install-the-server/' } },
+  overmind: { apt: { manual: 'download from https://github.com/DarthSim/overmind/releases' }, dnf: { manual: 'download from https://github.com/DarthSim/overmind/releases' }, pacman: { manual: 'overmind lives in the AUR' }, zypper: { manual: 'download from https://github.com/DarthSim/overmind/releases' }, apk: { manual: 'download from https://github.com/DarthSim/overmind/releases' }, winget: { manual: 'no overmind winget package — download from https://github.com/DarthSim/overmind/releases' } },
+
+  // ── ai ────────────────────────────────────────────────────────
+  ollama: { apt: { manual: 'install via script: curl -fsSL https://ollama.com/install.sh | sh' }, dnf: { manual: 'install via script: curl -fsSL https://ollama.com/install.sh | sh' }, pacman: { manual: 'ollama is not in official Arch repos — install via script: curl -fsSL https://ollama.com/install.sh | sh' }, zypper: { manual: 'install via script: curl -fsSL https://ollama.com/install.sh | sh' }, apk: { manual: 'install via script: curl -fsSL https://ollama.com/install.sh | sh' }, winget: 'Ollama.Ollama' },
+};
+
+// Resolves the package name for a tool on a manager.
+// Returns { name } or { manual } — never undefined (completeness contract).
+function resolvePackageName(id, manager) {
+  const entry = PACKAGE_NAMES[id];
+  if (entry) {
+    const perManager = entry[manager];
+    if (typeof perManager === 'string') return { name: perManager };
+    if (perManager && typeof perManager === 'object' && perManager.manual) {
+      return { manual: perManager.manual };
+    }
+  }
+  // Default mapping: package name equals the tool id.
+  return { name: id };
+}
+
+module.exports = { PACKAGE_NAMES, resolvePackageName };

package/src/pkg/script-urls.js

@@ -0,0 +1,100 @@
+// Per-OS×arch script URL resolver for installMethod "script" tools.
+// resolveScript(id, os, arch) → { url, run } | { manual }
+//   url — download/script URL (for the plan and for humans)
+//   run — the exact command that installs it (POSIX sh unless noted)
+
+const key = (os, arch) => `${os}-${arch}`;
+
+const LINUX_X86 = 'Linux-x86_64';
+const LINUX_ARM = 'Linux-aarch64';
+const MAC_X86 = 'MacOSX-x86_64';
+const MAC_ARM = 'MacOSX-arm64';
+
+const condaAsset = { 'linux-x64': LINUX_X86, 'linux-arm64': LINUX_ARM, 'darwin-x64': MAC_X86, 'darwin-arm64': MAC_ARM };
+
+const SCRIPTS = {
+  conda: {
+    'linux-x64': () => ({ url: `https://repo.anaconda.com/miniconda/Miniconda3-latest-${condaAsset['linux-x64']}.sh`, run: 'curl -fsSL https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh -o /tmp/miniconda.sh && sh /tmp/miniconda.sh -b' }),
+    'linux-arm64': () => ({ url: `https://repo.anaconda.com/miniconda/Miniconda3-latest-${condaAsset['linux-arm64']}.sh`, run: 'curl -fsSL https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-aarch64.sh -o /tmp/miniconda.sh && sh /tmp/miniconda.sh -b' }),
+    'darwin-x64': () => ({ url: `https://repo.anaconda.com/miniconda/Miniconda3-latest-${condaAsset['darwin-x64']}.sh`, run: 'curl -fsSL https://repo.anaconda.com/miniconda/Miniconda3-latest-MacOSX-x86_64.sh -o /tmp/miniconda.sh && sh /tmp/miniconda.sh -b' }),
+    'darwin-arm64': () => ({ url: `https://repo.anaconda.com/miniconda/Miniconda3-latest-${condaAsset['darwin-arm64']}.sh`, run: 'curl -fsSL https://repo.anaconda.com/miniconda/Miniconda3-latest-MacOSX-arm64.sh -o /tmp/miniconda.sh && sh /tmp/miniconda.sh -b' }),
+    'win32-x64': () => ({ url: 'https://repo.anaconda.com/miniconda/Miniconda3-latest-Windows-x86_64.exe', run: 'Start-Process -Wait $env:TEMP\\Miniconda3-latest-Windows-x86_64.exe /S', shell: 'powershell' }),
+  },
+  bun: {
+    'linux-x64': () => ({ url: 'https://bun.sh/install', run: 'curl -fsSL https://bun.sh/install | sh' }),
+    'linux-arm64': () => ({ url: 'https://bun.sh/install', run: 'curl -fsSL https://bun.sh/install | sh' }),
+    'darwin-x64': () => ({ url: 'https://bun.sh/install', run: 'curl -fsSL https://bun.sh/install | sh' }),
+    'darwin-arm64': () => ({ url: 'https://bun.sh/install', run: 'curl -fsSL https://bun.sh/install | sh' }),
+    'win32-x64': () => ({ url: 'https://bun.sh/install.ps1', run: 'powershell -c "irm bun.sh/install.ps1 | iex"', shell: 'powershell' }),
+    'win32-arm64': () => ({ url: 'https://bun.sh/install.ps1', run: 'powershell -c "irm bun.sh/install.ps1 | iex"', shell: 'powershell' }),
+  },
+  gcloud: {
+    'linux-x64': () => ({ url: 'https://sdk.cloud.google.com', run: 'curl -fsSL https://sdk.cloud.google.com | sh' }),
+    'linux-arm64': () => ({ url: 'https://sdk.cloud.google.com', run: 'curl -fsSL https://sdk.cloud.google.com | sh' }),
+    'darwin-x64': () => ({ url: 'https://sdk.cloud.google.com', run: 'curl -fsSL https://sdk.cloud.google.com | sh' }),
+    'darwin-arm64': () => ({ url: 'https://sdk.cloud.google.com', run: 'curl -fsSL https://sdk.cloud.google.com | sh' }),
+    'win32-x64': () => ({ manual: 'install gcloud CLI for Windows: https://cloud.google.com/sdk/docs/install-sdk-for-windows' }),
+    'win32-arm64': () => ({ manual: 'install gcloud CLI for Windows: https://cloud.google.com/sdk/docs/install-sdk-for-windows' }),
+  },
+  'azure-cli': {
+    'linux-x64': () => ({ url: 'https://aka.ms/InstallAzureCli', run: 'curl -fsSL https://aka.ms/InstallAzureCli | sh' }),
+    'linux-arm64': () => ({ url: 'https://aka.ms/InstallAzureCli', run: 'curl -fsSL https://aka.ms/InstallAzureCli | sh' }),
+    'darwin-x64': () => ({ url: 'https://aka.ms/InstallAzureCli', run: 'curl -fsSL https://aka.ms/InstallAzureCli | sh' }),
+    'darwin-arm64': () => ({ url: 'https://aka.ms/InstallAzureCli', run: 'curl -fsSL https://aka.ms/InstallAzureCli | sh' }),
+    'win32-x64': () => ({ manual: 'on Windows install azure-cli via winget: winget install Microsoft.AzureCLI' }),
+    'win32-arm64': () => ({ manual: 'on Windows install azure-cli via winget: winget install Microsoft.AzureCLI' }),
+  },
+  rustup: {
+    'linux-x64': () => ({ url: 'https://sh.rustup.rs', run: 'curl -fsSL https://sh.rustup.rs | sh -s -- -y' }),
+    'linux-arm64': () => ({ url: 'https://sh.rustup.rs', run: 'curl -fsSL https://sh.rustup.rs | sh -s -- -y' }),
+    'darwin-x64': () => ({ url: 'https://sh.rustup.rs', run: 'curl -fsSL https://sh.rustup.rs | sh -s -- -y' }),
+    'darwin-arm64': () => ({ url: 'https://sh.rustup.rs', run: 'curl -fsSL https://sh.rustup.rs | sh -s -- -y' }),
+    'win32-x64': () => ({ url: 'https://win.rustup.rs/x86_64', run: 'iwr -useb https://win.rustup.rs/x86_64 -OutFile rustup-init.exe; ./rustup-init.exe -y', shell: 'powershell' }),
+    'win32-arm64': () => ({ url: 'https://win.rustup.rs/aarch64', run: 'iwr -useb https://win.rustup.rs/aarch64 -OutFile rustup-init.exe; ./rustup-init.exe -y', shell: 'powershell' }),
+  },
+  'oh-my-zsh': {
+    universal: () => ({ url: 'https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh', run: 'sh -c "$(curl -fsSL https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"' }),
+  },
+  helm: {
+    'linux-x64': () => ({ url: 'https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3', run: 'curl -fsSL https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | sh' }),
+    'linux-arm64': () => ({ url: 'https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3', run: 'curl -fsSL https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | sh' }),
+    'darwin-x64': () => ({ url: 'https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3', run: 'curl -fsSL https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | sh' }),
+    'darwin-arm64': () => ({ url: 'https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3', run: 'curl -fsSL https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | sh' }),
+    'win32-x64': () => ({ manual: 'on Windows install helm via winget: winget install Helm.Helm' }),
+    'win32-arm64': () => ({ manual: 'on Windows install helm via winget: winget install Helm.Helm' }),
+  },
+  composer: {
+    'linux-x64': () => ({ url: 'https://getcomposer.org/installer', run: 'curl -fsSL https://getcomposer.org/installer -o /tmp/composer-setup.php && php /tmp/composer-setup.php --install-dir=$HOME/.local/bin --filename=composer' }),
+    'linux-arm64': () => ({ url: 'https://getcomposer.org/installer', run: 'curl -fsSL https://getcomposer.org/installer -o /tmp/composer-setup.php && php /tmp/composer-setup.php --install-dir=$HOME/.local/bin --filename=composer' }),
+    'darwin-x64': () => ({ url: 'https://getcomposer.org/installer', run: 'curl -fsSL https://getcomposer.org/installer -o /tmp/composer-setup.php && php /tmp/composer-setup.php --install-dir=$HOME/.local/bin --filename=composer' }),
+    'darwin-arm64': () => ({ url: 'https://getcomposer.org/installer', run: 'curl -fsSL https://getcomposer.org/installer -o /tmp/composer-setup.php && php /tmp/composer-setup.php --install-dir=$HOME/.local/bin --filename=composer' }),
+    'win32-x64': () => ({ manual: 'install composer via the installer: https://getcomposer.org/doc/00-intro.md#installation-windows' }),
+    'win32-arm64': () => ({ manual: 'install composer via the installer: https://getcomposer.org/doc/00-intro.md#installation-windows' }),
+  },
+  vcpkg: {
+    universal: () => ({ url: 'https://github.com/microsoft/vcpkg', run: 'git clone https://github.com/microsoft/vcpkg $HOME/.adm/vcpkg && $HOME/.adm/vcpkg/bootstrap-vcpkg.sh' }),
+    'win32-x64': () => ({ url: 'https://github.com/microsoft/vcpkg', run: 'git clone https://github.com/microsoft/vcpkg $env:USERPROFILE\\.adm\\vcpkg; & $env:USERPROFILE\\.adm\\vcpkg\\bootstrap-vcpkg.bat', shell: 'powershell' }),
+  },
+  bazel: {
+    'linux-x64': () => ({ url: 'https://github.com/bazelbuild/bazelisk/releases/latest/download/bazelisk-linux-amd64', run: 'mkdir -p $HOME/.local/bin && curl -fsSL https://github.com/bazelbuild/bazelisk/releases/latest/download/bazelisk-linux-amd64 -o $HOME/.local/bin/bazel && chmod +x $HOME/.local/bin/bazel' }),
+    'linux-arm64': () => ({ url: 'https://github.com/bazelbuild/bazelisk/releases/latest/download/bazelisk-linux-arm64', run: 'mkdir -p $HOME/.local/bin && curl -fsSL https://github.com/bazelbuild/bazelisk/releases/latest/download/bazelisk-linux-arm64 -o $HOME/.local/bin/bazel && chmod +x $HOME/.local/bin/bazel' }),
+    'darwin-x64': () => ({ url: 'https://github.com/bazelbuild/bazelisk/releases/latest/download/bazelisk-darwin-amd64', run: 'mkdir -p $HOME/.local/bin && curl -fsSL https://github.com/bazelbuild/bazelisk/releases/latest/download/bazelisk-darwin-amd64 -o $HOME/.local/bin/bazel && chmod +x $HOME/.local/bin/bazel' }),
+    'darwin-arm64': () => ({ url: 'https://github.com/bazelbuild/bazelisk/releases/latest/download/bazelisk-darwin-arm64', run: 'mkdir -p $HOME/.local/bin && curl -fsSL https://github.com/bazelbuild/bazelisk/releases/latest/download/bazelisk-darwin-arm64 -o $HOME/.local/bin/bazel && chmod +x $HOME/.local/bin/bazel' }),
+    'win32-x64': () => ({ manual: 'install bazelisk via choco: choco install bazelisk' }),
+    'win32-arm64': () => ({ manual: 'install bazelisk via choco: choco install bazelisk' }),
+  },
+};
+
+// resolveScript(id, os, arch) → { url, run, shell? } | { manual }
+// Falls back to a "universal" entry (platform-independent script) when the
+// exact os-arch pair has none.
+function resolveScript(id, os, arch) {
+  const table = SCRIPTS[id];
+  if (!table) return { manual: `no script installer known for "${id}" — install manually: https://github.com/CrystalPlatforms/ADM-CLI#manual-tools` };
+  const exact = table[key(os, arch)];
+  if (exact) return exact();
+  if (table.universal) return table.universal();
+  return { manual: `"${id}" has no install script for ${key(os, arch)} — install manually` };
+}
+
+module.exports = { resolveScript, SCRIPTS };

package/src/platform/index.js

@@ -0,0 +1,129 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { parseOsRelease } = require('./os-release');
+const { detectShell, rcFileFor } = require('./shell');
+
+// Maps a distro id (or an id from ID_LIKE) to its default package manager.
+const DISTRO_MANAGERS = {
+  ubuntu: 'apt',
+  debian: 'apt',
+  linuxmint: 'apt',
+  pop: 'apt',
+  neon: 'apt',
+  kali: 'apt',
+  raspbian: 'apt',
+  fedora: 'dnf',
+  rhel: 'dnf',
+  centos: 'dnf',
+  rocky: 'dnf',
+  almalinux: 'dnf',
+  amzn: 'dnf',
+  ol: 'dnf',
+  arch: 'pacman',
+  manjaro: 'pacman',
+  endeavouros: 'pacman',
+  garuda: 'pacman',
+  opensuse: 'zypper',
+  'opensuse-leap': 'zypper',
+  'opensuse-tumbleweed': 'zypper',
+  suse: 'zypper',
+  sles: 'zypper',
+  alpine: 'apk',
+};
+
+// Normalizes process.arch to the supported set (others pass through).
+function normalizeArch(arch) {
+  if (arch === 'x64' || arch === 'ia32') return 'x64';
+  if (arch === 'arm64') return 'arm64';
+  return arch;
+}
+
+function readOsRelease(readFile) {
+  for (const file of ['/etc/os-release', '/usr/lib/os-release']) {
+    try {
+      return readFile(file, 'utf8');
+    } catch {
+      // try next location
+    }
+  }
+  return null;
+}
+
+function isWSL({ platform, env, readFile }) {
+  if (platform !== 'linux') return false;
+  if (env.WSL_DISTRO_NAME || env.WSL_INTEROP) return true;
+  try {
+    return /microsoft/i.test(readFile('/proc/version', 'utf8'));
+  } catch {
+    return false;
+  }
+}
+
+// Resolves the package manager for a linux distro:
+// exact ID first, then any ID_LIKE entry.
+function linuxManager(osReleaseInfo) {
+  if (osReleaseInfo.id && DISTRO_MANAGERS[osReleaseInfo.id]) {
+    return DISTRO_MANAGERS[osReleaseInfo.id];
+  }
+  for (const like of osReleaseInfo.idLike || []) {
+    if (DISTRO_MANAGERS[like]) return DISTRO_MANAGERS[like];
+  }
+  return 'none';
+}
+
+// Detects the full execution environment. All system access is injectable
+// via opts (env/platform/arch/readFile) for deterministic tests.
+//
+// Result shape (frozen — also emitted by `adm config --json`):
+//   os, distro, distroVersion, manager, arch, isWSL, shell, rcFile
+function detectEnvironment(opts = {}) {
+  const platform = opts.platform || process.platform;
+  const env = opts.env || process.env;
+  const readFile = opts.readFile || fs.readFileSync;
+  const arch = normalizeArch(opts.arch || process.arch);
+
+  let distro = null;
+  let distroVersion = null;
+  let manager = 'none';
+
+  if (platform === 'linux') {
+    const info = parseOsRelease(opts.osRelease || readOsRelease(readFile) || '');
+    if (info.id) distro = info.id;
+    distroVersion = info.version;
+    manager = linuxManager(info);
+  } else if (platform === 'darwin') {
+    manager = 'brew';
+  } else if (platform === 'win32') {
+    manager = 'winget';
+  }
+
+  const shell = detectShell({ env, platform, readParentName: opts.readParentName, readPpid: opts.readPpid, ppid: opts.ppid });
+
+  return {
+    os: platform,
+    distro,
+    distroVersion,
+    manager,
+    arch,
+    isWSL: isWSL({ platform, env, readFile }),
+    shell,
+    rcFile: rcFileFor(shell),
+  };
+}
+
+// Text block for `adm config`.
+function formatEnvironment(env) {
+  const osPart = env.distro
+    ? `${env.os} — ${env.distro}${env.distroVersion ? ' ' + env.distroVersion : ''}`
+    : env.os;
+  const lines = [
+    `  OS:        ${osPart}${env.isWSL ? ' (WSL)' : ''}`,
+    `  Arch:      ${env.arch}`,
+    `  Packages:  ${env.manager}`,
+    `  Shell:     ${env.shell}${env.rcFile ? ` (${env.rcFile})` : ''}`,
+  ];
+  return lines.join('\n');
+}
+
+module.exports = { detectEnvironment, formatEnvironment, normalizeArch, DISTRO_MANAGERS };

package/src/platform/os-release.js

@@ -0,0 +1,27 @@
+// Parses /etc/os-release content into { id, version, idLike }.
+// Handles the common formats: KEY=value with optional quotes,
+// comments, blank lines.
+function parseOsRelease(content) {
+  if (!content) return { id: null, version: null, idLike: [] };
+  const fields = {};
+  for (const rawLine of content.split('\n')) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith('#')) continue;
+    const eq = line.indexOf('=');
+    if (eq === -1) continue;
+    const key = line.slice(0, eq).trim();
+    let value = line.slice(eq + 1).trim();
+    if ((value.startsWith('"') && value.endsWith('"')) ||
+        (value.startsWith("'") && value.endsWith("'"))) {
+      value = value.slice(1, -1);
+    }
+    fields[key] = value;
+  }
+  return {
+    id: (fields.ID || '').toLowerCase() || null,
+    version: fields.VERSION_ID || null,
+    idLike: (fields.ID_LIKE || '').toLowerCase().split(/\s+/).filter(Boolean),
+  };
+}
+
+module.exports = { parseOsRelease };

package/src/platform/shell.js

@@ -0,0 +1,111 @@
+const fs = require('fs');
+
+// Map a shell name to the rc file ADM writes PATH entries to (#29 uses this).
+const RC_FILES = {
+  bash: '.bashrc',
+  zsh: '.zshrc',
+  sh: '.profile',
+  ksh: '.kshrc',
+  fish: '.config/fish/config.fish',
+};
+
+function rcFileFor(shellName) {
+  return RC_FILES[shellName] || null;
+}
+
+function basename(p) {
+  return String(p || '').split(/[\\/]/).pop().trim().toLowerCase();
+}
+
+function normalizeShellName(name) {
+  const base = basename(name);
+  if (!base) return null;
+  // Strip version suffixes and login-shell markers: "zsh-5.9" → "zsh"
+  if (base.startsWith('bash')) return 'bash';
+  if (base.startsWith('zsh')) return 'zsh';
+  if (base.startsWith('fish')) return 'fish';
+  if (base.startsWith('ksh')) return 'ksh';
+  if (base === 'sh' || base === 'dash' || base === 'ash') return 'sh';
+  if (base.startsWith('powershell')) return 'powershell';
+  if (base === 'pwsh') return 'pwsh';
+  if (base === 'cmd') return 'cmd';
+  return null;
+}
+
+// Walks up the parent process chain (ppid → parent → grandparent…) and
+// returns the first ancestor whose name is a known shell. `readParentName(pid)`
+// returns the process name for a pid, or null when it can't be read.
+// `readPpid(pid)` returns the parent pid, or null to stop walking.
+function shellFromParentChain(ppid, readParentName, readPpid, maxDepth = 4) {
+  let pid = ppid;
+  for (let depth = 0; depth < maxDepth && pid && pid > 1; depth++) {
+    const shell = normalizeShellName(readParentName(pid));
+    if (shell) return shell;
+    if (!readPpid) break;
+    pid = readPpid(pid);
+    if (pid === null || pid === undefined) break;
+  }
+  return null;
+}
+
+function linuxParentName(pid) {
+  try {
+    return fs.readFileSync(`/proc/${pid}/comm`, 'utf8').trim();
+  } catch {
+    return null;
+  }
+}
+
+function linuxParentPpid(pid) {
+  try {
+    const stat = fs.readFileSync(`/proc/${pid}/stat`, 'utf8');
+    // Field 4 (ppid) sits after the comm field, which may contain spaces and
+    // parens — find the last ')' and parse fields after it.
+    const afterComm = stat.slice(stat.lastIndexOf(')') + 1).trim().split(/\s+/);
+    return parseInt(afterComm[1], 10) || null;
+  } catch {
+    return null;
+  }
+}
+
+function darwinParentName(pid) {
+  try {
+    const { execFileSync } = require('child_process');
+    const out = execFileSync('ps', ['-o', 'comm=', '-p', String(pid)], { encoding: 'utf8' });
+    return out.trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+// Detects the CURRENT shell (the one that launched adm):
+//   1. parent process chain (works even when $SHELL points at the login shell)
+//   2. fallback: $SHELL
+// Windows: git-bash (MSYSTEM) → bash; otherwise powershell/cmd.
+function detectShell(opts = {}) {
+  const env = opts.env || process.env;
+  const platform = opts.platform || process.platform;
+
+  if (platform === 'win32') {
+    if (env.MSYSTEM) return 'bash';
+    if (env.PSModulePath) return 'powershell';
+    return 'cmd';
+  }
+
+  const readParentName = opts.readParentName ||
+    (platform === 'darwin' ? darwinParentName : linuxParentName);
+  const readPpid = opts.readPpid || (platform === 'darwin' ? null : linuxParentPpid);
+
+  const chainShell = shellFromParentChain(
+    opts.ppid || process.ppid,
+    readParentName,
+    readPpid,
+  );
+  if (chainShell) return chainShell;
+
+  const fromEnv = normalizeShellName(env.SHELL);
+  if (fromEnv) return fromEnv;
+  return 'unknown';
+}
+
+module.exports = { detectShell, rcFileFor, normalizeShellName, shellFromParentChain, RC_FILES };