@sylphx/flow 2.0.0 → 2.1.0

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;
+}