@sylphx/flow 2.0.0 → 2.1.1

package/CHANGELOG.md

@@ -1,5 +1,122 @@
 # @sylphx/flow
 
+## 2.1.1
+
+### Patch Changes
+
+- 8ae48d6: Fix singleFiles location and improve settings cleanup
+
+  **Bug Fixes:**
+
+  1. Fixed silent.md location bug - output style files were incorrectly written to project root instead of target config directory (.claude/ or .opencode/)
+
+  2. Enhanced clearUserSettings to ensure complete cleanup in replace mode:
+     - Now clears ALL user configuration including hooks, complete MCP config, rules, and singleFiles
+     - Removes entire MCP section (not just servers) to properly clear user hooks
+     - Added legacy cleanup to remove incorrectly placed files from project root
+
+  This fixes the issue where user's hooks and MCP configs were still affecting execution even in replace mode (non-merge mode).
+
+## 2.1.0
+
+### Minor Changes
+
+- 09608be: Auto-installation and auto-upgrade features
+
+  **New Features:**
+
+  - **Auto-detection**: Automatically detects installed AI CLIs (Claude Code, OpenCode, Cursor)
+  - **Auto-installation**: If no AI CLI is detected, prompts user to select and installs it automatically
+  - **Auto-upgrade**: Before each Flow execution, automatically checks and upgrades Flow and target CLI to latest versions
+  - **Zero-friction setup**: New users can install Flow and start using it immediately without manual setup
+
+  **Implementation:**
+
+  - Created `TargetInstaller` service for detecting and installing AI CLI tools
+  - Created `AutoUpgrade` service for automatic version checking and upgrading
+  - Integrated both services into execution flow (`execute-v2.ts`)
+  - Smart package manager detection (npm, bun, pnpm, yarn)
+
+  **User Experience:**
+
+  Flow 2.0 now delivers on the promise of "One CLI to rule them all":
+
+  1. **First run**: User installs Flow → Flow detects no AI CLI → Prompts to select one → Installs it automatically
+  2. **Every run**: Flow checks for updates → Upgrades Flow and AI CLI to latest → Runs user's task
+
+  Example flow:
+
+  ```
+  $ npm install -g @sylphx/flow
+  $ sylphx-flow "build my app"
+
+  🔍 Detecting installed AI CLIs...
+  ⚠️  No AI CLI detected
+
+  ? No AI CLI detected. Which would you like to use?
+  ❯ Claude Code
+    OpenCode
+    Cursor
+
+  ✓ Claude Code installed successfully
+
+  🔄 Checking for updates...
+  ✓ Flow is up to date
+  ✓ Claude Code is up to date
+
+  🚀 Starting Flow session...
+  ```
+
+  **Philosophy:**
+
+  This implements Flow's core principle of "Transcendent Simplicity" - users don't need to know which AI CLI to use or how to install/upgrade it. Flow handles everything automatically.
+
+### Patch Changes
+
+- cc065f2: Code cleanup and refactoring
+
+  **Removed:**
+
+  - All legacy config migration code (~70 lines)
+  - OpenCode old directory cleanup logic (~16 lines)
+  - Deprecated FileInstaller and MCPInstaller classes (~60 lines)
+  - Unused deprecated exports (ALL_TARGETS, IMPLEMENTED_TARGETS)
+
+  **Refactored:**
+
+  - Migrated from class-based installers to functional API
+  - opencode.ts: Direct function calls instead of class wrappers
+  - claude-code.ts: Direct function calls instead of class wrappers
+
+  **Improved:**
+
+  - Removed ~179 lines of dead code
+  - Cleaner functional API
+  - Better code organization and modularity
+  - Comprehensive JSDoc documentation
+  - Consistent error handling patterns
+
+  **Result:**
+
+  - Zero technical debt
+  - Zero deprecated code
+  - Modern, maintainable codebase
+
+- edb043c: Fix target selection logic to properly distinguish between three cases
+
+  **Fixed:**
+
+  - Target selection now correctly handles three distinct scenarios:
+    1. User explicitly set "ask-every-time" → always prompt
+    2. User has no setting (undefined/null) → allow auto-detect
+    3. User has specific target → use that target
+
+  **Improved:**
+
+  - Better code clarity with explicit case handling
+  - More predictable behavior for different user preferences
+  - Enhanced logic comments for maintainability
+
 ## 2.0.0
 
 ### Major Changes

package/UPGRADE.md

@@ -1,20 +1,28 @@
 # Upgrade Guide
 
-Sylphx Flow includes built-in upgrade detection and automatic update capabilities with **smart package manager detection**.
+Flow 2.0 includes **automatic upgrade before every session** with smart package manager detection. No more manual version management—Flow keeps itself and your AI CLI tools up to date.
 
-## Auto-Detection on Startup
+## Auto-Upgrade on Every Execution
 
-Every time you run Sylphx Flow, it automatically checks for available updates in the background. If an update is available, you'll see a notification like:
+**Before each Flow session**, Flow automatically:
 
+1. **Checks for Flow updates**: Compares installed version with npm registry
+2. **Checks for AI CLI updates**: Verifies Claude Code, OpenCode, or Cursor versions
+3. **Upgrades automatically**: Installs latest versions if available
+4. **Detects package manager**: Uses npm, bun, pnpm, or yarn based on your environment
+
+Example output:
 ```
-📦 Sylphx Flow update available: 1.8.1 → 1.9.0
-   Quick upgrade: sylphx-flow upgrade --auto
-   Or run: bun install -g @sylphx/flow@latest
-```
+🔄 Checking for updates...
+✓ Flow 2.0.0 → 2.1.0 (latest)
+✓ Claude Code 1.5.0 → 1.6.0 (latest)
+📦 Installing updates...
+✓ All tools upgraded
 
-The upgrade command is automatically tailored to your detected package manager (npm, bun, pnpm, or yarn).
+🚀 Starting Flow session...
+```
 
-This check is non-intrusive and won't block your workflow. Use `--quick` mode to skip the check entirely.
+This happens automatically. No flags needed, no configuration required.
 
 ## Manual Upgrade Check
 
@@ -94,13 +102,16 @@ Sylphx Flow automatically detects which package manager you're using:
    - Without `--auto`: Shows manual install command for your package manager
    - With `--auto`: Runs the appropriate install command automatically
 
-## Disabling Auto-Check
+## Philosophy: Always Latest
 
-Use `--quick` mode to skip automatic update checks:
+Flow 2.0 embraces the principle of **always running the latest stable versions**. This ensures:
 
-```bash
-sylphx-flow --quick "your prompt here"
-```
+- Latest features and improvements
+- Security patches applied immediately
+- Compatibility with newest AI models
+- Bug fixes without manual intervention
+
+Auto-upgrade cannot be disabled—it's core to Flow's philosophy of zero-friction excellence.
 
 ## Troubleshooting
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sylphx/flow",
-  "version": "2.0.0",
-  "description": "AI-powered development workflow automation with autonomous loop mode and smart configuration",
+  "version": "2.1.1",
+  "description": "One CLI to rule them all. Unified orchestration layer for Claude Code, OpenCode, Cursor and all AI development tools. Auto-detection, auto-installation, auto-upgrade.",
   "type": "module",
   "bin": {
     "sylphx-flow": "./src/index.ts"
@@ -50,12 +50,16 @@
     "ai",
     "automation",
     "workflow",
-    "claude",
+    "claude-code",
     "opencode",
+    "cursor",
     "cli",
-    "autonomous",
-    "loop-mode",
-    "developer-tools"
+    "orchestration",
+    "unified",
+    "meta-layer",
+    "developer-tools",
+    "auto-install",
+    "auto-upgrade"
   ],
   "repository": {
     "type": "git",

package/src/commands/flow/execute-v2.ts

@@ -16,6 +16,32 @@ import type { FlowOptions } from './types.js';
 import { resolvePrompt } from './prompt.js';
 import { GlobalConfigService } from '../../services/global-config.js';
 import { UserCancelledError } from '../../utils/errors.js';
+import { TargetInstaller } from '../../services/target-installer.js';
+import { AutoUpgrade } from '../../services/auto-upgrade.js';
+import { promptForTargetSelection, ensureTargetInstalled } from '../../utils/target-selection.js';
+
+/**
+ * Configure provider environment variables
+ */
+function configureProviderEnv(
+  provider: 'kimi' | 'zai',
+  apiKey: string
+): void {
+  const providerConfig = {
+    kimi: {
+      baseUrl: 'https://api.moonshot.cn/v1',
+      name: 'Kimi',
+    },
+    zai: {
+      baseUrl: 'https://api.z.ai/v1',
+      name: 'Z.ai',
+    },
+  };
+
+  const config = providerConfig[provider];
+  process.env.ANTHROPIC_BASE_URL = config.baseUrl;
+  process.env.ANTHROPIC_API_KEY = apiKey;
+}
 
 /**
  * Select and configure provider for Claude Code
@@ -27,60 +53,48 @@ async function selectProvider(
     const providerConfig = await configService.loadProviderConfig();
     const defaultProvider = providerConfig.claudeCode.defaultProvider;
 
-  // If not "ask-every-time", use the default provider
-  if (defaultProvider !== 'ask-every-time') {
-    // Configure environment variables for the selected provider
-    if (defaultProvider === 'kimi' || defaultProvider === 'zai') {
-      const provider = providerConfig.claudeCode.providers[defaultProvider];
-      if (provider?.apiKey) {
-        if (defaultProvider === 'kimi') {
-          process.env.ANTHROPIC_BASE_URL = 'https://api.moonshot.cn/v1';
-          process.env.ANTHROPIC_API_KEY = provider.apiKey;
-        } else if (defaultProvider === 'zai') {
-          process.env.ANTHROPIC_BASE_URL = 'https://api.z.ai/v1';
-          process.env.ANTHROPIC_API_KEY = provider.apiKey;
+    // If not "ask-every-time", use the default provider
+    if (defaultProvider !== 'ask-every-time') {
+      if (defaultProvider === 'kimi' || defaultProvider === 'zai') {
+        const provider = providerConfig.claudeCode.providers[defaultProvider];
+        if (provider?.apiKey) {
+          configureProviderEnv(defaultProvider, provider.apiKey);
         }
       }
+      return;
     }
-    return;
-  }
-
-  // Ask user which provider to use for this session
-  const { selectedProvider } = await inquirer.prompt([
-    {
-      type: 'list',
-      name: 'selectedProvider',
-      message: 'Select provider for this session:',
-      choices: [
-        { name: 'Default (Claude Code built-in)', value: 'default' },
-        { name: 'Kimi', value: 'kimi' },
-        { name: 'Z.ai', value: 'zai' },
-      ],
-      default: 'default',
-    },
-  ]);
 
-  // Configure environment variables based on selection
-  if (selectedProvider === 'kimi' || selectedProvider === 'zai') {
-    const provider = providerConfig.claudeCode.providers[selectedProvider];
+    // Ask user which provider to use for this session
+    const { selectedProvider } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'selectedProvider',
+        message: 'Select provider for this session:',
+        choices: [
+          { name: 'Default (Claude Code built-in)', value: 'default' },
+          { name: 'Kimi', value: 'kimi' },
+          { name: 'Z.ai', value: 'zai' },
+        ],
+        default: 'default',
+      },
+    ]);
+
+    // Configure environment variables based on selection
+    if (selectedProvider === 'kimi' || selectedProvider === 'zai') {
+      const provider = providerConfig.claudeCode.providers[selectedProvider];
+
+      if (!provider?.apiKey) {
+        console.log(chalk.yellow('⚠ API key not configured. Use: sylphx-flow settings\n'));
+        return;
+      }
 
-    if (!provider?.apiKey) {
-      console.log(chalk.yellow('⚠ API key not configured. Use: sylphx-flow settings\n'));
-      return;
-    }
+      configureProviderEnv(selectedProvider, provider.apiKey);
 
-    if (selectedProvider === 'kimi') {
-      process.env.ANTHROPIC_BASE_URL = 'https://api.moonshot.cn/v1';
-      process.env.ANTHROPIC_API_KEY = provider.apiKey;
-      console.log(chalk.green('✓ Using Kimi provider\n'));
-    } else if (selectedProvider === 'zai') {
-      process.env.ANTHROPIC_BASE_URL = 'https://api.z.ai/v1';
-      process.env.ANTHROPIC_API_KEY = provider.apiKey;
-      console.log(chalk.green('✓ Using Z.ai provider\n'));
+      const providerName = selectedProvider === 'kimi' ? 'Kimi' : 'Z.ai';
+      console.log(chalk.green(`✓ Using ${providerName} provider\n`));
+    } else {
+      console.log(chalk.green('✓ Using default Claude Code provider\n'));
     }
-  } else {
-    console.log(chalk.green('✓ Using default Claude Code provider\n'));
-  }
   } catch (error: any) {
     // Handle user cancellation (Ctrl+C)
     if (error.name === 'ExitPromptError' || error.message?.includes('force closed')) {
@@ -129,6 +143,103 @@ export async function executeFlowV2(
   // Show welcome banner
   showWelcome();
 
+  // Initialize config service early to check for saved preferences
+  const configService = new GlobalConfigService();
+  await configService.initialize();
+
+  // Step 1: Determine target
+  const targetInstaller = new TargetInstaller(projectPath);
+  const installedTargets = await targetInstaller.detectInstalledTargets();
+  const settings = await configService.loadSettings();
+
+  let selectedTargetId: string | null = null;
+
+  // Distinguish between three cases:
+  // 1. User explicitly set "ask-every-time" → always prompt
+  // 2. User has no setting (undefined/null) → allow auto-detect
+  // 3. User has specific target → use that target
+  const isAskEveryTime = settings.defaultTarget === 'ask-every-time';
+  const hasNoSetting = !settings.defaultTarget;
+  const hasSpecificTarget = settings.defaultTarget && settings.defaultTarget !== 'ask-every-time';
+
+  if (isAskEveryTime) {
+    // User explicitly wants to be asked every time - ALWAYS prompt, never auto-detect
+    console.log(chalk.cyan('🔍 Detecting installed AI CLIs...\n'));
+
+    selectedTargetId = await promptForTargetSelection(
+      installedTargets,
+      'Select AI CLI to use:',
+      'execution'
+    );
+
+    const installation = targetInstaller.getInstallationInfo(selectedTargetId);
+    const installed = await ensureTargetInstalled(selectedTargetId, targetInstaller, installedTargets);
+
+    if (!installed) {
+      process.exit(1);
+    }
+
+    if (installedTargets.includes(selectedTargetId)) {
+      console.log(chalk.green(`✓ Using ${installation?.name}\n`));
+    }
+  } else if (hasNoSetting) {
+    // No setting - use auto-detection (smart default behavior)
+    if (installedTargets.length === 1) {
+      // Exactly 1 target found - use it automatically
+      selectedTargetId = installedTargets[0];
+      const installation = targetInstaller.getInstallationInfo(selectedTargetId);
+      console.log(chalk.green(`✓ Using ${installation?.name} (auto-detected)\n`));
+    } else {
+      // 0 or multiple targets - prompt for selection
+      console.log(chalk.cyan('🔍 Detecting installed AI CLIs...\n'));
+
+      selectedTargetId = await promptForTargetSelection(
+        installedTargets,
+        'Select AI CLI to use:',
+        'execution'
+      );
+
+      const installation = targetInstaller.getInstallationInfo(selectedTargetId);
+      const installed = await ensureTargetInstalled(selectedTargetId, targetInstaller, installedTargets);
+
+      if (!installed) {
+        process.exit(1);
+      }
+
+      if (installedTargets.includes(selectedTargetId)) {
+        console.log(chalk.green(`✓ Using ${installation?.name}\n`));
+      }
+    }
+  } else if (hasSpecificTarget) {
+    // User has a specific target preference - ALWAYS use it
+    selectedTargetId = settings.defaultTarget;
+    const installation = targetInstaller.getInstallationInfo(selectedTargetId);
+
+    // Check if the preferred target is installed
+    if (installedTargets.includes(selectedTargetId)) {
+      console.log(chalk.green(`✓ Using ${installation?.name} (from settings)\n`));
+    } else {
+      // Preferred target not installed - try to install it
+      console.log(chalk.yellow(`⚠️  ${installation?.name} is set as default but not installed\n`));
+      const installed = await targetInstaller.install(selectedTargetId, true);
+
+      if (!installed) {
+        // Installation failed - show error and exit
+        console.log(chalk.red(`\n✗ Cannot proceed: ${installation?.name} is not installed and auto-install failed`));
+        console.log(chalk.yellow('   Please either:'));
+        console.log(chalk.cyan('   1. Install manually (see instructions above)'));
+        console.log(chalk.cyan('   2. Change default target: sylphx-flow settings\n'));
+        process.exit(1);
+      }
+
+      console.log();
+    }
+  }
+
+  // Step 2: Auto-upgrade Flow and target CLI
+  const autoUpgrade = new AutoUpgrade(projectPath);
+  await autoUpgrade.runAutoUpgrade(selectedTargetId);
+
   // Mode info
   if (options.merge) {
     console.log(chalk.cyan('🔗 Merge mode: Flow settings will be merged with your existing settings'));
@@ -138,24 +249,10 @@ export async function executeFlowV2(
     console.log(chalk.dim('   Use --merge to keep your existing settings\n'));
   }
 
-  // Initialize config service
-  const configService = new GlobalConfigService();
-  await configService.initialize();
-
   // Create executor
   const executor = new FlowExecutor();
   const projectManager = executor.getProjectManager();
 
-  // Step 1: Check for upgrades (non-intrusive)
-  const upgradeManager = new UpgradeManager();
-  const updates = await upgradeManager.checkUpdates();
-
-  if (updates.flowUpdate || updates.targetUpdate) {
-    console.log(
-      chalk.yellow('📦 Updates available! Run: sylphx-flow upgrade --auto\n')
-    );
-  }
-
   // Step 2: Execute attach mode lifecycle
   try {
     // Attach Flow environment (backup → attach → register cleanup)
@@ -166,12 +263,9 @@ export async function executeFlowV2(
       merge: options.merge || false,
     });
 
-    // Step 3: Detect target and load agent
-    const projectHash = projectManager.getProjectHash(projectPath);
-    const target = await projectManager.detectTarget(projectPath);
-
-    // Map target to targetManager's target IDs
-    const targetId = target === 'claude-code' ? 'claude-code' : 'opencode';
+    // Step 3: Use the target we already selected (don't re-detect)
+    // selectedTargetId was determined earlier based on settings/auto-detect/prompt
+    const targetId = selectedTargetId;
 
     // Step 3.5: Provider selection (Claude Code only)
     if (targetId === 'claude-code') {

package/src/commands/settings-command.ts

@@ -8,6 +8,8 @@ import chalk from 'chalk';
 import inquirer from 'inquirer';
 import { GlobalConfigService } from '../services/global-config.js';
 import { UserCancelledError } from '../utils/errors.js';
+import { TargetInstaller } from '../services/target-installer.js';
+import { promptForDefaultTarget, buildAvailableTargets } from '../utils/target-selection.js';
 
 export const settingsCommand = new Command('settings')
   .description('Configure Sylphx Flow settings')
@@ -440,25 +442,30 @@ async function configureTarget(configService: GlobalConfigService): Promise<void
   console.log(chalk.cyan.bold('\n━━━ 🎯 Target Platform\n'));
 
   const settings = await configService.loadSettings();
+  const targetInstaller = new TargetInstaller();
 
-  const { defaultTarget } = await inquirer.prompt([
-    {
-      type: 'list',
-      name: 'defaultTarget',
-      message: 'Select default target platform:',
-      choices: [
-        { name: 'Claude Code', value: 'claude-code' },
-        { name: 'OpenCode', value: 'opencode' },
-      ],
-      default: settings.defaultTarget || 'claude-code',
-    },
-  ]);
+  // Detect which targets are installed
+  console.log(chalk.dim('Detecting installed AI CLIs...\n'));
+  const installedTargets = await targetInstaller.detectInstalledTargets();
 
-  settings.defaultTarget = defaultTarget;
+  const defaultTarget = await promptForDefaultTarget(installedTargets, settings.defaultTarget);
+
+  settings.defaultTarget = defaultTarget as 'claude-code' | 'opencode' | 'cursor' | 'ask-every-time';
   await configService.saveSettings(settings);
 
-  console.log(chalk.green('\n✓ Target platform saved'));
-  console.log(chalk.dim(`  Default: ${defaultTarget}`));
+  if (defaultTarget === 'ask-every-time') {
+    console.log(chalk.green('\n✓ Target platform saved'));
+    console.log(chalk.dim('  Default: Ask every time (auto-detect or prompt)'));
+  } else {
+    const availableTargets = buildAvailableTargets(installedTargets);
+    const selectedTarget = availableTargets.find((t) => t.value === defaultTarget);
+    const installStatus = selectedTarget?.installed
+      ? chalk.green('(installed)')
+      : chalk.yellow('(will be installed on first use)');
+
+    console.log(chalk.green('\n✓ Target platform saved'));
+    console.log(chalk.dim(`  Default: ${defaultTarget} ${installStatus}`));
+  }
 }
 
 /**

package/src/config/ai-config.ts

@@ -58,11 +58,6 @@ const GLOBAL_CONFIG_FILE = path.join(os.homedir(), '.sylphx-flow', 'settings.jso
 const PROJECT_CONFIG_FILE = '.sylphx-flow/settings.json';
 const LOCAL_CONFIG_FILE = '.sylphx-flow/settings.local.json';
 
-/**
- * Deprecated config file (for migration)
- */
-const LEGACY_CONFIG_FILE = '.sylphx-flow/ai-config.json';
-
 /**
  * Get AI config file paths in priority order
  */
@@ -70,12 +65,10 @@ export const getAIConfigPaths = (cwd: string = process.cwd()): {
   global: string;
   project: string;
   local: string;
-  legacy: string;
 } => ({
   global: GLOBAL_CONFIG_FILE,
   project: path.join(cwd, PROJECT_CONFIG_FILE),
   local: path.join(cwd, LOCAL_CONFIG_FILE),
-  legacy: path.join(cwd, LEGACY_CONFIG_FILE),
 });
 
 /**
@@ -140,18 +133,12 @@ export const aiConfigExists = async (cwd: string = process.cwd()): Promise<boole
     return true;
   } catch {}
 
-  try {
-    await fs.access(paths.legacy);
-    return true;
-  } catch {}
-
   return false;
 };
 
 /**
  * Load AI configuration
  * Merges global, project, and local configs with priority: local > project > global
- * Automatically migrates legacy config on first load
  */
 export const loadAIConfig = async (cwd: string = process.cwd()): Promise<Result<AIConfig, Error>> => {
   return tryCatchAsync(
@@ -159,39 +146,19 @@ export const loadAIConfig = async (cwd: string = process.cwd()): Promise<Result<
       const paths = getAIConfigPaths(cwd);
 
       // Load all config files
-      const [globalConfig, projectConfig, localConfig, legacyConfig] = await Promise.all([
+      const [globalConfig, projectConfig, localConfig] = await Promise.all([
         loadConfigFile(paths.global),
         loadConfigFile(paths.project),
         loadConfigFile(paths.local),
-        loadConfigFile(paths.legacy),
       ]);
 
-      // Auto-migrate legacy config if it exists and global doesn't
-      if (legacyConfig && !globalConfig) {
-        await migrateLegacyConfig(cwd);
-        // Reload global config after migration
-        const migratedGlobal = await loadConfigFile(paths.global);
-        if (migratedGlobal) {
-          // Start with empty config
-          let merged: AIConfig = {};
-
-          // Merge in priority order: global < project < local
-          merged = mergeConfigs(merged, migratedGlobal);
-          if (projectConfig) merged = mergeConfigs(merged, projectConfig);
-          if (localConfig) merged = mergeConfigs(merged, localConfig);
-
-          return merged;
-        }
-      }
-
       // Start with empty config
       let merged: AIConfig = {};
 
-      // Merge in priority order: global < project < local < legacy (for backwards compat)
+      // Merge in priority order: global < project < local
       if (globalConfig) merged = mergeConfigs(merged, globalConfig);
       if (projectConfig) merged = mergeConfigs(merged, projectConfig);
       if (localConfig) merged = mergeConfigs(merged, localConfig);
-      if (legacyConfig) merged = mergeConfigs(merged, legacyConfig);
 
       return merged;
     },
@@ -340,37 +307,3 @@ export const getConfiguredProviders = async (
   return providers;
 };
 
-/**
- * Migrate legacy ai-config.json to new settings system
- * Automatically called on first load if legacy config exists
- */
-export const migrateLegacyConfig = async (cwd: string = process.cwd()): Promise<Result<void, Error>> => {
-  return tryCatchAsync(
-    async () => {
-      const paths = getAIConfigPaths(cwd);
-
-      // Check if legacy config exists
-      const legacyConfig = await loadConfigFile(paths.legacy);
-      if (!legacyConfig) {
-        return; // No legacy config to migrate
-      }
-
-      // Check if global config already exists
-      const globalConfig = await loadConfigFile(paths.global);
-      if (globalConfig) {
-        // Global config exists, don't overwrite it
-        console.log('Legacy config found but global config already exists. Skipping migration.');
-        console.log(`You can manually delete ${paths.legacy} if migration is complete.`);
-        return;
-      }
-
-      // Migrate to global config
-      await fs.mkdir(path.dirname(paths.global), { recursive: true });
-      await fs.writeFile(paths.global, JSON.stringify(legacyConfig, null, 2) + '\n', 'utf8');
-
-      console.log(`✓ Migrated configuration from ${paths.legacy} to ${paths.global}`);
-      console.log(`  You can now safely delete the legacy file: ${paths.legacy}`);
-    },
-    (error: any) => new Error(`Failed to migrate legacy config: ${error.message}`)
-  );
-};

package/src/config/targets.ts

@@ -113,14 +113,3 @@ export const isTargetImplemented = (id: string): boolean => {
  * Utility type for target IDs
  */
 export type TargetID = ReturnType<typeof getAllTargetIDs>[number];
-
-/**
- * Legacy aliases for backward compatibility
- * @deprecated Use getAllTargets() instead
- */
-export const ALL_TARGETS = getAllTargets;
-
-/**
- * @deprecated Use getImplementedTargets() instead
- */
-export const IMPLEMENTED_TARGETS = getImplementedTargets;