@shepai/cli 1.20.1 → 1.21.0

package/dist/src/infrastructure/services/tool-installer/tool-installer.service.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Tool Installer Service Implementation
+ *
+ * Provides tool availability checking, installation command resolution,
+ * and installation execution with streaming output and timeout handling.
+ *
+ * Features:
+ * - Check binary availability using 'which' command
+ * - Retrieve platform-specific installation commands
+ * - Execute installations with real-time output streaming
+ * - Automatic timeout handling with process termination
+ * - Immutable status objects via value object factory functions
+ */
+import type { IToolInstallerService } from '../../../application/ports/output/services/tool-installer.service.js';
+import type { ToolInstallationStatus, ToolInstallCommand } from '../../../domain/generated/output.js';
+export declare class ToolInstallerServiceImpl implements IToolInstallerService {
+    /**
+     * Check if a tool binary is available on the system (PATH check)
+     */
+    checkAvailability(toolName: string): Promise<ToolInstallationStatus>;
+    /**
+     * Get the install command metadata for a tool on the current platform.
+     * Returns null if tool is unknown or not supported on current platform.
+     */
+    getInstallCommand(toolName: string): ToolInstallCommand | null;
+    /**
+     * Execute installation of a tool with live output streaming.
+     * Streams stdout/stderr to optional callback and handles timeout automatically.
+     */
+    executeInstall(toolName: string, onOutput?: (data: string) => void): Promise<ToolInstallationStatus>;
+    /**
+     * Create installation suggestions for a tool based on its metadata
+     */
+    private createInstallationSuggestions;
+}
+//# sourceMappingURL=tool-installer.service.d.ts.map

package/dist/src/infrastructure/services/tool-installer/tool-installer.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-installer.service.d.ts","sourceRoot":"","sources":["../../../../../src/infrastructure/services/tool-installer/tool-installer.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAKH,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,sEAAsE,CAAC;AAClH,OAAO,KAAK,EACV,sBAAsB,EACtB,kBAAkB,EAEnB,MAAM,qCAAqC,CAAC;AA6B7C,qBACa,wBAAyB,YAAW,qBAAqB;IACpE;;OAEG;IACG,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,sBAAsB,CAAC;IA8B1E;;;OAGG;IACH,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,kBAAkB,GAAG,IAAI;IAqB9D;;;OAGG;IACG,cAAc,CAClB,QAAQ,EAAE,MAAM,EAChB,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,GAChC,OAAO,CAAC,sBAAsB,CAAC;IAyDlC;;OAEG;IACH,OAAO,CAAC,6BAA6B;CA4BtC"}

package/dist/src/infrastructure/services/tool-installer/tool-installer.service.js

@@ -0,0 +1,179 @@
+/**
+ * Tool Installer Service Implementation
+ *
+ * Provides tool availability checking, installation command resolution,
+ * and installation execution with streaming output and timeout handling.
+ *
+ * Features:
+ * - Check binary availability using 'which' command
+ * - Retrieve platform-specific installation commands
+ * - Execute installations with real-time output streaming
+ * - Automatic timeout handling with process termination
+ * - Immutable status objects via value object factory functions
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { injectable } from 'tsyringe';
+import { execFile, spawn } from 'node:child_process';
+import { platform } from 'node:os';
+import { createAvailableStatus, createMissingStatus, createErrorStatus, } from '../../../domain/value-objects/tool-installation-status.js';
+import { TOOL_METADATA } from './tool-metadata.js';
+/**
+ * Resolve binary name for the current platform.
+ * Supports both simple string binaries and per-platform maps.
+ */
+function resolveBinary(metadata) {
+    if (typeof metadata.binary === 'string')
+        return metadata.binary;
+    return metadata.binary[platform()] ?? Object.values(metadata.binary)[0];
+}
+/**
+ * Check if a binary exists in the system PATH using 'which' command.
+ * Returns both availability status and any error for detailed reporting.
+ */
+const checkBinaryExists = (binary) => {
+    return new Promise((resolve) => {
+        execFile('which', [binary], (err) => {
+            resolve(err ? { found: false, error: err } : { found: true });
+        });
+    });
+};
+let ToolInstallerServiceImpl = class ToolInstallerServiceImpl {
+    /**
+     * Check if a tool binary is available on the system (PATH check)
+     */
+    async checkAvailability(toolName) {
+        const metadata = TOOL_METADATA[toolName];
+        if (!metadata) {
+            return createErrorStatus(toolName, `Unknown tool: ${toolName}`);
+        }
+        try {
+            const result = await checkBinaryExists(resolveBinary(metadata));
+            if (result.found) {
+                return createAvailableStatus(toolName);
+            }
+            // Check if it's just "not found" or another error
+            if (result.error?.message.includes('not found')) {
+                // Binary doesn't exist in PATH - create suggestions for installation
+                const suggestions = this.createInstallationSuggestions(metadata);
+                return createMissingStatus(toolName, suggestions);
+            }
+            // Some other error occurred
+            const errorMessage = result.error?.message ?? 'Unknown error checking availability';
+            return createErrorStatus(toolName, `Failed to check availability: ${errorMessage}`);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return createErrorStatus(toolName, `Failed to check availability: ${errorMessage}`);
+        }
+    }
+    /**
+     * Get the install command metadata for a tool on the current platform.
+     * Returns null if tool is unknown or not supported on current platform.
+     */
+    getInstallCommand(toolName) {
+        const metadata = TOOL_METADATA[toolName];
+        if (!metadata) {
+            return null;
+        }
+        const currentPlatform = platform();
+        const command = metadata.commands[currentPlatform];
+        if (!command) {
+            return null;
+        }
+        return {
+            command,
+            platform: currentPlatform,
+            timeout: metadata.timeout,
+            toolName,
+            packageManager: metadata.packageManager,
+        };
+    }
+    /**
+     * Execute installation of a tool with live output streaming.
+     * Streams stdout/stderr to optional callback and handles timeout automatically.
+     */
+    async executeInstall(toolName, onOutput) {
+        const installCommand = this.getInstallCommand(toolName);
+        if (!installCommand) {
+            return createErrorStatus(toolName, `No installation command available for ${toolName}`);
+        }
+        return new Promise((resolve) => {
+            let output = '';
+            const child = spawn('sh', ['-c', installCommand.command], {
+                shell: false,
+                stdio: ['ignore', 'pipe', 'pipe'],
+            });
+            // Stream output from stdout and stderr
+            const pipeOutput = (stream) => {
+                if (!stream)
+                    return;
+                stream.on('data', (data) => {
+                    const text = data.toString();
+                    output += text;
+                    if (onOutput) {
+                        onOutput(text);
+                    }
+                });
+            };
+            pipeOutput(child.stdout);
+            pipeOutput(child.stderr);
+            // Set up timeout to kill process if it takes too long
+            const timeoutId = setTimeout(() => {
+                child.kill();
+            }, installCommand.timeout);
+            // Handle process completion or error
+            const cleanup = (errorMessage) => {
+                clearTimeout(timeoutId);
+                const returnStatus = errorMessage
+                    ? createErrorStatus(toolName, errorMessage)
+                    : createAvailableStatus(toolName);
+                resolve(returnStatus);
+            };
+            child.on('close', (code) => {
+                if (code === 0) {
+                    cleanup();
+                }
+                else {
+                    cleanup(`Installation failed with exit code ${code}. Output: ${output.slice(0, 200)}`);
+                }
+            });
+            child.on('error', (err) => {
+                cleanup(`Installation error: ${err.message}`);
+            });
+        });
+    }
+    /**
+     * Create installation suggestions for a tool based on its metadata
+     */
+    createInstallationSuggestions(metadata) {
+        const suggestions = [];
+        // Add suggestion for current platform if available
+        const currentPlatform = platform();
+        const command = metadata.commands[currentPlatform];
+        if (command) {
+            suggestions.push({
+                packageManager: metadata.packageManager,
+                command,
+                documentationUrl: metadata.documentationUrl,
+            });
+        }
+        // Add generic suggestion
+        if (!suggestions.length) {
+            suggestions.push({
+                packageManager: metadata.packageManager,
+                command: 'Visit official documentation',
+                documentationUrl: metadata.documentationUrl,
+            });
+        }
+        return suggestions;
+    }
+};
+ToolInstallerServiceImpl = __decorate([
+    injectable()
+], ToolInstallerServiceImpl);
+export { ToolInstallerServiceImpl };

package/dist/src/infrastructure/services/tool-installer/tool-metadata.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Tool Installation Metadata
+ *
+ * Dynamically loads tool definitions from individual JSON files in the tools/ directory.
+ * Each JSON file defines installation commands and metadata for a single development tool.
+ *
+ * To add a new tool, create a JSON file in tools/ matching the ToolMetadata schema:
+ *   tools/<tool-name>.json
+ */
+export interface ToolMetadata {
+    /** Human-readable display name */
+    name: string;
+    /** Short one-line summary */
+    summary: string;
+    /** Detailed description */
+    description: string;
+    /** Tool category for grouping in listings */
+    category: 'ide' | 'cli-agent';
+    /** Binary name to check with 'which' command (string or per-platform map) */
+    binary: string | Record<string, string>;
+    /** Package manager or installation method */
+    packageManager: string;
+    /** Platform-specific installation commands as shell strings (keyed by os.platform()) */
+    commands: Record<string, string>;
+    /** Installation timeout in milliseconds */
+    timeout: number;
+    /** Official documentation URL */
+    documentationUrl: string;
+    /** Command to verify installation (e.g., "code --version") */
+    verifyCommand: string;
+    /** Whether the tool supports automated installation (default: true) */
+    autoInstall?: boolean;
+    /** Command to open a directory in this tool (e.g., "code .") */
+    openDirectory?: string;
+}
+export declare const TOOL_METADATA: Record<string, ToolMetadata>;
+//# sourceMappingURL=tool-metadata.d.ts.map

package/dist/src/infrastructure/services/tool-installer/tool-metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-metadata.d.ts","sourceRoot":"","sources":["../../../../../src/infrastructure/services/tool-installer/tool-metadata.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAMH,MAAM,WAAW,YAAY;IAC3B,kCAAkC;IAClC,IAAI,EAAE,MAAM,CAAC;IAEb,6BAA6B;IAC7B,OAAO,EAAE,MAAM,CAAC;IAEhB,2BAA2B;IAC3B,WAAW,EAAE,MAAM,CAAC;IAEpB,6CAA6C;IAC7C,QAAQ,EAAE,KAAK,GAAG,WAAW,CAAC;IAE9B,6EAA6E;IAC7E,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAExC,6CAA6C;IAC7C,cAAc,EAAE,MAAM,CAAC;IAEvB,wFAAwF;IACxF,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAEjC,2CAA2C;IAC3C,OAAO,EAAE,MAAM,CAAC;IAEhB,iCAAiC;IACjC,gBAAgB,EAAE,MAAM,CAAC;IAEzB,8DAA8D;IAC9D,aAAa,EAAE,MAAM,CAAC;IAEtB,uEAAuE;IACvE,WAAW,CAAC,EAAE,OAAO,CAAC;IAEtB,gEAAgE;IAChE,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AA8CD,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAsB,CAAC"}

package/dist/src/infrastructure/services/tool-installer/tool-metadata.js

@@ -0,0 +1,52 @@
+/**
+ * Tool Installation Metadata
+ *
+ * Dynamically loads tool definitions from individual JSON files in the tools/ directory.
+ * Each JSON file defines installation commands and metadata for a single development tool.
+ *
+ * To add a new tool, create a JSON file in tools/ matching the ToolMetadata schema:
+ *   tools/<tool-name>.json
+ */
+import { readdirSync, readFileSync } from 'node:fs';
+import { join, basename } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const REQUIRED_FIELDS = [
+    'name',
+    'summary',
+    'description',
+    'category',
+    'binary',
+    'packageManager',
+    'commands',
+    'timeout',
+    'documentationUrl',
+    'verifyCommand',
+];
+function loadToolMetadata() {
+    const toolsDir = join(fileURLToPath(import.meta.url), '..', 'tools');
+    const metadata = {};
+    let files;
+    try {
+        files = readdirSync(toolsDir).filter((f) => f.endsWith('.json'));
+    }
+    catch {
+        return metadata;
+    }
+    for (const file of files) {
+        const toolName = basename(file, '.json');
+        try {
+            const raw = readFileSync(join(toolsDir, file), 'utf-8');
+            const parsed = JSON.parse(raw);
+            const missing = REQUIRED_FIELDS.filter((field) => !(field in parsed));
+            if (missing.length > 0) {
+                continue;
+            }
+            metadata[toolName] = parsed;
+        }
+        catch {
+            // Skip malformed JSON files
+        }
+    }
+    return metadata;
+}
+export const TOOL_METADATA = loadToolMetadata();

package/dist/src/infrastructure/services/tool-installer/tools/antigravity.json

@@ -0,0 +1,20 @@
+{
+  "name": "Google Antigravity",
+  "summary": "AI-powered agentic development platform",
+  "description": "Google Antigravity is an AI-powered platform that enables agentic development workflows, helping developers build intelligent applications with autonomous agents.",
+  "category": "ide",
+  "binary": {
+    "linux": "antigravity",
+    "darwin": "agy"
+  },
+  "packageManager": "download",
+  "commands": {
+    "linux": "echo \"Download from https://antigravity.google/download\"",
+    "darwin": "echo \"Download from https://antigravity.google/download\""
+  },
+  "timeout": 300000,
+  "documentationUrl": "https://codelabs.developers.google.com/getting-started-google-antigravity",
+  "verifyCommand": "agy --version",
+  "autoInstall": false,
+  "openDirectory": "agy ."
+}

package/dist/src/infrastructure/services/tool-installer/tools/claude-code.json

@@ -0,0 +1,16 @@
+{
+  "name": "Claude Code",
+  "summary": "AI-powered code assistant from Anthropic",
+  "description": "Claude Code is an AI-powered code assistant from Anthropic that helps you write, understand, and debug code with advanced AI capabilities.",
+  "category": "cli-agent",
+  "binary": "claude",
+  "packageManager": "curl",
+  "commands": {
+    "linux": "curl -fsSL https://claude.ai/install.sh | bash",
+    "darwin": "curl -fsSL https://claude.ai/install.sh | bash"
+  },
+  "timeout": 300000,
+  "documentationUrl": "https://code.claude.com/docs/en/overview",
+  "verifyCommand": "claude --version",
+  "autoInstall": true
+}

package/dist/src/infrastructure/services/tool-installer/tools/cursor-cli.json

@@ -0,0 +1,16 @@
+{
+  "name": "Cursor CLI",
+  "summary": "AI-powered code editor command-line interface",
+  "description": "Cursor CLI provides command-line access to Cursor, an AI-powered code editor designed for efficient AI-assisted development.",
+  "category": "cli-agent",
+  "binary": "cursor",
+  "packageManager": "curl",
+  "commands": {
+    "linux": "curl https://cursor.com/install -fsS | bash",
+    "darwin": "curl https://cursor.com/install -fsS | bash"
+  },
+  "timeout": 300000,
+  "documentationUrl": "https://cursor.com",
+  "verifyCommand": "cursor --version",
+  "autoInstall": true
+}

package/dist/src/infrastructure/services/tool-installer/tools/cursor.json

@@ -0,0 +1,17 @@
+{
+  "name": "Cursor",
+  "summary": "AI-powered code editor for efficient development",
+  "description": "Cursor is an AI-powered code editor built on VS Code, designed to streamline development workflows with advanced AI-assisted coding capabilities.",
+  "category": "ide",
+  "binary": "cursor",
+  "packageManager": "curl",
+  "commands": {
+    "linux": "curl -fsSL https://www.cursor.com/linux/install.sh | sh",
+    "darwin": "curl -fsSL https://www.cursor.com/mac/install.sh | sh"
+  },
+  "timeout": 600000,
+  "documentationUrl": "https://www.cursor.com/docs",
+  "verifyCommand": "cursor --version",
+  "autoInstall": true,
+  "openDirectory": "cursor ."
+}

package/dist/src/infrastructure/services/tool-installer/tools/vscode.json

@@ -0,0 +1,17 @@
+{
+  "name": "Visual Studio Code",
+  "summary": "Lightweight but powerful source code editor",
+  "description": "Microsoft Visual Studio Code is a free, open-source code editor with built-in support for debugging, version control, and extensions for enhanced development workflows.",
+  "category": "ide",
+  "binary": "code",
+  "packageManager": "apt",
+  "commands": {
+    "linux": "sudo apt update && sudo apt install -y code",
+    "darwin": "brew install visual-studio-code"
+  },
+  "timeout": 300000,
+  "documentationUrl": "https://code.visualstudio.com/docs/setup/linux",
+  "verifyCommand": "code --version",
+  "autoInstall": true,
+  "openDirectory": "code ."
+}

package/dist/src/infrastructure/services/tool-installer/tools/windsurf.json

@@ -0,0 +1,17 @@
+{
+  "name": "Windsurf",
+  "summary": "AI-powered code editor by Codeium",
+  "description": "Windsurf is an AI-powered code editor by Codeium that provides intelligent code assistance and automation features for modern development.",
+  "category": "ide",
+  "binary": "windsurf",
+  "packageManager": "apt",
+  "commands": {
+    "linux": "curl -fsSL \"https://windsurf-stable.codeiumdata.com/wVxQEIWkwPUEAGf3/windsurf.gpg\" | sudo gpg --dearmor -o /usr/share/keyrings/windsurf-stable-archive-keyring.gpg && echo \"deb [signed-by=/usr/share/keyrings/windsurf-stable-archive-keyring.gpg arch=amd64] https://windsurf-stable.codeiumdata.com/wVxQEIWkwPUEAGf3/apt stable main\" | sudo tee /etc/apt/sources.list.d/windsurf.list > /dev/null && sudo apt-get update && sudo apt-get install -y windsurf",
+    "darwin": "brew install --cask windsurf"
+  },
+  "timeout": 300000,
+  "documentationUrl": "https://docs.windsurf.com/windsurf/getting-started",
+  "verifyCommand": "windsurf --version",
+  "autoInstall": true,
+  "openDirectory": "windsurf ."
+}

package/dist/src/infrastructure/services/tool-installer/tools/zed.json

@@ -0,0 +1,17 @@
+{
+  "name": "Zed",
+  "summary": "High-performance code editor written in Rust",
+  "description": "Zed is a high-performance code editor written in Rust, designed for speed and collaboration with modern developer workflows.",
+  "category": "ide",
+  "binary": "zed",
+  "packageManager": "curl",
+  "commands": {
+    "linux": "curl -f https://zed.dev/install.sh | sh",
+    "darwin": "curl -f https://zed.dev/install.sh | sh"
+  },
+  "timeout": 300000,
+  "documentationUrl": "https://zed.dev/docs/installation",
+  "verifyCommand": "zed --version",
+  "autoInstall": true,
+  "openDirectory": "zed ."
+}

package/dist/src/presentation/cli/commands/install.command.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Install Command
+ *
+ * Installs a development tool (IDE or CLI agent) on the system.
+ *
+ * Usage:
+ *   shep install <tool>           Install a tool
+ *   shep install <tool> --how     Show installation instructions without executing
+ *
+ * Available tools are loaded dynamically from JSON files in the tools/ directory.
+ */
+import { Command } from 'commander';
+export declare function createInstallCommand(): Command;
+//# sourceMappingURL=install.command.d.ts.map

package/dist/src/presentation/cli/commands/install.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"install.command.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/cli/commands/install.command.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA6BpC,wBAAgB,oBAAoB,IAAI,OAAO,CAuE9C"}

package/dist/src/presentation/cli/commands/install.command.js

@@ -0,0 +1,134 @@
+/**
+ * Install Command
+ *
+ * Installs a development tool (IDE or CLI agent) on the system.
+ *
+ * Usage:
+ *   shep install <tool>           Install a tool
+ *   shep install <tool> --how     Show installation instructions without executing
+ *
+ * Available tools are loaded dynamically from JSON files in the tools/ directory.
+ */
+import { Command } from 'commander';
+import { container } from '../../../infrastructure/di/container.js';
+import { ValidateToolAvailabilityUseCase } from '../../../application/use-cases/tools/validate-tool-availability.use-case.js';
+import { InstallToolUseCase } from '../../../application/use-cases/tools/install-tool.use-case.js';
+import { TOOL_METADATA } from '../../../infrastructure/services/tool-installer/tool-metadata.js';
+import { messages, fmt, colors } from '../ui/index.js';
+function printToolsList() {
+    const tools = Object.entries(TOOL_METADATA);
+    const ides = tools.filter(([, meta]) => meta.category === 'ide');
+    const cliAgents = tools.filter(([, meta]) => meta.category === 'cli-agent');
+    console.log(fmt.heading('IDEs:'));
+    for (const [key, meta] of ides) {
+        console.log(`  ${colors.accent(key.padEnd(16))}${meta.name} - ${colors.muted(meta.summary)}`);
+    }
+    console.log();
+    console.log(fmt.heading('CLI Agents:'));
+    for (const [key, meta] of cliAgents) {
+        console.log(`  ${colors.accent(key.padEnd(16))}${meta.name} - ${colors.muted(meta.summary)}`);
+    }
+    console.log();
+}
+export function createInstallCommand() {
+    return new Command('install')
+        .description('Install a development tool (IDE or CLI agent)')
+        .argument('[tool]', 'Tool to install (vscode, cursor, windsurf, zed, antigravity, cursor-cli, claude-code)')
+        .option('--how', 'Show installation instructions without executing')
+        .action(async (tool, options) => {
+        try {
+            // No tool specified — show available tools
+            if (!tool) {
+                console.log();
+                console.log(`Run ${fmt.code('shep install <tool>')} with one of these options:`);
+                console.log();
+                printToolsList();
+                return;
+            }
+            // Validate tool name
+            const metadata = TOOL_METADATA[tool];
+            if (!metadata) {
+                console.log();
+                console.log(`Hmm, I don't recognize '${tool}'. Did you mean one of these?`);
+                console.log();
+                printToolsList();
+                process.exitCode = 1;
+                return;
+            }
+            if (options.how) {
+                // Print installation instructions without executing
+                printInstallInstructions(metadata);
+                return;
+            }
+            // Check availability first
+            const validateUseCase = container.resolve(ValidateToolAvailabilityUseCase);
+            const status = await validateUseCase.execute(tool);
+            if (status.status === 'available') {
+                messages.success(`${tool} is already installed`);
+                return;
+            }
+            // Tools that don't support auto-install — show instructions instead
+            if (metadata.autoInstall === false) {
+                messages.warning(`${tool} does not support automated installation`);
+                printInstallInstructions(metadata);
+                return;
+            }
+            // Install
+            const installUseCase = container.resolve(InstallToolUseCase);
+            const result = await installUseCase.execute(tool, (data) => process.stdout.write(data));
+            if (result.status === 'available') {
+                messages.success(`${tool} installed successfully`);
+            }
+            else {
+                messages.error(`Failed to install ${tool}: ${result.errorMessage ?? 'Unknown error'}`, new Error(result.errorMessage ?? 'Installation failed'));
+                process.exitCode = 1;
+            }
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            messages.error(`Failed to install ${tool}`, err);
+            process.exitCode = 1;
+        }
+    });
+}
+/**
+ * Print installation instructions for a tool
+ */
+function printInstallInstructions(metadata) {
+    console.log();
+    console.log(fmt.heading(`Installation Instructions for ${metadata.name}`));
+    console.log();
+    console.log(`${fmt.label('Name:')} ${metadata.name}`);
+    console.log(`${fmt.label('Summary:')} ${metadata.summary}`);
+    console.log(`${fmt.label('Description:')} ${metadata.description}`);
+    console.log(`${fmt.label('Category:')} ${metadata.category}`);
+    console.log();
+    const binaryDisplay = typeof metadata.binary === 'string'
+        ? metadata.binary
+        : Object.entries(metadata.binary)
+            .map(([platform, bin]) => `${bin} (${platform})`)
+            .join(', ');
+    console.log(`${fmt.label('Binary:')} ${binaryDisplay}`);
+    console.log(`${fmt.label('Package Manager:')} ${metadata.packageManager}`);
+    console.log();
+    // Print platform-specific commands
+    console.log(fmt.heading('Installation Commands'));
+    for (const [platform, command] of Object.entries(metadata.commands)) {
+        console.log(`${colors.muted(`[${platform}]`)} ${command}`);
+    }
+    console.log();
+    // Print verify command
+    console.log(fmt.heading('Verify Installation'));
+    console.log(`${colors.muted('$')} ${metadata.verifyCommand}`);
+    console.log();
+    // Print open directory command if available
+    if (metadata.openDirectory) {
+        console.log(fmt.heading('Open Directory'));
+        console.log(`${colors.muted('$')} ${metadata.openDirectory}`);
+        console.log();
+    }
+    // Print documentation link
+    console.log(fmt.heading('Documentation'));
+    console.log(`${colors.muted('→')} ${metadata.documentationUrl}`);
+    console.log();
+}

package/dist/src/presentation/cli/index.js

@@ -31,6 +31,7 @@ import { createRunCommand } from './commands/run.command.js';
 import { createAgentCommand } from './commands/agent/index.js';
 import { createFeatCommand } from './commands/feat/index.js';
 import { createIdeOpenCommand } from './commands/ide-open.command.js';
+import { createInstallCommand } from './commands/install.command.js';
 import { messages } from './ui/index.js';
 // DI container and settings
 import { initializeContainer, container } from '../../infrastructure/di/container.js';
@@ -80,6 +81,7 @@ async function bootstrap() {
         program.addCommand(createAgentCommand());
         program.addCommand(createFeatCommand());
         program.addCommand(createIdeOpenCommand());
+        program.addCommand(createInstallCommand());
         // Parse arguments (parseAsync needed for async command actions like init)
         await program.parseAsync();
     }

package/dist/src/presentation/cli/ui/index.d.ts

@@ -15,6 +15,7 @@ export { colors, type Colors } from './colors.js';
 export { symbols, type Symbols } from './symbols.js';
 export { fmt, type Formatters } from './formatters.js';
 export { messages, type Messages } from './messages.js';
+export { installMessages } from './install-messages.js';
 export { TableFormatter, type DatabaseMeta } from './tables.js';
 export { OutputFormatter, type OutputFormat } from './output.js';
 export { renderDetailView, type DetailViewConfig, type DetailSection, type DetailField, type DetailTextBlock, } from './detail-view.js';

package/dist/src/presentation/cli/ui/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/cli/ui/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,MAAM,EAAE,KAAK,MAAM,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,EAAE,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,EAAE,GAAG,EAAE,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,EAAE,QAAQ,EAAE,KAAK,QAAQ,EAAE,MAAM,eAAe,CAAC;AACxD,OAAO,EAAE,cAAc,EAAE,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC;AAChE,OAAO,EAAE,eAAe,EAAE,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC;AACjE,OAAO,EACL,gBAAgB,EAChB,KAAK,gBAAgB,EACrB,KAAK,aAAa,EAClB,KAAK,WAAW,EAChB,KAAK,eAAe,GACrB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,cAAc,EAAE,KAAK,cAAc,EAAE,KAAK,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACtF,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/cli/ui/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,MAAM,EAAE,KAAK,MAAM,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,EAAE,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,EAAE,GAAG,EAAE,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,EAAE,QAAQ,EAAE,KAAK,QAAQ,EAAE,MAAM,eAAe,CAAC;AACxD,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,EAAE,cAAc,EAAE,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC;AAChE,OAAO,EAAE,eAAe,EAAE,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC;AACjE,OAAO,EACL,gBAAgB,EAChB,KAAK,gBAAgB,EACrB,KAAK,aAAa,EAClB,KAAK,WAAW,EAChB,KAAK,eAAe,GACrB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,cAAc,EAAE,KAAK,cAAc,EAAE,KAAK,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACtF,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC"}

package/dist/src/presentation/cli/ui/index.js

@@ -15,6 +15,7 @@ export { colors } from './colors.js';
 export { symbols } from './symbols.js';
 export { fmt } from './formatters.js';
 export { messages } from './messages.js';
+export { installMessages } from './install-messages.js';
 export { TableFormatter } from './tables.js';
 export { OutputFormatter } from './output.js';
 export { renderDetailView, } from './detail-view.js';