@sylphx/flow 2.0.0 → 2.1.1

package/src/services/target-installer.ts

@@ -0,0 +1,254 @@
+/**
+ * Target Installation Service
+ * Auto-detects and installs AI CLI tools (Claude Code, OpenCode, Cursor)
+ */
+
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+import chalk from 'chalk';
+import ora from 'ora';
+import inquirer from 'inquirer';
+import { detectPackageManager, type PackageManager } from '../utils/package-manager-detector.js';
+import { UserCancelledError } from '../utils/errors.js';
+
+const execAsync = promisify(exec);
+
+export interface TargetInstallation {
+  id: 'claude-code' | 'opencode' | 'cursor';
+  name: string;
+  package: string;
+  checkCommand: string;
+  installCommand: (pm: PackageManager) => string;
+}
+
+/**
+ * Supported target installations
+ */
+const TARGET_INSTALLATIONS: TargetInstallation[] = [
+  {
+    id: 'claude-code',
+    name: 'Claude Code',
+    package: '@anthropic-ai/claude-code',
+    checkCommand: 'claude --version',
+    installCommand: (pm: PackageManager) => {
+      switch (pm) {
+        case 'npm':
+          return 'npm install -g @anthropic-ai/claude-code';
+        case 'bun':
+          return 'bun install -g @anthropic-ai/claude-code';
+        case 'pnpm':
+          return 'pnpm install -g @anthropic-ai/claude-code';
+        case 'yarn':
+          return 'yarn global add @anthropic-ai/claude-code';
+      }
+    },
+  },
+  {
+    id: 'opencode',
+    name: 'OpenCode',
+    package: 'opencode-ai',
+    checkCommand: 'opencode --version',
+    installCommand: (pm: PackageManager) => {
+      switch (pm) {
+        case 'npm':
+          return 'npm install -g opencode-ai@latest';
+        case 'bun':
+          return 'bun install -g opencode-ai@latest';
+        case 'pnpm':
+          return 'pnpm install -g opencode-ai@latest';
+        case 'yarn':
+          return 'yarn global add opencode-ai@latest';
+      }
+    },
+  },
+  {
+    id: 'cursor',
+    name: 'Cursor',
+    package: 'cursor',
+    checkCommand: 'cursor --version',
+    installCommand: () => {
+      // Cursor is typically installed via installer, not npm
+      return 'Visit https://cursor.sh to download and install';
+    },
+  },
+];
+
+export class TargetInstaller {
+  private packageManager: PackageManager;
+
+  constructor(projectPath: string = process.cwd()) {
+    this.packageManager = detectPackageManager(projectPath);
+  }
+
+  /**
+   * Check if a target CLI is installed
+   * @param targetId - Target ID to check
+   * @returns True if installed, false otherwise
+   */
+  async isInstalled(targetId: string): Promise<boolean> {
+    const installation = TARGET_INSTALLATIONS.find((t) => t.id === targetId);
+    if (!installation) {
+      return false;
+    }
+
+    try {
+      await execAsync(installation.checkCommand);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Detect which target CLIs are currently installed
+   * @returns Array of installed target IDs
+   */
+  async detectInstalledTargets(): Promise<string[]> {
+    const installed: string[] = [];
+
+    for (const installation of TARGET_INSTALLATIONS) {
+      if (await this.isInstalled(installation.id)) {
+        installed.push(installation.id);
+      }
+    }
+
+    return installed;
+  }
+
+  /**
+   * Prompt user to select a target to install
+   * @returns Selected target ID
+   * @throws {UserCancelledError} If user cancels the prompt
+   */
+  async promptForTargetSelection(): Promise<string> {
+    try {
+      const { targetId } = await inquirer.prompt([
+        {
+          type: 'list',
+          name: 'targetId',
+          message: 'No AI CLI detected. Which would you like to use?',
+          choices: TARGET_INSTALLATIONS.map((t) => ({
+            name: t.name,
+            value: t.id,
+          })),
+          default: 'claude-code',
+        },
+      ]);
+
+      return targetId;
+    } catch (error: any) {
+      // Handle user cancellation (Ctrl+C)
+      if (error.name === 'ExitPromptError' || error.message?.includes('force closed')) {
+        throw new UserCancelledError('Target selection cancelled');
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Install a target CLI using detected package manager
+   * @param targetId - Target ID to install
+   * @param autoConfirm - Skip confirmation prompt if true
+   * @returns True if installation successful, false otherwise
+   * @throws {UserCancelledError} If user cancels installation
+   */
+  async install(targetId: string, autoConfirm: boolean = false): Promise<boolean> {
+    const installation = TARGET_INSTALLATIONS.find((t) => t.id === targetId);
+    if (!installation) {
+      console.log(chalk.red(`✗ Unknown target: ${targetId}`));
+      return false;
+    }
+
+    // Special handling for Cursor (not npm-installable)
+    if (targetId === 'cursor') {
+      console.log(chalk.yellow('\n⚠️  Cursor requires manual installation'));
+      console.log(chalk.cyan('   Visit https://cursor.sh to download and install\n'));
+      return false;
+    }
+
+    // Confirm installation unless auto-confirm is enabled
+    if (!autoConfirm) {
+      try {
+        const { confirmInstall } = await inquirer.prompt([
+          {
+            type: 'confirm',
+            name: 'confirmInstall',
+            message: `Install ${installation.name}?`,
+            default: true,
+          },
+        ]);
+
+        if (!confirmInstall) {
+          console.log(chalk.yellow('\n⚠️  Installation cancelled\n'));
+          return false;
+        }
+      } catch (error: any) {
+        // Handle user cancellation (Ctrl+C)
+        if (error.name === 'ExitPromptError' || error.message?.includes('force closed')) {
+          throw new UserCancelledError('Installation cancelled');
+        }
+        throw error;
+      }
+    }
+
+    const spinner = ora(`Installing ${installation.name}...`).start();
+
+    try {
+      const installCmd = installation.installCommand(this.packageManager);
+      await execAsync(installCmd);
+
+      spinner.succeed(chalk.green(`✓ ${installation.name} installed successfully`));
+      return true;
+    } catch (error) {
+      spinner.fail(chalk.red(`✗ Failed to install ${installation.name}`));
+
+      const installCmd = installation.installCommand(this.packageManager);
+      console.log(chalk.yellow('\n⚠️  Auto-install failed. Please run manually:'));
+      console.log(chalk.cyan(`   ${installCmd}\n`));
+
+      return false;
+    }
+  }
+
+  /**
+   * Auto-detect installed targets or prompt to install one
+   * @returns Target ID if found or installed, null if installation failed
+   * @throws {UserCancelledError} If user cancels selection or installation
+   */
+  async autoDetectAndInstall(): Promise<string | null> {
+    console.log(chalk.cyan('🔍 Detecting installed AI CLIs...\n'));
+
+    const installedTargets = await this.detectInstalledTargets();
+
+    // If we found installed targets, return the first one (priority order)
+    if (installedTargets.length > 0) {
+      const targetId = installedTargets[0];
+      const installation = TARGET_INSTALLATIONS.find((t) => t.id === targetId);
+      console.log(chalk.green(`✓ Found ${installation?.name}\n`));
+      return targetId;
+    }
+
+    // No targets found - prompt user to select one
+    console.log(chalk.yellow('⚠️  No AI CLI detected\n'));
+    const selectedTargetId = await this.promptForTargetSelection();
+
+    // Try to install the selected target
+    console.log();
+    const installed = await this.install(selectedTargetId, false);
+
+    if (!installed) {
+      return null;
+    }
+
+    return selectedTargetId;
+  }
+
+  /**
+   * Get installation metadata for a target
+   * @param targetId - Target ID to get info for
+   * @returns Installation info or undefined if target not found
+   */
+  getInstallationInfo(targetId: string): TargetInstallation | undefined {
+    return TARGET_INSTALLATIONS.find((t) => t.id === targetId);
+  }
+}

package/src/targets/claude-code.ts

@@ -3,8 +3,8 @@ import fs from 'node:fs';
 import fsPromises from 'node:fs/promises';
 import path from 'node:path';
 import chalk from 'chalk';
-import { FileInstaller } from '../core/installers/file-installer.js';
-import { MCPInstaller } from '../core/installers/mcp-installer.js';
+import { installToDirectory } from '../core/installers/file-installer.js';
+import { createMCPInstaller } from '../core/installers/mcp-installer.js';
 import type { AgentMetadata } from '../types/target-config.types.js';
 import type { CommonOptions, MCPServerConfigUnion, SetupResult, Target } from '../types.js';
 import { CLIError } from '../utils/error-handler.js';
@@ -432,10 +432,9 @@ Please begin your response with a comprehensive summary of all the instructions
    */
   async setupAgents(cwd: string, options: CommonOptions): Promise<SetupResult> {
     const { enhanceAgentContent } = await import('../utils/agent-enhancer.js');
-    const installer = new FileInstaller();
     const agentsDir = path.join(cwd, this.config.agentDir);
 
-    const results = await installer.installToDirectory(
+    const results = await installToDirectory(
       getAgentsDir(),
       agentsDir,
       async (content, sourcePath) => {
@@ -491,7 +490,7 @@ Please begin your response with a comprehensive summary of all the instructions
    * Select, configure, install, and approve MCP servers
    */
   async setupMCP(cwd: string, options: CommonOptions): Promise<SetupResult> {
-    const installer = new MCPInstaller(this);
+    const installer = createMCPInstaller(this);
     const result = await installer.setupMCP({ ...options, quiet: true });
 
     // Approve servers in Claude Code settings
@@ -513,10 +512,9 @@ Please begin your response with a comprehensive summary of all the instructions
       return { count: 0 };
     }
 
-    const installer = new FileInstaller();
     const slashCommandsDir = path.join(cwd, this.config.slashCommandsDir);
 
-    const results = await installer.installToDirectory(
+    const results = await installToDirectory(
       getSlashCommandsDir(),
       slashCommandsDir,
       async (content) => {

package/src/targets/opencode.ts

@@ -3,8 +3,8 @@ import path from 'node:path';
 import chalk from 'chalk';
 import { getRulesPath, ruleFileExists } from '../config/rules.js';
 import { MCP_SERVER_REGISTRY } from '../config/servers.js';
-import { FileInstaller } from '../core/installers/file-installer.js';
-import { MCPInstaller } from '../core/installers/mcp-installer.js';
+import { installToDirectory, installFile } from '../core/installers/file-installer.js';
+import { createMCPInstaller } from '../core/installers/mcp-installer.js';
 import type { AgentMetadata } from '../types/target-config.types.js';
 import type { CommonOptions, MCPServerConfigUnion, SetupResult, Target } from '../types.js';
 import { getAgentsDir, getOutputStylesDir, getSlashCommandsDir } from '../utils/config/paths.js';
@@ -232,19 +232,9 @@ export const opencodeTarget: Target = {
    * Install agents to .opencode/agent/ directory
    */
   async setupAgents(cwd: string, options: CommonOptions): Promise<SetupResult> {
-    // Clean up old 'commands' directory if it exists (migration from old structure)
-    // This ensures OpenCode won't crash with ConfigDirectoryTypoError
-    const oldCommandsDir = path.join(cwd, '.opencode/commands');
-    try {
-      await fs.rm(oldCommandsDir, { recursive: true, force: true });
-    } catch {
-      // Ignore if doesn't exist
-    }
-
-    const installer = new FileInstaller();
     const agentsDir = path.join(cwd, this.config.agentDir);
 
-    const results = await installer.installToDirectory(
+    const results = await installToDirectory(
       getAgentsDir(),
       agentsDir,
       async (content, sourcePath) => {
@@ -336,11 +326,10 @@ export const opencodeTarget: Target = {
       throw new Error('Core rules file not found');
     }
 
-    const installer = new FileInstaller();
     const rulesDestPath = path.join(cwd, this.config.rulesFile);
     const rulePath = getRulesPath('core');
 
-    await installer.installFile(
+    await installFile(
       rulePath,
       rulesDestPath,
       async (content) => {
@@ -371,7 +360,7 @@ export const opencodeTarget: Target = {
     }
 
     // Install MCP servers
-    const installer = new MCPInstaller(this);
+    const installer = createMCPInstaller(this);
     const result = await installer.setupMCP({ ...options, quiet: true });
 
     return { count: result.selectedServers.length };
@@ -386,18 +375,9 @@ export const opencodeTarget: Target = {
       return { count: 0 };
     }
 
-    // Clean up old 'commands' directory if it exists (migration from old structure)
-    const oldCommandsDir = path.join(cwd, '.opencode/commands');
-    try {
-      await fs.rm(oldCommandsDir, { recursive: true, force: true });
-    } catch {
-      // Ignore if doesn't exist
-    }
-
-    const installer = new FileInstaller();
     const slashCommandsDir = path.join(cwd, this.config.slashCommandsDir);
 
-    const results = await installer.installToDirectory(
+    const results = await installToDirectory(
       getSlashCommandsDir(),
       slashCommandsDir,
       async (content) => {

package/src/utils/prompt-helpers.ts

@@ -0,0 +1,48 @@
+/**
+ * Prompt Helpers
+ * Utilities for handling user prompts and error handling
+ */
+
+import { UserCancelledError } from './errors.js';
+
+/**
+ * Check if error is a user cancellation (Ctrl+C or force closed)
+ * @param error - Error to check
+ * @returns True if error represents user cancellation
+ */
+export function isUserCancellation(error: any): boolean {
+  return error?.name === 'ExitPromptError' || error?.message?.includes('force closed');
+}
+
+/**
+ * Handle inquirer prompt errors with consistent error handling
+ * Throws UserCancelledError for user cancellations, re-throws other errors
+ * @param error - Error from inquirer prompt
+ * @param message - Custom cancellation message
+ * @throws {UserCancelledError} If user cancelled the prompt
+ * @throws Original error if not a cancellation
+ */
+export function handlePromptError(error: any, message: string): never {
+  if (isUserCancellation(error)) {
+    throw new UserCancelledError(message);
+  }
+  throw error;
+}
+
+/**
+ * Wrap an inquirer prompt with consistent error handling
+ * @param promptFn - Function that returns a promise from inquirer
+ * @param errorMessage - Message to use if user cancels
+ * @returns Promise with the prompt result
+ * @throws {UserCancelledError} If user cancels the prompt
+ */
+export async function withPromptErrorHandling<T>(
+  promptFn: () => Promise<T>,
+  errorMessage: string
+): Promise<T> {
+  try {
+    return await promptFn();
+  } catch (error) {
+    handlePromptError(error, errorMessage);
+  }
+}

package/src/utils/target-selection.ts

@@ -0,0 +1,169 @@
+/**
+ * Target Selection Utilities
+ * Shared logic for target selection UI across settings and execution flows
+ */
+
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { TargetInstaller } from '../services/target-installer.js';
+import { handlePromptError } from './prompt-helpers.js';
+
+/**
+ * Represents a target CLI choice with installation status
+ */
+export interface TargetChoice {
+  /** Display name of the target */
+  name: string;
+  /** Target identifier */
+  value: 'claude-code' | 'opencode' | 'cursor';
+  /** Whether the target is currently installed */
+  installed: boolean;
+}
+
+/**
+ * Build list of available targets with installation status
+ * @param installedTargets - List of currently installed target IDs
+ * @returns Array of target choices with installation status
+ */
+export function buildAvailableTargets(installedTargets: string[]): TargetChoice[] {
+  return [
+    {
+      name: 'Claude Code',
+      value: 'claude-code',
+      installed: installedTargets.includes('claude-code'),
+    },
+    {
+      name: 'OpenCode',
+      value: 'opencode',
+      installed: installedTargets.includes('opencode'),
+    },
+    {
+      name: 'Cursor',
+      value: 'cursor',
+      installed: installedTargets.includes('cursor'),
+    },
+  ];
+}
+
+/**
+ * Format target choice for display in prompts
+ * @param target - Target choice to format
+ * @param context - Context where choice is displayed (affects status message)
+ * @returns Formatted string with target name and installation status
+ */
+export function formatTargetChoice(target: TargetChoice, context: 'execution' | 'settings'): string {
+  const status = target.installed
+    ? chalk.green(' ✓ installed')
+    : context === 'execution'
+      ? chalk.dim(' (will auto-install)')
+      : chalk.dim(' (not installed - will auto-install on first use)');
+
+  return `${target.name}${status}`;
+}
+
+/**
+ * Prompt user to select a target
+ * @param installedTargets - List of currently installed target IDs
+ * @param message - Prompt message to display
+ * @param context - Context where prompt is shown (affects status formatting)
+ * @returns Selected target ID
+ * @throws {UserCancelledError} If user cancels the prompt
+ */
+export async function promptForTargetSelection(
+  installedTargets: string[],
+  message: string,
+  context: 'execution' | 'settings'
+): Promise<string> {
+  const availableTargets = buildAvailableTargets(installedTargets);
+
+  try {
+    const { targetId } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'targetId',
+        message,
+        choices: availableTargets.map((target) => ({
+          name: formatTargetChoice(target, context),
+          value: target.value,
+        })),
+      },
+    ]);
+
+    return targetId;
+  } catch (error) {
+    handlePromptError(error, 'Target selection cancelled');
+  }
+}
+
+/**
+ * Prompt for default target with "Ask me every time" option
+ * @param installedTargets - List of currently installed target IDs
+ * @param currentDefault - Current default target (if any)
+ * @returns Selected default target ID or 'ask-every-time'
+ * @throws {UserCancelledError} If user cancels the prompt
+ */
+export async function promptForDefaultTarget(
+  installedTargets: string[],
+  currentDefault?: string
+): Promise<string> {
+  const availableTargets = buildAvailableTargets(installedTargets);
+
+  try {
+    const { defaultTarget } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'defaultTarget',
+        message: 'Select default target platform:',
+        choices: [
+          ...availableTargets.map((target) => ({
+            name: formatTargetChoice(target, 'settings'),
+            value: target.value,
+          })),
+          new inquirer.Separator(),
+          {
+            name: 'Ask me every time',
+            value: 'ask-every-time',
+          },
+        ],
+        default: currentDefault || 'ask-every-time',
+      },
+    ]);
+
+    return defaultTarget;
+  } catch (error) {
+    handlePromptError(error, 'Target selection cancelled');
+  }
+}
+
+/**
+ * Ensure target is installed, auto-installing if needed
+ * @param targetId - Target ID to ensure is installed
+ * @param targetInstaller - TargetInstaller instance to use
+ * @param installedTargets - List of currently installed target IDs
+ * @returns True if target is installed (or successfully installed), false otherwise
+ */
+export async function ensureTargetInstalled(
+  targetId: string,
+  targetInstaller: TargetInstaller,
+  installedTargets: string[]
+): Promise<boolean> {
+  const installation = targetInstaller.getInstallationInfo(targetId);
+
+  // Already installed - nothing to do
+  if (installedTargets.includes(targetId)) {
+    return true;
+  }
+
+  // Not installed - try to install
+  console.log();
+  const installed = await targetInstaller.install(targetId, true);
+
+  if (!installed) {
+    console.log(chalk.red(`\n✗ Failed to install ${installation?.name}`));
+    console.log(chalk.yellow('   Please install manually and try again.\n'));
+    return false;
+  }
+
+  console.log();
+  return true;
+}