@sylphx/flow 2.1.3 → 2.1.5

package/src/core/upgrade-manager.ts

@@ -1,14 +1,15 @@
+import { exec } from 'node:child_process';
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import { exec } from 'node:child_process';
 import { promisify } from 'node:util';
 import chalk from 'chalk';
 import ora from 'ora';
-import type { ProjectState } from './state-detector.js';
-import { CLIError } from '../utils/error-handler.js';
-import { ConfigService } from '../services/config-service.js';
 import { getProjectSettingsFile } from '../config/constants.js';
-import { detectPackageManager, getUpgradeCommand, type PackageManager } from '../utils/package-manager-detector.js';
+import type { Target } from '../types/target.types.js';
+import { CLIError } from '../utils/error-handler.js';
+import { detectPackageManager, getUpgradeCommand } from '../utils/package-manager-detector.js';
+import type { ProjectState } from './state-detector.js';
+import { targetManager } from './target-manager.js';
 
 const execAsync = promisify(exec);
 
@@ -150,67 +151,83 @@ export class UpgradeManager {
     }
   }
 
+  /**
+   * Resolve target from ID string to Target object
+   */
+  private resolveTarget(targetId: string): Target | null {
+    const targetOption = targetManager.getTarget(targetId);
+    if (targetOption._tag === 'None') {
+      return null;
+    }
+    return targetOption.value;
+  }
+
   async upgradeTarget(state: ProjectState, autoInstall: boolean = false): Promise<boolean> {
     if (!state.target || !state.targetLatestVersion) {
       return false;
     }
 
-    const spinner = ora(`Upgrading ${state.target}...`).start();
+    const target = this.resolveTarget(state.target);
+    if (!target) {
+      return false;
+    }
+
+    const spinner = ora(`Upgrading ${target.name}...`).start();
 
     try {
-      if (state.target === 'claude-code') {
-        await this.upgradeClaudeCode(autoInstall);
-      } else if (state.target === 'opencode') {
-        await this.upgradeOpenCode();
-      }
+      // Use target-specific upgrade logic based on target ID
+      // This is necessary because each CLI has different upgrade commands
+      await this.upgradeTargetCLI(target, autoInstall);
 
-      spinner.succeed(`${state.target} upgraded to latest version`);
+      spinner.succeed(`${target.name} upgraded to latest version`);
       return true;
     } catch (error) {
-      spinner.fail(`${state.target} upgrade failed`);
+      spinner.fail(`${target.name} upgrade failed`);
       throw new CLIError(
-        `Failed to upgrade ${state.target}: ${error instanceof Error ? error.message : String(error)}`,
+        `Failed to upgrade ${target.name}: ${error instanceof Error ? error.message : String(error)}`,
         'TARGET_UPGRADE_FAILED'
       );
     }
   }
 
-  private async upgradeClaudeCode(autoInstall: boolean = false): Promise<void> {
+  /**
+   * Upgrade target CLI - handles target-specific upgrade commands
+   */
+  private async upgradeTargetCLI(target: Target, autoInstall: boolean = false): Promise<void> {
     if (this.options.dryRun) {
-      console.log('Dry run: claude update');
+      console.log(`Dry run: upgrade ${target.id}`);
       return;
     }
 
-    if (autoInstall) {
-      // Use detected package manager to install latest version
-      const packageManager = detectPackageManager(this.projectPath);
-      const installCmd = getUpgradeCommand('@anthropic-ai/claude-code', packageManager);
-      const { stdout } = await execAsync(installCmd);
-
-      if (this.options.verbose) {
-        console.log(stdout);
-      }
-    } else {
-      // Claude Code has built-in update command
-      const { stdout } = await execAsync('claude update');
+    // Each CLI target has specific upgrade commands
+    // This is inherently target-specific and can't be fully abstracted
+    switch (target.id) {
+      case 'claude-code':
+        if (autoInstall) {
+          const packageManager = detectPackageManager(this.projectPath);
+          const installCmd = getUpgradeCommand('@anthropic-ai/claude-code', packageManager);
+          const { stdout } = await execAsync(installCmd);
+          if (this.options.verbose) {
+            console.log(stdout);
+          }
+        } else {
+          const { stdout } = await execAsync('claude update');
+          if (this.options.verbose) {
+            console.log(stdout);
+          }
+        }
+        break;
 
-      if (this.options.verbose) {
-        console.log(stdout);
+      case 'opencode': {
+        const { stdout: ocStdout } = await execAsync('opencode upgrade');
+        if (this.options.verbose) {
+          console.log(ocStdout);
+        }
+        break;
       }
-    }
-  }
-
-  private async upgradeOpenCode(): Promise<void> {
-    if (this.options.dryRun) {
-      console.log('模拟: opencode upgrade');
-      return;
-    }
-
-    // OpenCode has built-in upgrade command
-    const { stdout } = await execAsync('opencode upgrade');
 
-    if (this.options.verbose) {
-      console.log(stdout);
+      default:
+        console.log(chalk.yellow(`No upgrade command available for ${target.name}`));
     }
   }
 
@@ -235,40 +252,63 @@ export class UpgradeManager {
     return upgraded;
   }
 
+  /**
+   * Get the current target from project settings
+   */
+  private async getCurrentTarget(): Promise<Target | null> {
+    try {
+      const configPath = path.join(this.projectPath, getProjectSettingsFile());
+      const config = JSON.parse(await fs.readFile(configPath, 'utf-8'));
+      if (config.target) {
+        return this.resolveTarget(config.target);
+      }
+    } catch {
+      // Cannot read config
+    }
+    return null;
+  }
+
   private async upgradeComponent(component: string): Promise<void> {
-    // 删除旧版本
-    const componentPath = path.join(this.projectPath, '.claude', component);
+    // Get target config for correct directory
+    const target = await this.getCurrentTarget();
+    const configDir = target?.config.configDir || '.claude';
+
+    // Delete old version
+    const componentPath = path.join(this.projectPath, configDir, component);
     await fs.rm(componentPath, { recursive: true, force: true });
 
-    // 重新安装最新版本
-    // 实际实现会调用相应的 installer
-    // 这里用 dry-run 模式模拟
+    // Reinstall latest version
+    // Actual implementation would call the appropriate installer
     if (this.options.dryRun) {
-      console.log(`模拟: 重新安装 ${component}`);
+      console.log(`Dry run: reinstall ${component}`);
     }
   }
 
   private async backupConfig(): Promise<string> {
-    const backupDir = this.options.backupPath || path.join(this.projectPath, '.claude-backup');
+    // Get target config for correct directories
+    const target = await this.getCurrentTarget();
+    const configDir = target?.config.configDir || '.claude';
+
+    const backupDir = this.options.backupPath || path.join(this.projectPath, `${configDir}-backup`);
     await fs.mkdir(backupDir, { recursive: true });
 
     const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
     const backupPath = path.join(backupDir, `backup-${timestamp}`);
 
-    // 备份 .claude 目录
-    const claudePath = path.join(this.projectPath, '.claude');
+    // Backup target config directory
+    const targetConfigPath = path.join(this.projectPath, configDir);
     try {
-      await fs.cp(claudePath, path.join(backupPath, '.claude'), { recursive: true });
+      await fs.cp(targetConfigPath, path.join(backupPath, configDir), { recursive: true });
     } catch {
-      // .claude 目录可能不存在
+      // Config directory may not exist
     }
 
-    // 备份配置文件
-    const configPath = path.join(this.projectPath, getProjectSettingsFile());
+    // Backup project settings file
+    const settingsPath = path.join(this.projectPath, getProjectSettingsFile());
     try {
-      await fs.cp(configPath, path.join(backupPath, getProjectSettingsFile()));
+      await fs.cp(settingsPath, path.join(backupPath, getProjectSettingsFile()));
     } catch {
-      // 配置文件可能不存在
+      // Settings file may not exist
     }
 
     return backupPath;
@@ -281,7 +321,7 @@ export class UpgradeManager {
       const packagePath = path.join(__dirname, '..', '..', 'package.json');
       const packageJson = JSON.parse(await fs.readFile(packagePath, 'utf-8'));
       return packageJson.version || null;
-    } catch (error) {
+    } catch (_error) {
       // Fallback: try to get version from globally installed package
       try {
         const { stdout } = await execAsync('npm list -g @sylphx/flow --depth=0 --json');
@@ -311,18 +351,31 @@ export class UpgradeManager {
     }
   }
 
-  private async getCurrentTargetVersion(target: string): Promise<string | null> {
-    if (target === 'claude-code') {
-      try {
-        const { stdout } = await execAsync('claude --version');
-        const match = stdout.match(/v?(\d+\.\d+\.\d+)/);
-        return match ? match[1] : null;
-      } catch {
-        return null;
-      }
+  private async getCurrentTargetVersion(targetId: string): Promise<string | null> {
+    const target = this.resolveTarget(targetId);
+    if (!target) {
+      return null;
     }
 
-    return null;
+    // Each CLI target has specific version commands
+    try {
+      switch (target.id) {
+        case 'claude-code': {
+          const { stdout } = await execAsync('claude --version');
+          const match = stdout.match(/v?(\d+\.\d+\.\d+)/);
+          return match ? match[1] : null;
+        }
+        case 'opencode': {
+          const { stdout } = await execAsync('opencode --version');
+          const match = stdout.match(/v?(\d+\.\d+\.\d+)/);
+          return match ? match[1] : null;
+        }
+        default:
+          return null;
+      }
+    } catch {
+      return null;
+    }
   }
 
   private async getLatestTargetVersion(): Promise<string | null> {

package/src/index.ts

@@ -8,16 +8,16 @@ import { readFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { Command } from 'commander';
-import { hookCommand } from './commands/hook-command.js';
+import { executeFlow } from './commands/flow/execute-v2.js';
 import {
+  doctorCommand,
   flowCommand,
-  statusCommand,
   setupCommand,
-  doctorCommand,
+  statusCommand,
   upgradeCommand,
 } from './commands/flow-command.js';
+import { hookCommand } from './commands/hook-command.js';
 import { settingsCommand } from './commands/settings-command.js';
-import { executeFlow } from './commands/flow/execute-v2.js';
 import { UserCancelledError } from './utils/errors.js';
 
 // Read version from package.json
@@ -53,7 +53,10 @@ export function createCLI(): Command {
   // Default action: delegate to flow command for convenience
   // This allows `sylphx-flow "prompt"` instead of requiring `sylphx-flow flow "prompt"`
   program
-    .argument('[prompt]', 'Prompt to execute with agent (optional, supports @file.txt for file input)')
+    .argument(
+      '[prompt]',
+      'Prompt to execute with agent (optional, supports @file.txt for file input)'
+    )
     .option('--agent <name>', 'Agent to use (default: coder)', 'coder')
     .option('--agent-file <path>', 'Load agent from specific file')
     .option('--verbose', 'Show detailed output')

package/src/services/auto-upgrade.ts

@@ -4,9 +4,9 @@
  */
 
 import { exec } from 'node:child_process';
-import { promisify } from 'node:util';
 import fs from 'node:fs/promises';
 import path from 'node:path';
+import { promisify } from 'node:util';
 import chalk from 'chalk';
 import ora from 'ora';
 import { detectPackageManager, getUpgradeCommand } from '../utils/package-manager-detector.js';

package/src/services/config-service.ts

@@ -5,12 +5,11 @@
 
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import os from 'node:os';
 import {
   CONFIG_DIR,
-  USER_SETTINGS_FILE,
+  getProjectLocalSettingsFile,
   getProjectSettingsFile,
-  getProjectLocalSettingsFile
+  USER_SETTINGS_FILE,
 } from '../config/constants.js';
 
 /**
@@ -27,8 +26,8 @@ export interface UserSettings {
 
   // API keys for providers
   apiKeys?: {
-    kimi?: string;     // Kimi provider
-    'z.ai'?: string;   // Z.ai proxy
+    kimi?: string; // Kimi provider
+    'z.ai'?: string; // Z.ai proxy
   };
 
   // User preferences (can be changed anytime)
@@ -45,7 +44,7 @@ export interface UserSettings {
 export interface ProjectSettings {
   target?: string;
   version?: string;
-  defaultAgent?: string;  // Can override user default per project
+  defaultAgent?: string; // Can override user default per project
 
   [key: string]: unknown;
 }
@@ -55,9 +54,9 @@ export interface ProjectSettings {
  * These are selected each run but can be overridden by CLI flags
  */
 export interface RuntimeChoices {
-  provider?: string;  // Selected for this run
-  agent?: string;     // Selected for this run
-  prompt?: string;    // User prompt for this run
+  provider?: string; // Selected for this run
+  agent?: string; // Selected for this run
+  prompt?: string; // User prompt for this run
 
   [key: string]: unknown;
 }
@@ -71,9 +70,9 @@ export class ConfigService {
     project: ProjectSettings;
     choices: RuntimeChoices;
   }> {
-    const userSettings = await this.loadHomeSettings();
-    const projectSettings = await this.loadProjectSettings(cwd);
-    const localSettings = await this.loadLocalSettings(cwd);
+    const userSettings = await ConfigService.loadHomeSettings();
+    const projectSettings = await ConfigService.loadProjectSettings(cwd);
+    const localSettings = await ConfigService.loadLocalSettings(cwd);
 
     // Runtime choices merge: local > project > user defaults
     const choices: RuntimeChoices = {
@@ -92,7 +91,7 @@ export class ConfigService {
    * Legacy method for backward compatibility
    */
   static async loadSettings(cwd: string = process.cwd()): Promise<any> {
-    const config = await this.loadConfiguration(cwd);
+    const config = await ConfigService.loadConfiguration(cwd);
     return {
       ...config.user,
       ...config.project,
@@ -120,18 +119,21 @@ export class ConfigService {
     await fs.mkdir(USER_SETTINGS_FILE.replace('/settings.json', ''), { recursive: true });
 
     // Merge with existing settings and save
-    const existing = await this.loadHomeSettings();
+    const existing = await ConfigService.loadHomeSettings();
     const merged = { ...existing, ...settings };
-    await fs.writeFile(USER_SETTINGS_FILE, JSON.stringify(merged, null, 2) + '\n');
+    await fs.writeFile(USER_SETTINGS_FILE, `${JSON.stringify(merged, null, 2)}\n`);
   }
 
   /**
    * Check if user has completed initial setup (API keys configured)
    */
   static async hasInitialSetup(): Promise<boolean> {
-    const userSettings = await this.loadHomeSettings();
+    const userSettings = await ConfigService.loadHomeSettings();
     // Check if user has completed setup (either has API keys OR has explicitly chosen default)
-    return !!(userSettings.hasCompletedSetup || (userSettings.apiKeys && Object.keys(userSettings.apiKeys).length > 0));
+    return !!(
+      userSettings.hasCompletedSetup ||
+      (userSettings.apiKeys && Object.keys(userSettings.apiKeys).length > 0)
+    );
   }
 
   /**
@@ -140,8 +142,12 @@ export class ConfigService {
    */
   static getAvailableProviders(userSettings: UserSettings): string[] {
     const providers: string[] = ['default']; // Always available
-    if (userSettings.apiKeys?.kimi) providers.push('kimi');
-    if (userSettings.apiKeys?.['z.ai']) providers.push('z.ai');
+    if (userSettings.apiKeys?.kimi) {
+      providers.push('kimi');
+    }
+    if (userSettings.apiKeys?.['z.ai']) {
+      providers.push('z.ai');
+    }
     return providers;
   }
 
@@ -161,17 +167,20 @@ export class ConfigService {
   /**
    * Save project-level settings
    */
-  static async saveProjectSettings(settings: ProjectSettings, cwd: string = process.cwd()): Promise<void> {
+  static async saveProjectSettings(
+    settings: ProjectSettings,
+    cwd: string = process.cwd()
+  ): Promise<void> {
     // Ensure directory exists
     const configDir = path.join(cwd, CONFIG_DIR);
     await fs.mkdir(configDir, { recursive: true });
 
     // Merge with existing settings and save
-    const existing = await this.loadProjectSettings(cwd);
+    const existing = await ConfigService.loadProjectSettings(cwd);
     const merged = { ...existing, ...settings };
 
     const configPath = getProjectSettingsFile(cwd);
-    await fs.writeFile(configPath, JSON.stringify(merged, null, 2) + '\n');
+    await fs.writeFile(configPath, `${JSON.stringify(merged, null, 2)}\n`);
   }
 
   /**
@@ -190,13 +199,16 @@ export class ConfigService {
   /**
    * Save project-local settings
    */
-  static async saveLocalSettings(settings: RuntimeChoices, cwd: string = process.cwd()): Promise<void> {
+  static async saveLocalSettings(
+    settings: RuntimeChoices,
+    cwd: string = process.cwd()
+  ): Promise<void> {
     // Ensure directory exists
     const configDir = path.join(cwd, CONFIG_DIR);
     await fs.mkdir(configDir, { recursive: true });
 
     const configPath = getProjectLocalSettingsFile(cwd);
-    await fs.writeFile(configPath, JSON.stringify(settings, null, 2) + '\n');
+    await fs.writeFile(configPath, `${JSON.stringify(settings, null, 2)}\n`);
   }
 
   /**
@@ -209,14 +221,14 @@ export class ConfigService {
   ): Promise<void> {
     // Save API keys to home directory
     if (userConfig.claudeApiKey || userConfig.claudeProvider || userConfig.claudeProviderConfig) {
-      await this.saveHomeSettings(userConfig);
+      await ConfigService.saveHomeSettings(userConfig);
     }
 
     // Save other settings to project
-    await this.saveProjectSettings(projectConfig, cwd);
+    await ConfigService.saveProjectSettings(projectConfig, cwd);
 
     // Create .gitignore pattern file if it doesn't exist (excluding .local.json)
-    await this.addGitignore(cwd);
+    await ConfigService.addGitignore(cwd);
   }
 
   /**
@@ -235,11 +247,11 @@ export class ConfigService {
 
       // Check if pattern already exists
       if (!content.includes('.sylphx-flow/*.local.json')) {
-        await fs.appendFile(gitignorePath, patterns.join('\n') + '\n');
+        await fs.appendFile(gitignorePath, `${patterns.join('\n')}\n`);
       }
     } catch {
       // .gitignore doesn't exist - create it
-      await fs.writeFile(gitignorePath, patterns.join('\n').trim() + '\n');
+      await fs.writeFile(gitignorePath, `${patterns.join('\n').trim()}\n`);
     }
   }
 

package/src/services/global-config.ts

@@ -3,14 +3,14 @@
  * Manages all Flow settings in ~/.sylphx-flow/
  */
 
+import { existsSync } from 'node:fs';
 import fs from 'node:fs/promises';
-import path from 'node:path';
 import os from 'node:os';
-import { existsSync } from 'node:fs';
+import path from 'node:path';
 
 export interface GlobalSettings {
   version: string;
-  defaultTarget?: 'claude-code' | 'opencode' | 'cursor' | 'ask-every-time';
+  defaultTarget?: 'claude-code' | 'opencode' | 'ask-every-time';
   defaultAgent?: string; // Default agent to use (e.g., 'coder', 'writer', 'reviewer', 'orchestrator')
   firstRun: boolean;
   lastUpdated: string;

package/src/services/target-installer.ts

@@ -1,20 +1,20 @@
 /**
  * Target Installation Service
- * Auto-detects and installs AI CLI tools (Claude Code, OpenCode, Cursor)
+ * Auto-detects and installs AI CLI tools (Claude Code, OpenCode)
  */
 
 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 ora from 'ora';
 import { UserCancelledError } from '../utils/errors.js';
+import { detectPackageManager, type PackageManager } from '../utils/package-manager-detector.js';
 
 const execAsync = promisify(exec);
 
 export interface TargetInstallation {
-  id: 'claude-code' | 'opencode' | 'cursor';
+  id: 'claude-code' | 'opencode';
   name: string;
   package: string;
   checkCommand: string;
@@ -61,16 +61,6 @@ const TARGET_INSTALLATIONS: TargetInstallation[] = [
       }
     },
   },
-  {
-    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 {
@@ -136,9 +126,10 @@ export class TargetInstaller {
       ]);
 
       return targetId;
-    } catch (error: any) {
+    } catch (error: unknown) {
       // Handle user cancellation (Ctrl+C)
-      if (error.name === 'ExitPromptError' || error.message?.includes('force closed')) {
+      const err = error as Error & { name?: string };
+      if (err.name === 'ExitPromptError' || err.message?.includes('force closed')) {
         throw new UserCancelledError('Target selection cancelled');
       }
       throw error;
@@ -159,13 +150,6 @@ export class TargetInstaller {
       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 {
@@ -182,9 +166,10 @@ export class TargetInstaller {
           console.log(chalk.yellow('\n⚠️  Installation cancelled\n'));
           return false;
         }
-      } catch (error: any) {
+      } catch (error: unknown) {
         // Handle user cancellation (Ctrl+C)
-        if (error.name === 'ExitPromptError' || error.message?.includes('force closed')) {
+        const err = error as Error & { name?: string };
+        if (err.name === 'ExitPromptError' || err.message?.includes('force closed')) {
           throw new UserCancelledError('Installation cancelled');
         }
         throw error;
@@ -199,7 +184,7 @@ export class TargetInstaller {
 
       spinner.succeed(chalk.green(`✓ ${installation.name} installed successfully`));
       return true;
-    } catch (error) {
+    } catch (_error) {
       spinner.fail(chalk.red(`✗ Failed to install ${installation.name}`));
 
       const installCmd = installation.installCommand(this.packageManager);