axinstall 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Łukasz Jerciński
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,96 @@
+# axinstall
+
+Install AI CLI agents (Claude Code, Codex, Gemini, etc.) in any environment.
+
+## Quick Start
+
+```bash
+# Install Claude Code globally
+npx axinstall claude
+
+# Install with a specific package manager
+npx axinstall claude --with npm
+
+# Preview what would be installed (dry run)
+npx axinstall claude --dry-run
+
+# List supported agents
+npx axinstall --list-agents
+
+# Check installed agents and available package managers
+npx axinstall --status
+```
+
+## Requirements
+
+axinstall needs at least one supported package manager available:
+
+- npm
+- pnpm
+- bun
+- yarn
+- Homebrew (`brew`)
+
+### Custom Paths
+
+Override the default binary lookup by setting environment variables:
+
+```bash
+export AXINSTALL_NPM_PATH=/path/to/npm
+export AXINSTALL_PNPM_PATH=/path/to/pnpm
+export AXINSTALL_BUN_PATH=/path/to/bun
+export AXINSTALL_YARN_PATH=/path/to/yarn
+export AXINSTALL_BREW_PATH=/path/to/brew
+```
+
+## Examples
+
+### Install agents
+
+```bash
+# Install using auto-detected package manager (pnpm > bun > yarn > npm > brew)
+axinstall claude
+axinstall codex
+axinstall gemini
+
+# Force a specific package manager
+axinstall claude --with npm
+axinstall opencode --with brew
+
+# Install locally (not globally)
+axinstall claude --local
+```
+
+### Pipeline examples
+
+```bash
+# Get list of agent CLI names
+axinstall --list-agents | tail -n +2 | cut -f1
+
+# Find agents from a specific provider
+axinstall --list-agents | tail -n +2 | awk -F'\t' '$4 == "Anthropic" {print $1}'
+
+# Get available installers only
+axinstall --status --only installers | tail -n +2 | awk -F'\t' '$4 == "available" {print $2}'
+
+# Count installed vs not found agents
+axinstall --status --only agents | tail -n +2 | cut -f4 | sort | uniq -c
+```
+
+## Agent Rule
+
+Add to your `CLAUDE.md` or `AGENTS.md`:
+
+```markdown
+# Rule: `axinstall` Usage
+
+Run `npx -y axinstall --help` to learn available options.
+
+Use `axinstall` to install AI CLI agents in any environment. It auto-detects
+the best available package manager (pnpm, bun, yarn, npm, brew) and handles
+the installation with a single command.
+```
+
+## License
+
+MIT

package/bin/axinstall

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+/**
+ * CLI entry point that dynamically imports the compiled TypeScript.
+ *
+ * Uses top-level await to ensure module evaluation errors are handled
+ * properly. Without await, errors during import would surface as unhandled
+ * rejections instead of clean CLI failures with appropriate exit codes.
+ */
+try {
+  await import("../dist/cli.js");
+} catch (error) {
+  console.error(
+    "Failed to start axinstall:",
+    error instanceof Error ? error.message : error,
+  );
+  process.exitCode = 1;
+}

package/dist/cli.d.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+/**
+ * axinstall - AI agent installation CLI.
+ *
+ * Installs CLI agents (Claude Code, Codex, Gemini, etc.) using
+ * the best available package manager in the environment.
+ */
+export {};

package/dist/cli.js

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+/**
+ * axinstall - AI agent installation CLI.
+ *
+ * Installs CLI agents (Claude Code, Codex, Gemini, etc.) using
+ * the best available package manager in the environment.
+ */
+import { Command } from "@commander-js/extra-typings";
+import { AGENT_CLIS } from "axshared";
+import packageJson from "../package.json" with { type: "json" };
+import { getInstaller } from "./installer-data.js";
+import { runCommand } from "./run-command.js";
+import { INSTALLER_IDS } from "./types.js";
+// =============================================================================
+// Signal Handling
+// =============================================================================
+process.on("SIGINT", () => {
+    console.error("\nInstallation cancelled.");
+    process.exit(130); // 128 + SIGINT(2)
+});
+const INSTALLER_NAMES = INSTALLER_IDS.join(", ");
+const INSTALLER_ENV_VARS = INSTALLER_IDS.map((id) => getInstaller(id).envVar).join(", ");
+// =============================================================================
+// CLI Setup
+// =============================================================================
+const program = new Command()
+    .name(packageJson.name)
+    .description(packageJson.description)
+    .version(packageJson.version)
+    .showHelpAfterError("(add --help for additional information)")
+    .showSuggestionAfterError()
+    .option("--list-agents", "List supported agents")
+    .option("--status", "Show installed agents and available package managers")
+    .option("--only <scope>", "Limit --status output (agents|installers). Default: all.")
+    .option("-v, --verbose", "Enable verbose output")
+    .addHelpText("after", `
+Examples:
+  $ axinstall claude                              Install Claude Code
+  $ axinstall claude --with npm                   Use specific package manager
+  $ axinstall claude --dry-run                    Preview installation command
+  $ axinstall --list-agents | tail -n +2 | cut -f1   List agent CLI names
+  $ axinstall --status --only installers | grep available  Show available installers
+
+Environment:
+  AXINSTALL_WITH    Default package manager (${INSTALLER_NAMES})
+
+Requirements:
+  ${INSTALLER_NAMES}
+  Override paths: ${INSTALLER_ENV_VARS}`);
+// =============================================================================
+// Install / List / Status (Default)
+// =============================================================================
+program
+    .argument("[agent]", `Agent to install (${AGENT_CLIS.join(", ")})`)
+    .option("--with <installer>", `Package manager to use (${INSTALLER_IDS.join(", ")})`)
+    .option("--dry-run", "Show command without executing", false)
+    .option("--local", "Install locally instead of globally", false)
+    .action((agentCli, cliOptions) => {
+    runCommand(agentCli, cliOptions);
+});
+// =============================================================================
+// Parse and Execute
+// =============================================================================
+program.parse();

package/dist/detect-agent.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Agent detection logic.
+ *
+ * Detects which AI agents are installed in the current environment.
+ */
+import type { Agent } from "axshared";
+/** Result of checking if an agent is installed */
+interface AgentCheckResult {
+    agent: Agent;
+    installed: boolean;
+    version?: string;
+}
+/**
+ * Check if a single agent is installed by running `<cli> --version`.
+ */
+declare function checkAgent(agent: Agent): AgentCheckResult;
+/**
+ * Check installation status of all agents.
+ */
+declare function checkAllAgents(): AgentCheckResult[];
+/**
+ * Get all installed agents.
+ */
+declare function getInstalledAgents(): Agent[];
+export { checkAgent, checkAllAgents, getInstalledAgents };
+export type { AgentCheckResult };

package/dist/detect-agent.js

@@ -0,0 +1,46 @@
+/**
+ * Agent detection logic.
+ *
+ * Detects which AI agents are installed in the current environment.
+ */
+import { execSync } from "node:child_process";
+import { getAllAgents } from "axshared";
+/**
+ * Check if a single agent is installed by running `<cli> --version`.
+ */
+function checkAgent(agent) {
+    try {
+        const output = execSync(`${agent.cli} --version`, {
+            encoding: "utf8",
+            stdio: ["pipe", "pipe", "pipe"],
+        }).trim();
+        // Extract version from first line
+        const version = output.split("\n")[0]?.trim();
+        return {
+            agent,
+            installed: true,
+            version,
+        };
+    }
+    catch {
+        return {
+            agent,
+            installed: false,
+        };
+    }
+}
+/**
+ * Check installation status of all agents.
+ */
+function checkAllAgents() {
+    return getAllAgents().map((agent) => checkAgent(agent));
+}
+/**
+ * Get all installed agents.
+ */
+function getInstalledAgents() {
+    return checkAllAgents()
+        .filter((result) => result.installed)
+        .map((result) => result.agent);
+}
+export { checkAgent, checkAllAgents, getInstalledAgents };

package/dist/detect-installer.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Installer detection logic.
+ *
+ * Detects which package managers are available in the current environment.
+ */
+import type { Installer, InstallerId, InstallerCheckResult } from "./types.js";
+/**
+ * Check if a single installer is available.
+ */
+declare function checkInstaller(installer: Installer): InstallerCheckResult;
+/**
+ * Check availability of all installers.
+ */
+declare function checkAllInstallers(): InstallerCheckResult[];
+/**
+ * Get all available installers.
+ */
+declare function getAvailableInstallers(): Installer[];
+/**
+ * Auto-detect the best available installer based on priority.
+ *
+ * Priority order: pnpm > bun > yarn > npm > brew
+ */
+declare function detectBestInstaller(): Installer | undefined;
+/**
+ * Check if a specific installer is available.
+ */
+declare function isInstallerAvailable(id: InstallerId): boolean;
+export { checkInstaller, checkAllInstallers, getAvailableInstallers, detectBestInstaller, isInstallerAvailable, };

package/dist/detect-installer.js

@@ -0,0 +1,69 @@
+/**
+ * Installer detection logic.
+ *
+ * Detects which package managers are available in the current environment.
+ */
+import { execFileSync } from "node:child_process";
+import { getAllInstallers, getInstaller, INSTALLER_PRIORITY, } from "./installer-data.js";
+import { resolveInstallerCommand } from "./resolve-installer-command.js";
+/**
+ * Check if a single installer is available.
+ */
+function checkInstaller(installer) {
+    try {
+        const command = resolveInstallerCommand(installer);
+        const output = execFileSync(command, [...installer.checkArgs], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "pipe"],
+        }).trim();
+        // Extract version from first line
+        const version = output.split("\n")[0]?.trim();
+        return {
+            installer,
+            available: true,
+            version,
+        };
+    }
+    catch {
+        return {
+            installer,
+            available: false,
+        };
+    }
+}
+/**
+ * Check availability of all installers.
+ */
+function checkAllInstallers() {
+    return getAllInstallers().map((installer) => checkInstaller(installer));
+}
+/**
+ * Get all available installers.
+ */
+function getAvailableInstallers() {
+    return checkAllInstallers()
+        .filter((result) => result.available)
+        .map((result) => result.installer);
+}
+/**
+ * Auto-detect the best available installer based on priority.
+ *
+ * Priority order: pnpm > bun > yarn > npm > brew
+ */
+function detectBestInstaller() {
+    const available = new Set(getAvailableInstallers().map((installer) => installer.id));
+    for (const id of INSTALLER_PRIORITY) {
+        if (available.has(id)) {
+            return getInstaller(id);
+        }
+    }
+    return undefined;
+}
+/**
+ * Check if a specific installer is available.
+ */
+function isInstallerAvailable(id) {
+    const installer = getInstaller(id);
+    return checkInstaller(installer).available;
+}
+export { checkInstaller, checkAllInstallers, getAvailableInstallers, detectBestInstaller, isInstallerAvailable, };

package/dist/execute-install.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Installation command execution.
+ */
+import type { Agent } from "axshared";
+import type { Installer } from "./types.js";
+interface InstallOptions {
+    agent: Agent;
+    installer: Installer;
+    global: boolean;
+    dryRun: boolean;
+}
+interface InstallResult {
+    ok: true;
+    command: string;
+}
+interface InstallError {
+    ok: false;
+    command: string;
+    error: Error;
+}
+type InstallOutcome = InstallResult | InstallError;
+declare function buildInstallCommand(options: InstallOptions): string;
+/**
+ * Execute the installation command.
+ */
+declare function executeInstall(options: InstallOptions): InstallOutcome;
+export { buildInstallCommand, executeInstall };
+export type { InstallOptions, InstallOutcome };

package/dist/execute-install.js

@@ -0,0 +1,55 @@
+/**
+ * Installation command execution.
+ */
+import { execFileSync } from "node:child_process";
+import { resolveInstallerCommand } from "./resolve-installer-command.js";
+/**
+ * Build the installation arguments for an agent.
+ */
+function buildInstallArguments(options) {
+    const { agent, installer, global: isGlobal } = options;
+    // For brew, use the CLI name as the package name (formula name)
+    // For npm-based installers, use the npm package name
+    const packageName = installer.id === "brew" ? agent.cli : agent.package;
+    const installArguments = isGlobal
+        ? installer.globalInstallArgs
+        : installer.localInstallArgs;
+    return installArguments.map((argument) => argument.replace("{package}", packageName));
+}
+function formatCommand(command, arguments_) {
+    const parts = [command, ...arguments_];
+    return parts
+        .map((part) => (/\s/u.test(part) ? JSON.stringify(part) : part))
+        .join(" ");
+}
+function buildInstallCommand(options) {
+    const command = resolveInstallerCommand(options.installer);
+    const arguments_ = buildInstallArguments(options);
+    return formatCommand(command, arguments_);
+}
+/**
+ * Execute the installation command.
+ */
+function executeInstall(options) {
+    const command = resolveInstallerCommand(options.installer);
+    const arguments_ = buildInstallArguments(options);
+    const displayCommand = formatCommand(command, arguments_);
+    if (options.dryRun) {
+        return { ok: true, command: displayCommand };
+    }
+    try {
+        execFileSync(command, arguments_, {
+            stdio: "inherit",
+            encoding: "utf8",
+        });
+        return { ok: true, command: displayCommand };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            command: displayCommand,
+            error: error instanceof Error ? error : new Error(String(error)),
+        };
+    }
+}
+export { buildInstallCommand, executeInstall };

package/dist/handle-install.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Agent installation handler.
+ */
+interface InstallOptions {
+    with?: string;
+    dryRun: boolean;
+    local: boolean;
+    verbose?: boolean;
+}
+export declare function handleInstall(agentCli: string, options: InstallOptions): void;
+export {};

package/dist/handle-install.js

@@ -0,0 +1,82 @@
+/**
+ * Agent installation handler.
+ */
+import { AGENT_CLIS, getAgent, isValidAgentCli } from "axshared";
+import { detectBestInstaller, isInstallerAvailable, } from "./detect-installer.js";
+import { executeInstall } from "./execute-install.js";
+import { getInstaller } from "./installer-data.js";
+import { resolveInstallerCommand } from "./resolve-installer-command.js";
+import { INSTALLER_IDS } from "./types.js";
+const INSTALLER_ID_SET = new Set(INSTALLER_IDS);
+const INSTALLER_NAMES = INSTALLER_IDS.join(", ");
+const INSTALLER_ENV_VARS = INSTALLER_IDS.map((id) => getInstaller(id).envVar).join(", ");
+function isInstallerId(value) {
+    return INSTALLER_ID_SET.has(value);
+}
+function reportMissingInstaller(installer) {
+    const command = resolveInstallerCommand(installer);
+    console.error(`Error: Installer '${installer.id}' not available`);
+    console.error(`Looked for: ${command}`);
+    console.error(`Install ${installer.name} and try again.`);
+    console.error(`Override path: ${installer.envVar}=/path/to/${installer.command}`);
+    console.error(`Run 'axinstall --status --only installers' to verify availability.`);
+    process.exitCode = 1;
+}
+export function handleInstall(agentCli, options) {
+    if (!isValidAgentCli(agentCli)) {
+        console.error(`Error: Unknown agent '${agentCli}'`);
+        console.error(`Available: ${AGENT_CLIS.join(", ")}`);
+        console.error("Try 'axinstall --help' for usage information.");
+        process.exitCode = 1;
+        return;
+    }
+    const agent = getAgent(agentCli);
+    const requestedInstaller = options.with ?? process.env["AXINSTALL_WITH"];
+    let installer;
+    if (requestedInstaller) {
+        if (!isInstallerId(requestedInstaller)) {
+            console.error(`Error: Unknown installer '${requestedInstaller}'`);
+            console.error(`Available: ${INSTALLER_IDS.join(", ")}`);
+            console.error("Try 'axinstall --help' for usage information.");
+            process.exitCode = 1;
+            return;
+        }
+        installer = getInstaller(requestedInstaller);
+        if (!isInstallerAvailable(requestedInstaller)) {
+            reportMissingInstaller(installer);
+            return;
+        }
+    }
+    else {
+        installer = detectBestInstaller();
+        if (!installer) {
+            console.error("Error: No package manager found");
+            console.error(`Install ${INSTALLER_NAMES} and try again.`);
+            console.error(`Override paths: ${INSTALLER_ENV_VARS}`);
+            console.error("Run 'axinstall --status --only installers' to verify availability.");
+            process.exitCode = 1;
+            return;
+        }
+    }
+    const isGlobal = !options.local;
+    const result = executeInstall({
+        agent,
+        installer,
+        global: isGlobal,
+        dryRun: options.dryRun,
+    });
+    if (options.dryRun) {
+        console.log(result.command);
+        return;
+    }
+    if (result.ok) {
+        if (options.verbose) {
+            console.error(`Successfully installed ${agent.name}.`);
+            console.error(`Run '${agent.cli}' to get started.`);
+        }
+        return;
+    }
+    console.error(`Error: Failed to install ${agent.name}`);
+    console.error(`Command: ${result.command}`);
+    process.exitCode = 1;
+}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * axinstall - AI agent installation library.
+ *
+ * Exports programmatic APIs for installing CLI agents.
+ */
+export { INSTALLER_IDS } from "./types.js";
+export type { Installer, InstallerId, InstallerCheckResult } from "./types.js";
+export { getInstaller, getAllInstallers, INSTALLERS, INSTALLER_PRIORITY, } from "./installer-data.js";
+export { checkInstaller, checkAllInstallers, getAvailableInstallers, detectBestInstaller, isInstallerAvailable, } from "./detect-installer.js";
+export { checkAgent, checkAllAgents, getInstalledAgents, } from "./detect-agent.js";
+export type { AgentCheckResult } from "./detect-agent.js";
+export { buildInstallCommand, executeInstall } from "./execute-install.js";
+export type { InstallOptions, InstallOutcome } from "./execute-install.js";

package/dist/index.js

@@ -0,0 +1,15 @@
+/**
+ * axinstall - AI agent installation library.
+ *
+ * Exports programmatic APIs for installing CLI agents.
+ */
+// Types
+export { INSTALLER_IDS } from "./types.js";
+// Installer data
+export { getInstaller, getAllInstallers, INSTALLERS, INSTALLER_PRIORITY, } from "./installer-data.js";
+// Installer detection
+export { checkInstaller, checkAllInstallers, getAvailableInstallers, detectBestInstaller, isInstallerAvailable, } from "./detect-installer.js";
+// Agent detection
+export { checkAgent, checkAllAgents, getInstalledAgents, } from "./detect-agent.js";
+// Installation
+export { buildInstallCommand, executeInstall } from "./execute-install.js";

package/dist/installer-data.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Installer definitions and metadata.
+ */
+import type { Installer, InstallerId } from "./types.js";
+/** All installers indexed by ID */
+declare const INSTALLERS: Record<InstallerId, Installer>;
+/** Default priority order for auto-detection */
+declare const INSTALLER_PRIORITY: readonly InstallerId[];
+declare function getInstaller(id: InstallerId): Installer;
+declare function getAllInstallers(): Installer[];
+export { getInstaller, getAllInstallers, INSTALLERS, INSTALLER_PRIORITY };

package/dist/installer-data.js

@@ -0,0 +1,71 @@
+/**
+ * Installer definitions and metadata.
+ */
+const npm = {
+    id: "npm",
+    name: "npm",
+    command: "npm",
+    envVar: "AXINSTALL_NPM_PATH",
+    checkArgs: ["--version"],
+    globalInstallArgs: ["install", "-g", "{package}"],
+    localInstallArgs: ["install", "{package}"],
+};
+const pnpm = {
+    id: "pnpm",
+    name: "pnpm",
+    command: "pnpm",
+    envVar: "AXINSTALL_PNPM_PATH",
+    checkArgs: ["--version"],
+    globalInstallArgs: ["add", "-g", "{package}"],
+    localInstallArgs: ["add", "{package}"],
+};
+const bun = {
+    id: "bun",
+    name: "Bun",
+    command: "bun",
+    envVar: "AXINSTALL_BUN_PATH",
+    checkArgs: ["--version"],
+    globalInstallArgs: ["add", "-g", "{package}"],
+    localInstallArgs: ["add", "{package}"],
+};
+const yarn = {
+    id: "yarn",
+    name: "Yarn",
+    command: "yarn",
+    envVar: "AXINSTALL_YARN_PATH",
+    checkArgs: ["--version"],
+    globalInstallArgs: ["global", "add", "{package}"],
+    localInstallArgs: ["add", "{package}"],
+};
+const brew = {
+    id: "brew",
+    name: "Homebrew",
+    command: "brew",
+    envVar: "AXINSTALL_BREW_PATH",
+    checkArgs: ["--version"],
+    globalInstallArgs: ["install", "{package}"],
+    localInstallArgs: ["install", "{package}"],
+};
+/** All installers indexed by ID */
+const INSTALLERS = {
+    npm,
+    pnpm,
+    bun,
+    yarn,
+    brew,
+};
+/** Default priority order for auto-detection */
+const INSTALLER_PRIORITY = [
+    "pnpm",
+    "bun",
+    "yarn",
+    "npm",
+    "brew",
+];
+function getInstaller(id) {
+    return INSTALLERS[id];
+}
+function getAllInstallers() {
+    return Object.values(INSTALLERS);
+}
+export { getInstaller, getAllInstallers, INSTALLERS, INSTALLER_PRIORITY };

package/dist/print-status.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Status and agent listing output.
+ */
+declare const STATUS_SCOPES: readonly ["all", "agents", "installers"];
+type StatusScope = (typeof STATUS_SCOPES)[number];
+export declare function isStatusScope(value: string): value is StatusScope;
+export declare function printSupportedAgents(): void;
+export declare function printStatus(scope: StatusScope): void;
+export {};

package/dist/print-status.js

@@ -0,0 +1,39 @@
+/**
+ * Status and agent listing output.
+ */
+import { getAllAgents } from "axshared";
+import { checkAllAgents } from "./detect-agent.js";
+import { checkAllInstallers } from "./detect-installer.js";
+const STATUS_SCOPES = ["all", "agents", "installers"];
+const STATUS_SCOPE_SET = new Set(STATUS_SCOPES);
+export function isStatusScope(value) {
+    return STATUS_SCOPE_SET.has(value);
+}
+export function printSupportedAgents() {
+    const agents = getAllAgents();
+    console.log("CLI\tNAME\tPACKAGE\tPROVIDER");
+    for (const agent of agents) {
+        console.log(`${agent.cli}\t${agent.name}\t${agent.package}\t${agent.provider}`);
+    }
+}
+export function printStatus(scope) {
+    const includeAgents = scope === "all" || scope === "agents";
+    const includeInstallers = scope === "all" || scope === "installers";
+    console.log("TYPE\tID\tNAME\tSTATUS\tVERSION\tPROVIDER\tPACKAGE");
+    if (includeAgents) {
+        const agentResults = checkAllAgents();
+        for (const result of agentResults) {
+            const status = result.installed ? "installed" : "not_found";
+            const version = result.version ?? "-";
+            console.log(`AGENT\t${result.agent.cli}\t${result.agent.name}\t${status}\t${version}\t${result.agent.provider}\t${result.agent.package}`);
+        }
+    }
+    if (includeInstallers) {
+        const installerResults = checkAllInstallers();
+        for (const result of installerResults) {
+            const status = result.available ? "available" : "not_found";
+            const version = result.version ?? "-";
+            console.log(`INSTALLER\t${result.installer.id}\t${result.installer.name}\t${status}\t${version}\t-\t-`);
+        }
+    }
+}

package/dist/resolve-installer-command.d.ts

@@ -0,0 +1,3 @@
+import type { Installer } from "./types.js";
+declare function resolveInstallerCommand(installer: Installer): string;
+export { resolveInstallerCommand };

package/dist/resolve-installer-command.js

@@ -0,0 +1,5 @@
+function resolveInstallerCommand(installer) {
+    const override = process.env[installer.envVar];
+    return override && override.length > 0 ? override : installer.command;
+}
+export { resolveInstallerCommand };

package/dist/run-command.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Command execution logic for axinstall CLI.
+ */
+export interface CliOptions {
+    listAgents?: boolean;
+    status?: boolean;
+    only?: string;
+    verbose?: boolean;
+    with?: string;
+    dryRun: boolean;
+    local: boolean;
+}
+export declare function runCommand(agentCli: string | undefined, options: CliOptions): void;

package/dist/run-command.js

@@ -0,0 +1,39 @@
+/**
+ * Command execution logic for axinstall CLI.
+ */
+import { handleInstall } from "./handle-install.js";
+import { isStatusScope, printStatus, printSupportedAgents, } from "./print-status.js";
+import { validateOptions } from "./validate-cli-options.js";
+function reportUsageError(message) {
+    console.error(`Error: ${message}`);
+    console.error("Usage: axinstall [options] <agent>");
+    console.error("       axinstall --list-agents");
+    console.error("       axinstall --status [--only <scope>]");
+    console.error("Try 'axinstall --help' for usage information.");
+    process.exitCode = 1;
+}
+export function runCommand(agentCli, options) {
+    const validation = validateOptions(agentCli, options);
+    if (!validation.valid) {
+        reportUsageError(validation.message);
+        return;
+    }
+    if (options.listAgents) {
+        printSupportedAgents();
+        return;
+    }
+    if (options.status) {
+        const scopeInput = options.only?.toLowerCase() ?? "all";
+        if (!isStatusScope(scopeInput)) {
+            reportUsageError(`Invalid --only value '${options.only}'. Use agents or installers.`);
+            return;
+        }
+        printStatus(scopeInput);
+        return;
+    }
+    if (!agentCli) {
+        reportUsageError("Missing required argument 'agent'.");
+        return;
+    }
+    handleInstall(agentCli, options);
+}

package/dist/types.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Type definitions for axinstall.
+ */
+/** Supported package manager identifiers */
+declare const INSTALLER_IDS: readonly ["npm", "pnpm", "bun", "yarn", "brew"];
+type InstallerId = (typeof INSTALLER_IDS)[number];
+/** Package manager metadata */
+interface Installer {
+    id: InstallerId;
+    name: string;
+    /** Executable name used when no env override is set. */
+    command: string;
+    /** Environment variable to override the command path. */
+    envVar: string;
+    /** Args for a version check. */
+    checkArgs: readonly string[];
+    /** Args for global install. Use {package} as placeholder. */
+    globalInstallArgs: readonly string[];
+    /** Args for local install. Use {package} as placeholder. */
+    localInstallArgs: readonly string[];
+}
+/** Result of checking installer availability */
+interface InstallerCheckResult {
+    installer: Installer;
+    available: boolean;
+    version?: string;
+}
+export { INSTALLER_IDS };
+export type { Installer, InstallerId, InstallerCheckResult };

package/dist/types.js

@@ -0,0 +1,6 @@
+/**
+ * Type definitions for axinstall.
+ */
+/** Supported package manager identifiers */
+const INSTALLER_IDS = ["npm", "pnpm", "bun", "yarn", "brew"];
+export { INSTALLER_IDS };

package/dist/validate-cli-options.d.ts

@@ -0,0 +1,14 @@
+/**
+ * CLI option validation.
+ */
+import type { CliOptions } from "./run-command.js";
+type ValidationError = {
+    valid: false;
+    message: string;
+};
+type ValidationSuccess = {
+    valid: true;
+};
+type ValidationResult = ValidationError | ValidationSuccess;
+export declare function validateOptions(agentCli: string | undefined, options: CliOptions): ValidationResult;
+export {};

package/dist/validate-cli-options.js

@@ -0,0 +1,39 @@
+/**
+ * CLI option validation.
+ */
+export function validateOptions(agentCli, options) {
+    if (options.listAgents && options.status) {
+        return {
+            valid: false,
+            message: "Use either --list-agents or --status, not both.",
+        };
+    }
+    if ((options.listAgents || options.status) && agentCli) {
+        return {
+            valid: false,
+            message: "Do not pass an agent when using --list-agents or --status.",
+        };
+    }
+    if ((options.listAgents || options.status) && options.with) {
+        return {
+            valid: false,
+            message: "--with is only valid when installing an agent.",
+        };
+    }
+    if ((options.listAgents || options.status) && options.local) {
+        return {
+            valid: false,
+            message: "--local is only valid when installing an agent.",
+        };
+    }
+    if ((options.listAgents || options.status) && options.dryRun) {
+        return {
+            valid: false,
+            message: "--dry-run is only valid when installing an agent.",
+        };
+    }
+    if (options.only && !options.status) {
+        return { valid: false, message: "--only must be used with --status." };
+    }
+    return { valid: true };
+}

package/package.json

@@ -0,0 +1,95 @@
+{
+  "name": "axinstall",
+  "author": "Łukasz Jerciński",
+  "license": "MIT",
+  "version": "1.0.0",
+  "description": "Universal installer for AI CLI agents with automatic package manager detection",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Jercik/axinstall.git"
+  },
+  "homepage": "https://github.com/Jercik/axinstall#readme",
+  "bugs": {
+    "url": "https://github.com/Jercik/axinstall/issues"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "bin": {
+    "axinstall": "bin/axinstall"
+  },
+  "files": [
+    "bin/",
+    "dist/",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "prepare": "git config core.hooksPath .githooks",
+    "prepublishOnly": "pnpm run rebuild",
+    "build": "tsc -p tsconfig.app.json",
+    "clean": "rm -rf dist *.tsbuildinfo",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "fta": "fta-check",
+    "knip": "knip",
+    "lint": "eslint",
+    "rebuild": "pnpm run clean && pnpm run build",
+    "start": "pnpm -s run rebuild && node bin/axinstall",
+    "test": "vitest run --exclude '**/*.integration.test.ts'",
+    "test:coverage": "vitest run --coverage --exclude '**/*.integration.test.ts'",
+    "test:integration": "vitest run --testTimeout=300000 src/docker-install.integration.test.ts",
+    "test:all": "vitest run --testTimeout=300000",
+    "test:watch": "vitest --exclude '**/*.integration.test.ts'",
+    "typecheck": "tsc -b --noEmit"
+  },
+  "keywords": [
+    "ai",
+    "agent",
+    "cli",
+    "config",
+    "configuration",
+    "claude-code",
+    "codex",
+    "gemini",
+    "opencode",
+    "llm",
+    "automation",
+    "coding-assistant"
+  ],
+  "packageManager": "pnpm@10.26.1",
+  "engines": {
+    "node": ">=22.14.0"
+  },
+  "dependencies": {
+    "@commander-js/extra-typings": "^14.0.0",
+    "axshared": "^1.1.0",
+    "commander": "^14.0.2"
+  },
+  "devDependencies": {
+    "@eslint/compat": "^2.0.0",
+    "@eslint/js": "^9.39.2",
+    "@total-typescript/ts-reset": "^0.6.1",
+    "@types/node": "^25.0.3",
+    "@vitest/coverage-v8": "^4.0.16",
+    "@vitest/eslint-plugin": "^1.5.4",
+    "eslint": "^9.39.2",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-unicorn": "^62.0.0",
+    "fta-check": "^1.5.1",
+    "fta-cli": "^3.0.0",
+    "globals": "^16.5.0",
+    "knip": "^5.76.1",
+    "prettier": "3.7.4",
+    "semantic-release": "^25.0.2",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.50.0",
+    "vitest": "^4.0.16"
+  }
+}