@pify/cli 0.1.2 → 0.2.0

package/dist/cli.js

@@ -4,9 +4,9 @@
 import { parseArgs } from "util";
 
 // src/pi.ts
-import { readFileSync, realpathSync } from "fs";
+import { accessSync as accessSync2, constants as constants2, readFileSync, realpathSync, statSync as statSync2 } from "fs";
 import { homedir } from "os";
-import { join as join2 } from "path";
+import { dirname, join as join2 } from "path";
 
 // src/exec.ts
 import { spawn, spawnSync } from "child_process";
@@ -97,6 +97,17 @@ function runInherit(command, args) {
     child.on("close", (code) => resolve2(code ?? 1));
   });
 }
+function runOfficialInstaller(kind) {
+  const [cmd, argv] = kind === "windows" ? [
+    "powershell",
+    ["-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", "irm https://pi.dev/install.ps1 | iex"]
+  ] : ["sh", ["-c", "curl -fsSL https://pi.dev/install.sh | sh"]];
+  return new Promise((resolve2, reject) => {
+    const child = spawn(cmd, argv, { stdio: "inherit", windowsHide: false });
+    child.on("error", reject);
+    child.on("close", (code) => resolve2(code ?? 1));
+  });
+}
 function which(command) {
   const dirs = (process.env.PATH ?? "").split(delimiter).filter(Boolean);
   if (isWindows) {
@@ -258,38 +269,107 @@ function guardNpmManaged(binPath) {
     );
   }
 }
+function officialInstallerCommand() {
+  return isWindows ? 'powershell -c "irm https://pi.dev/install.ps1 | iex"' : "curl -fsSL https://pi.dev/install.sh | sh";
+}
+function writableOrCreatable(path) {
+  let current = path;
+  for (; ; ) {
+    try {
+      statSync2(current);
+      break;
+    } catch {
+      const parent = dirname(current);
+      if (parent === current) return false;
+      current = parent;
+    }
+  }
+  try {
+    if (!statSync2(current).isDirectory()) return false;
+    accessSync2(current, constants2.W_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function npmInstallPiArgs(spec, npmMajor, prefix) {
+  const args = ["install", "-g", "--ignore-scripts"];
+  if (npmMajor >= 11) args.push("--min-release-age=0");
+  args.push("--no-fund", "--no-audit");
+  if (prefix) args.push("--prefix", prefix);
+  args.push(spec);
+  return args;
+}
+function npmMajorVersion() {
+  const res = runCapture("npm", ["--version"]);
+  const major = Number.parseInt(res.stdout.trim().split(".")[0] ?? "", 10);
+  return Number.isNaN(major) ? 0 : major;
+}
 async function installPi(version) {
   assertNodeVersion();
-  if (!which("npm")) {
-    throw environmentError(
-      "npm was not found on PATH.",
-      "Install Node.js (which bundles npm) from https://nodejs.org and retry."
-    );
-  }
   if (process.env.PI_MANAGED_INSTALL_ROOT && !piStatus().installed) {
     throw environmentError(
       "PI_MANAGED_INSTALL_ROOT is set but pi is not installed.",
-      "Use the managed installer: curl -fsSL https://pi.dev/install.sh | sh (Linux/macOS)."
+      `Use the official installer: ${officialInstallerCommand()}`
     );
   }
   const spec = version ? `${PI_PACKAGE}@${version}` : PI_PACKAGE;
-  step(`npm install -g --ignore-scripts ${spec}`);
-  const code = await runInherit("npm", ["install", "-g", "--ignore-scripts", spec]);
+  const npmPath = which("npm");
+  const bunPath = which("bun");
+  if (!npmPath && !bunPath) {
+    throw environmentError(
+      "Neither npm nor bun was found on PATH.",
+      `Run the official installer (it can install Node too): ${officialInstallerCommand()}`
+    );
+  }
+  let command;
+  let args;
+  let localPrefix = null;
+  if (npmPath) {
+    command = "npm";
+    if (!isWindows) {
+      const prefixRes = runCapture("npm", ["prefix", "-g"]);
+      const prefix = prefixRes.status === 0 ? prefixRes.stdout.trim() : "";
+      const prefixWritable = prefix !== "" && writableOrCreatable(join2(prefix, "lib", "node_modules")) && writableOrCreatable(join2(prefix, "bin"));
+      if (prefix && !prefixWritable) {
+        let staleGlobalPi = false;
+        try {
+          statSync2(join2(prefix, "bin", "pi"));
+          staleGlobalPi = true;
+        } catch {
+        }
+        if (staleGlobalPi) {
+          throw environmentError(
+            `npm's global directory is not writable (${prefix}) and pi is already installed there.`,
+            `Update or remove it first: sudo npm install -g --ignore-scripts ${PI_PACKAGE}`
+          );
+        }
+        localPrefix = join2(homedir(), ".local");
+      }
+    }
+    args = npmInstallPiArgs(spec, npmMajorVersion(), localPrefix ?? void 0);
+  } else {
+    command = "bun";
+    args = ["add", "-g", "--ignore-scripts", spec];
+  }
+  step(`${command} ${args.join(" ")}`);
+  const code = await runInherit(command, args);
   if (code !== 0) {
     throw new PifyError(
-      `npm install -g ${spec} exited with code ${code}.`,
+      `${command} ${args[0]} exited with code ${code}.`,
       ExitCode.SUBPROCESS,
-      isWindows ? "If this is a permissions or file-lock error, close running pi sessions and retry from an elevated terminal." : "If this is an EACCES error, configure a user-writable npm prefix (https://docs.npmjs.com/resolving-eacces-permissions-errors-when-installing-packages-globally) or use a Node version manager."
+      isWindows ? "If this is a permissions or file-lock error, close running pi sessions and retry from an elevated terminal." : `If the problem persists, try the official installer: ${officialInstallerCommand()}`
     );
   }
   const st = piStatus();
   if (!st.installed) {
-    throw environmentError(
-      "pi was installed but is not resolvable on PATH.",
-      "Add npm's global prefix to PATH (npm prefix -g) and open a new terminal."
-    );
+    const pathHint = localPrefix ? `Add ${join2(localPrefix, "bin")} to PATH and open a new terminal.` : "Add the global bin directory to PATH (npm prefix -g) and open a new terminal.";
+    throw environmentError("pi was installed but is not resolvable on PATH.", pathHint);
   }
   success(`pi ${st.version ?? ""} installed.`.replace("  ", " "));
+  if (localPrefix) {
+    hint(`Installed under ${localPrefix} because npm's global prefix is not writable.`);
+  }
 }
 function requirePi() {
   if (!piStatus().installed) {
@@ -349,12 +429,19 @@ function installedVersionOnDisk(name, scope) {
 
 // src/commands/setup.ts
 async function setup(opts) {
-  assertNodeVersion();
-  if (!which("npm")) {
-    throw environmentError(
-      "npm was not found on PATH.",
-      "Install Node.js (which bundles npm) from https://nodejs.org and retry."
-    );
+  if (opts.installer) {
+    if (!process.stdin.isTTY || process.env.CI) {
+      throw environmentError(
+        "The official installer is interactive and needs a terminal.",
+        "In CI, use plain `pify setup` (non-interactive npm path) instead."
+      );
+    }
+    step(officialInstallerCommand());
+    const code = await runOfficialInstaller(isWindows ? "windows" : "posix");
+    if (code !== 0) {
+      throw new PifyError(`The official installer exited with code ${code}.`, ExitCode.SUBPROCESS);
+    }
+    return 0;
   }
   const st = piStatus();
   if (st.installed && !opts.force && !opts.piVersion) {
@@ -381,10 +468,10 @@ async function setup(opts) {
 // src/catalog.ts
 import { readFileSync as readFileSync2, writeFileSync, mkdirSync } from "fs";
 import { homedir as homedir2 } from "os";
-import { dirname, join as join3 } from "path";
+import { dirname as dirname2, join as join3 } from "path";
 import { fileURLToPath } from "url";
 function bundledCatalogPath() {
-  return join3(dirname(fileURLToPath(import.meta.url)), "..", "catalog.json");
+  return join3(dirname2(fileURLToPath(import.meta.url)), "..", "catalog.json");
 }
 function cachePath() {
   return join3(homedir2(), ".pify", "catalog.json");
@@ -459,7 +546,7 @@ function readCache() {
 }
 function writeCache(catalog) {
   try {
-    mkdirSync(dirname(cachePath()), { recursive: true });
+    mkdirSync(dirname2(cachePath()), { recursive: true });
     writeFileSync(cachePath(), JSON.stringify({ fetchedAt: Date.now(), catalog }, null, 2));
   } catch {
   }
@@ -675,12 +762,12 @@ async function update(targets, opts) {
   const updateEverything = targets.length === 0;
   const piOnly = targets.length === 1 && (targets[0] === "pi" || targets[0] === "self");
   const installed = installedPifyPackages();
-  let packageNames = [];
+  let packageNames2 = [];
   if (updateEverything) {
-    packageNames = [...installed.keys()].sort();
+    packageNames2 = [...installed.keys()].sort();
   } else if (!piOnly) {
-    packageNames = targets.map(resolvePifyName);
-    for (const name of packageNames) {
+    packageNames2 = targets.map(resolvePifyName);
+    for (const name of packageNames2) {
       if (!installed.has(name)) {
         throw notFoundError(`${name} is not installed.`, `pify install ${name}`);
       }
@@ -688,7 +775,7 @@ async function update(targets, opts) {
   }
   if (opts.dryRun) {
     if (updateEverything || piOnly) out("pi update");
-    for (const name of packageNames) out(`pi update npm:@pify/${name}`);
+    for (const name of packageNames2) out(`pi update npm:@pify/${name}`);
     if (updateEverything) out("refresh catalog");
     return 0;
   }
@@ -702,20 +789,20 @@ async function update(targets, opts) {
       if (code !== 0) failed.push("pi");
     }
   }
-  if (packageNames.length > 0 && !piStatus().installed) {
+  if (packageNames2.length > 0 && !piStatus().installed) {
     throw new PifyError(
       "pi is required to update packages.",
       ExitCode.ENVIRONMENT,
       "Run pify setup first."
     );
   }
-  for (const name of packageNames) {
+  for (const name of packageNames2) {
     const args = ["update", `npm:@pify/${name}`];
     step(`pi ${args.join(" ")}`);
     const code = await delegate(args);
     if (code !== 0) failed.push(name);
   }
-  if (updateEverything && packageNames.length === 0) {
+  if (updateEverything && packageNames2.length === 0) {
     hint("No @pify packages installed; nothing more to update.");
   }
   if (updateEverything) {
@@ -822,6 +909,14 @@ async function doctor(opts) {
     gitPath ? "ok" : "warn",
     gitPath ?? "git not found - pi's git: package sources will not work"
   );
+  if (isWindows) {
+    const bashPath = which("bash");
+    push(
+      "bash",
+      bashPath ? "ok" : "warn",
+      bashPath ?? "bash not found - pi needs Git Bash on Windows; run pify setup --installer"
+    );
+  }
   const pi = piStatus();
   if (!pi.installed) {
     push("pi", "fail", "not installed - run: pify setup");
@@ -1100,6 +1195,244 @@ async function init(dirArg, opts) {
   return 0;
 }
 
+// src/registry.ts
+var GLOBAL_FLAGS = [
+  { name: "help", short: "h", description: "Show help" },
+  { name: "version", short: "v", description: "Print the pify version" },
+  { name: "no-color", description: "Disable colored output" }
+];
+var COMMAND_SPECS = [
+  {
+    name: "setup",
+    aliases: [],
+    description: "Install the pi coding agent (safe to re-run)",
+    positional: "none",
+    flags: [
+      { name: "force", description: "Reinstall pi even if present" },
+      { name: "pi-version", takesValue: true, description: "Install an exact pi version" },
+      { name: "installer", description: "Run pi's official interactive installer" }
+    ]
+  },
+  {
+    name: "install",
+    aliases: ["i", "add"],
+    description: "Install @pify packages by short name",
+    positional: "packages",
+    flags: [
+      { name: "local", short: "l", description: "Project scope" },
+      { name: "approve", short: "a", description: "Forward --approve to pi" },
+      { name: "dry-run", description: "Print the pi commands without running them" }
+    ]
+  },
+  {
+    name: "remove",
+    aliases: ["rm", "uninstall"],
+    description: "Remove installed @pify packages",
+    positional: "packages",
+    flags: [
+      { name: "local", short: "l", description: "Project scope" },
+      { name: "approve", short: "a", description: "Forward --approve to pi" },
+      { name: "dry-run", description: "Print the pi commands without running them" }
+    ]
+  },
+  {
+    name: "update",
+    aliases: ["up"],
+    description: "Update pi and installed @pify packages",
+    positional: "updateTargets",
+    flags: [
+      { name: "catalog", description: "Refresh the catalog cache only" },
+      { name: "dry-run", description: "Print the update plan without executing" }
+    ]
+  },
+  {
+    name: "list",
+    aliases: ["ls"],
+    description: "Show the @pify catalog with install state",
+    positional: "none",
+    flags: [{ name: "json", description: "Machine-readable output" }]
+  },
+  {
+    name: "doctor",
+    aliases: [],
+    description: "Diagnose the local pi/pify environment",
+    positional: "none",
+    flags: [{ name: "json", description: "Machine-readable output" }]
+  },
+  {
+    name: "init",
+    aliases: [],
+    description: "Scaffold a new Pi Package",
+    positional: "directory",
+    flags: [
+      { name: "name", takesValue: true, description: "npm package name" },
+      { name: "description", takesValue: true, description: "Package description" }
+    ]
+  },
+  {
+    name: "completions",
+    aliases: [],
+    description: "Print a shell completion script",
+    positional: "shell",
+    flags: []
+  }
+];
+var COMPLETION_SHELLS = ["bash", "zsh", "fish", "powershell"];
+function parseArgsOptionsFor(spec) {
+  const options = {};
+  for (const flag of spec.flags) {
+    options[flag.name] = flag.takesValue ? { type: "string", ...flag.short ? { short: flag.short } : {} } : { type: "boolean", default: false, ...flag.short ? { short: flag.short } : {} };
+  }
+  return options;
+}
+
+// src/completions.ts
+function packageNames() {
+  return loadBundledCatalog().packages.map((p) => p.name);
+}
+function allNames(spec) {
+  return [spec.name, ...spec.aliases];
+}
+function flagTokens(spec) {
+  return spec.flags.flatMap((f) => [`--${f.name}`, ...f.short ? [`-${f.short}`] : []]);
+}
+function positionalWords(spec) {
+  switch (spec.positional) {
+    case "packages":
+      return packageNames();
+    case "updateTargets":
+      return ["pi", ...packageNames()];
+    case "shell":
+      return [...COMPLETION_SHELLS];
+    default:
+      return [];
+  }
+}
+function bashScript() {
+  const commands = COMMAND_SPECS.flatMap(allNames).join(" ");
+  const cases = COMMAND_SPECS.map((spec) => {
+    const words = [...positionalWords(spec), ...flagTokens(spec)].join(" ");
+    return `    ${allNames(spec).join("|")}) words="${words}" ;;`;
+  }).join("\n");
+  return `# bash completion for pify \u2014 generated by \`pify completions bash\`
+# Install: eval "$(pify completions bash)"  (or save to a bash-completion dir)
+_pify_completions() {
+  local cur words
+  cur="\${COMP_WORDS[COMP_CWORD]}"
+  if [ "$COMP_CWORD" -eq 1 ]; then
+    COMPREPLY=($(compgen -W "${commands} ${GLOBAL_FLAGS.map((f) => `--${f.name}`).join(" ")}" -- "$cur"))
+    return
+  fi
+  case "\${COMP_WORDS[1]}" in
+${cases}
+    *) words="" ;;
+  esac
+  COMPREPLY=($(compgen -W "$words" -- "$cur"))
+}
+complete -F _pify_completions pify
+`;
+}
+function zshScript() {
+  const commandDescs = COMMAND_SPECS.flatMap(
+    (spec) => allNames(spec).map((n) => `    '${n}:${spec.description.replace(/'/g, "")}'`)
+  ).join("\n");
+  const cases = COMMAND_SPECS.map((spec) => {
+    const words = [...positionalWords(spec), ...flagTokens(spec)].map((w) => `'${w}'`).join(" ");
+    return `    ${allNames(spec).join("|")}) _values 'value' ${words || "''"} ;;`;
+  }).join("\n");
+  return `#compdef pify
+# zsh completion for pify \u2014 generated by \`pify completions zsh\`
+# Install: eval "$(pify completions zsh)"  (or save into a directory on $fpath)
+_pify() {
+  local -a commands
+  commands=(
+${commandDescs}
+  )
+  if (( CURRENT == 2 )); then
+    _describe 'command' commands
+    return
+  fi
+  case "$words[2]" in
+${cases}
+  esac
+}
+_pify "$@"
+`;
+}
+function fishScript() {
+  const lines = [
+    `# fish completion for pify \u2014 generated by \`pify completions fish\``,
+    `# Install: pify completions fish > ~/.config/fish/completions/pify.fish`,
+    `complete -c pify -f`
+  ];
+  for (const spec of COMMAND_SPECS) {
+    for (const name of allNames(spec)) {
+      lines.push(
+        `complete -c pify -n __fish_use_subcommand -a ${name} -d '${spec.description.replace(/'/g, "")}'`
+      );
+    }
+    const condition = `__fish_seen_subcommand_from ${allNames(spec).join(" ")}`;
+    const words = positionalWords(spec);
+    if (words.length > 0) {
+      lines.push(`complete -c pify -n '${condition}' -a '${words.join(" ")}'`);
+    }
+    for (const flag of spec.flags) {
+      const short = flag.short ? ` -s ${flag.short}` : "";
+      lines.push(
+        `complete -c pify -n '${condition}' -l ${flag.name}${short} -d '${flag.description.replace(/'/g, "")}'`
+      );
+    }
+  }
+  for (const flag of GLOBAL_FLAGS) {
+    const short = flag.short ? ` -s ${flag.short}` : "";
+    lines.push(`complete -c pify -l ${flag.name}${short} -d '${flag.description.replace(/'/g, "")}'`);
+  }
+  return `${lines.join("\n")}
+`;
+}
+function powershellScript() {
+  const commands = COMMAND_SPECS.flatMap(allNames);
+  const caseBlocks = COMMAND_SPECS.map((spec) => {
+    const words = [...positionalWords(spec), ...flagTokens(spec)].map((w) => `'${w}'`).join(", ");
+    return `      ${allNames(spec).map((n) => `'${n}'`).join(" ")} { @(${words}) }`;
+  }).join("\n");
+  return `# PowerShell completion for pify \u2014 generated by \`pify completions powershell\`
+# Install: pify completions powershell | Out-String | Invoke-Expression  (add to $PROFILE)
+Register-ArgumentCompleter -Native -CommandName pify -ScriptBlock {
+  param($wordToComplete, $commandAst, $cursorPosition)
+  $tokens = $commandAst.CommandElements | ForEach-Object { $_.ToString() }
+  $candidates = if ($tokens.Count -le 1 -or ($tokens.Count -eq 2 -and $wordToComplete)) {
+    @(${commands.map((c) => `'${c}'`).join(", ")})
+  } else {
+    switch ($tokens[1]) {
+${caseBlocks}
+      default { @() }
+    }
+  }
+  $candidates | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
+    [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
+  }
+}
+`;
+}
+function generateCompletion(shell) {
+  switch (shell) {
+    case "bash":
+      return bashScript();
+    case "zsh":
+      return zshScript();
+    case "fish":
+      return fishScript();
+    case "powershell":
+      return powershellScript();
+    default:
+      throw usageError(
+        `Unknown shell ${JSON.stringify(shell)}.`,
+        `Usage: pify completions <${COMPLETION_SHELLS.join("|")}>`
+      );
+  }
+}
+
 // src/help.ts
 function render(text) {
   return text.split("\n").map((line) => {
@@ -1124,6 +1457,7 @@ Commands:
   list                   Show the @pify catalog with install state
   doctor                 Diagnose the local pi/pify environment
   init [dir]             Scaffold a new Pi Package
+  completions <shell>    Print a completion script (bash|zsh|fish|powershell)
 
 Short forms:
   i = install, rm = remove, up = update, ls = list
@@ -1159,15 +1493,21 @@ settings. Anything beyond these commands is pi's job: run pi --help.
 }
 var COMMAND_HELP = {
   setup: `Usage:
-  pify setup [--force] [--pi-version <version>]
+  pify setup [--force] [--pi-version <version>] [--installer]
 
-Install the pi coding agent globally via npm. Safe to re-run; reports status
-when pi is already installed. Updates of an existing pi are pi's own job:
-run pify update pi.
+Install the pi coding agent. Safe to re-run; reports status when pi is
+already installed. Uses the same npm invocation as pi's official installers
+(--ignore-scripts --min-release-age=0), falls back to bun when npm is
+absent, and to --prefix ~/.local on POSIX when npm's global prefix is not
+writable (never sudo). Updates of an existing pi are pi's own job: run
+pify update pi.
 
 Options:
       --force                Reinstall pi even if it is already installed
       --pi-version <version> Install an exact pi version (may downgrade)
+      --installer            Run pi's official interactive installer for
+                             this OS (can bootstrap Node and Git Bash;
+                             needs a terminal, refuses in CI)
 
 Examples:
   # Bootstrap a bare machine
@@ -1175,6 +1515,9 @@ Examples:
 
   # Pin the version your team has tested
   pify setup --pi-version 0.84.4
+
+  # Full native experience (Windows: install.ps1, Unix: install.sh)
+  pify setup --installer
 `,
   install: `Usage:
   pify install <name...> [-l] [-a] [--dry-run]
@@ -1251,6 +1594,23 @@ Options:
 
 Examples:
   pify doctor
+`,
+  completions: `Usage:
+  pify completions <bash|zsh|fish|powershell>
+
+Print a shell completion script generated from the live command registry \u2014
+command names, aliases, flags, and package names all tab-complete.
+
+Examples:
+  # bash / zsh \u2014 evaluate at shell startup (add to your rc file)
+  eval "$(pify completions bash)"
+  eval "$(pify completions zsh)"
+
+  # fish
+  pify completions fish > ~/.config/fish/completions/pify.fish
+
+  # PowerShell \u2014 add to $PROFILE
+  pify completions powershell | Out-String | Invoke-Expression
 `,
   init: `Usage:
   pify init [dir] [--name <package-name>] [--description <text>]
@@ -1277,85 +1637,40 @@ function commandHelp(command) {
 }
 
 // src/cli.ts
-var COMMANDS = [
-  {
-    name: "setup",
-    aliases: [],
-    options: {
-      force: { type: "boolean", default: false },
-      "pi-version": { type: "string" }
-    },
-    allowPositionals: false,
-    run: (_p, v) => setup({ force: Boolean(v.force), piVersion: v["pi-version"] })
-  },
-  {
-    name: "install",
-    aliases: ["i", "add"],
-    options: {
-      local: { type: "boolean", short: "l", default: false },
-      approve: { type: "boolean", short: "a", default: false },
-      "dry-run": { type: "boolean", default: false }
-    },
-    allowPositionals: true,
-    run: (p, v) => install(p, {
-      local: Boolean(v.local),
-      approve: Boolean(v.approve),
-      dryRun: Boolean(v["dry-run"])
-    })
-  },
-  {
-    name: "remove",
-    aliases: ["rm", "uninstall"],
-    options: {
-      local: { type: "boolean", short: "l", default: false },
-      approve: { type: "boolean", short: "a", default: false },
-      "dry-run": { type: "boolean", default: false }
-    },
-    allowPositionals: true,
-    run: (p, v) => remove(p, {
-      local: Boolean(v.local),
-      approve: Boolean(v.approve),
-      dryRun: Boolean(v["dry-run"])
-    })
-  },
-  {
-    name: "update",
-    aliases: ["up"],
-    options: {
-      catalog: { type: "boolean", default: false },
-      "dry-run": { type: "boolean", default: false }
-    },
-    allowPositionals: true,
-    run: (p, v) => update(p, { catalogOnly: Boolean(v.catalog), dryRun: Boolean(v["dry-run"]) })
-  },
-  {
-    name: "list",
-    aliases: ["ls"],
-    options: { json: { type: "boolean", default: false } },
-    allowPositionals: false,
-    run: (_p, v) => list({ json: Boolean(v.json) })
-  },
-  {
-    name: "doctor",
-    aliases: [],
-    options: { json: { type: "boolean", default: false } },
-    allowPositionals: false,
-    run: (_p, v) => doctor({ json: Boolean(v.json) })
-  },
-  {
-    name: "init",
-    aliases: [],
-    options: {
-      name: { type: "string" },
-      description: { type: "string" }
-    },
-    allowPositionals: true,
-    run: (p, v) => init(p[0], {
-      name: v.name,
-      description: v.description
-    })
+var RUNNERS = {
+  setup: (_p, v) => setup({
+    force: Boolean(v.force),
+    piVersion: v["pi-version"],
+    installer: Boolean(v.installer)
+  }),
+  install: (p, v) => install(p, {
+    local: Boolean(v.local),
+    approve: Boolean(v.approve),
+    dryRun: Boolean(v["dry-run"])
+  }),
+  remove: (p, v) => remove(p, {
+    local: Boolean(v.local),
+    approve: Boolean(v.approve),
+    dryRun: Boolean(v["dry-run"])
+  }),
+  update: (p, v) => update(p, { catalogOnly: Boolean(v.catalog), dryRun: Boolean(v["dry-run"]) }),
+  list: (_p, v) => list({ json: Boolean(v.json) }),
+  doctor: (_p, v) => doctor({ json: Boolean(v.json) }),
+  init: (p, v) => init(p[0], {
+    name: v.name,
+    description: v.description
+  }),
+  completions: async (p) => {
+    if (!p[0]) {
+      throw usageError("Missing shell.", "Usage: pify completions <bash|zsh|fish|powershell>");
+    }
+    out(generateCompletion(p[0]));
+    return 0;
   }
-];
+};
+function findSpec(name) {
+  return COMMAND_SPECS.find((c) => c.name === name || c.aliases.includes(name));
+}
 async function main(argv) {
   const args = argv.filter((a) => a !== "--no-color");
   if (args.length !== argv.length) setColor(false);
@@ -1375,8 +1690,8 @@ async function main(argv) {
   if (first.startsWith("-")) {
     throw usageError(`Unknown option ${first}.`, 'Use "pify --help".');
   }
-  const command = COMMANDS.find((c) => c.name === first || c.aliases.includes(first));
-  if (!command) {
+  const spec = findSpec(first);
+  if (!spec) {
     throw usageError(
       `Unknown command: ${JSON.stringify(first)}`,
       'Run "pify --help" to see available commands.'
@@ -1384,26 +1699,26 @@ async function main(argv) {
   }
   const rest = args.slice(1);
   if (rest.includes("-h") || rest.includes("--help")) {
-    out(commandHelp(command.name));
+    out(commandHelp(spec.name));
     return 0;
   }
   let parsed;
   try {
     parsed = parseArgs({
       args: rest,
-      options: command.options,
-      allowPositionals: command.allowPositionals,
+      options: parseArgsOptionsFor(spec),
+      allowPositionals: spec.positional !== "none",
       strict: true
     });
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     const unknown = /Unknown option '(--?[^']+)'/.exec(message)?.[1];
     throw usageError(
-      unknown ? `Unknown option ${unknown} for "${command.name}".` : message,
-      `Use "pify --help" or "pify ${command.name} --help".`
+      unknown ? `Unknown option ${unknown} for "${spec.name}".` : message,
+      `Use "pify --help" or "pify ${spec.name} --help".`
     );
   }
-  return command.run(parsed.positionals, parsed.values);
+  return RUNNERS[spec.name](parsed.positionals, parsed.values);
 }
 main(process.argv.slice(2)).then((code) => {
   process.exitCode = code;