@sylphx/flow 1.8.2 → 2.1.0

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

@@ -0,0 +1,372 @@
+/**
+ * Execution Logic for Flow Command (V2 - Attach Mode)
+ * New execution flow with attach-mode lifecycle
+ */
+
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { FlowExecutor } from '../../core/flow-executor.js';
+import { targetManager } from '../../core/target-manager.js';
+import { UpgradeManager } from '../../core/upgrade-manager.js';
+import { showWelcome } from '../../utils/display/banner.js';
+import { loadAgentContent, extractAgentInstructions } from '../run-command.js';
+import { CLIError } from '../../utils/error-handler.js';
+import type { RunCommandOptions } from '../../types.js';
+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
+ */
+async function selectProvider(
+  configService: GlobalConfigService
+): Promise<void> {
+  try {
+    const providerConfig = await configService.loadProviderConfig();
+    const defaultProvider = providerConfig.claudeCode.defaultProvider;
+
+    // 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;
+    }
+
+    // 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;
+      }
+
+      configureProviderEnv(selectedProvider, provider.apiKey);
+
+      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'));
+    }
+  } catch (error: any) {
+    // Handle user cancellation (Ctrl+C)
+    if (error.name === 'ExitPromptError' || error.message?.includes('force closed')) {
+      throw new UserCancelledError('Provider selection cancelled');
+    }
+    throw error;
+  }
+}
+
+/**
+ * Execute command using target's executeCommand method
+ */
+async function executeTargetCommand(
+  targetId: string,
+  systemPrompt: string,
+  userPrompt: string,
+  options: RunCommandOptions
+): Promise<void> {
+  const targetOption = targetManager.getTarget(targetId);
+
+  if (targetOption._tag === 'None') {
+    throw new CLIError(`Target not found: ${targetId}`, 'TARGET_NOT_FOUND');
+  }
+
+  const target = targetOption.value;
+
+  if (!target.isImplemented || !target.executeCommand) {
+    throw new CLIError(
+      `Target '${targetId}' does not support command execution`,
+      'EXECUTION_NOT_SUPPORTED'
+    );
+  }
+
+  return target.executeCommand(systemPrompt, userPrompt, options);
+}
+
+/**
+ * Main flow execution with attach mode (V2)
+ */
+export async function executeFlowV2(
+  prompt: string | undefined,
+  options: FlowOptions
+): Promise<void> {
+  const projectPath = process.cwd();
+
+  // 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'));
+    console.log(chalk.dim('   Settings will be restored after execution\n'));
+  } else {
+    console.log(chalk.yellow('🔄 Replace mode (default): All settings will use Flow configuration'));
+    console.log(chalk.dim('   Use --merge to keep your existing settings\n'));
+  }
+
+  // Create executor
+  const executor = new FlowExecutor();
+  const projectManager = executor.getProjectManager();
+
+  // Step 2: Execute attach mode lifecycle
+  try {
+    // Attach Flow environment (backup → attach → register cleanup)
+    await executor.execute(projectPath, {
+      verbose: options.verbose,
+      skipBackup: false,
+      skipSecrets: false,
+      merge: options.merge || false,
+    });
+
+    // 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') {
+      await selectProvider(configService);
+    }
+
+    // Step 3.6: Load Flow settings and determine agent to use
+    const settings = await configService.loadSettings();
+    const flowConfig = await configService.loadFlowConfig();
+
+    // Determine which agent to use (CLI option > settings default > 'coder')
+    const agent = options.agent || settings.defaultAgent || 'coder';
+
+    // Check if agent is enabled
+    if (!flowConfig.agents[agent]?.enabled) {
+      console.log(chalk.yellow(`⚠️  Agent '${agent}' is not enabled in settings`));
+      console.log(chalk.yellow(`   Enable it with: sylphx-flow settings`));
+      console.log(chalk.yellow(`   Using 'coder' agent instead\n`));
+      // Fallback to first enabled agent or coder
+      const enabledAgents = await configService.getEnabledAgents();
+      const fallbackAgent = enabledAgents.length > 0 ? enabledAgents[0] : 'coder';
+      options.agent = fallbackAgent;
+    }
+
+    console.log(chalk.cyan(`🤖 Running agent: ${agent}\n`));
+
+    // Load enabled rules and output styles from config
+    const enabledRules = await configService.getEnabledRules();
+    const enabledOutputStyles = await configService.getEnabledOutputStyles();
+
+    console.log(chalk.dim(`   Enabled rules: ${enabledRules.join(', ')}`));
+    console.log(chalk.dim(`   Enabled output styles: ${enabledOutputStyles.join(', ')}\n`));
+
+    // Load agent content with only enabled rules and styles
+    const agentContent = await loadAgentContent(
+      agent,
+      options.agentFile,
+      enabledRules,
+      enabledOutputStyles
+    );
+    const agentInstructions = extractAgentInstructions(agentContent);
+
+    const systemPrompt = `AGENT INSTRUCTIONS:\n${agentInstructions}`;
+
+    const userPrompt = prompt?.trim() || '';
+
+    // Prepare run options
+    const runOptions: RunCommandOptions = {
+      target: targetId,
+      verbose: options.verbose || false,
+      dryRun: options.dryRun || false,
+      agent,
+      agentFile: options.agentFile,
+      prompt,
+      print: options.print,
+      continue: options.continue,
+    };
+
+    // Step 4: Execute command
+    await executeTargetCommand(targetId, systemPrompt, userPrompt, runOptions);
+
+    // Step 5: Cleanup (restore environment)
+    await executor.cleanup(projectPath);
+
+    console.log(chalk.green('✓ Session complete\n'));
+  } catch (error) {
+    // Handle user cancellation gracefully
+    if (error instanceof UserCancelledError) {
+      console.log(chalk.yellow('\n⚠️  Operation cancelled by user'));
+      try {
+        await executor.cleanup(projectPath);
+        console.log(chalk.green('   ✓ Settings restored\n'));
+      } catch (cleanupError) {
+        console.error(chalk.red('   ✗ Cleanup failed:'), cleanupError);
+      }
+      process.exit(0);
+    }
+
+    console.error(chalk.red.bold('\n✗ Execution failed:'), error);
+
+    // Ensure cleanup even on error
+    try {
+      await executor.cleanup(projectPath);
+    } catch (cleanupError) {
+      console.error(chalk.red('✗ Cleanup failed:'), cleanupError);
+    }
+
+    throw error;
+  }
+}
+
+/**
+ * Main flow execution entry point
+ */
+export async function executeFlow(
+  prompt: string | undefined,
+  options: FlowOptions
+): Promise<void> {
+  // Resolve prompt (handle file input)
+  const resolvedPrompt = await resolvePrompt(prompt);
+
+  // Use V2 attach mode execution
+  await executeFlowV2(resolvedPrompt, options);
+}

package/src/commands/flow/execute.ts

@@ -124,28 +124,11 @@ export async function executeFlowOnce(prompt: string | undefined, options: FlowO
       await showStatus(state);
     }
 
-    // Step 1: Check for upgrades
+    // Step 1: Check for upgrades (non-intrusive notification)
     if (!options.quick) {
       await checkUpgrades(state, options);
     }
 
-    // Step 1: Upgrade (if requested)
-    if (options.upgrade && state.outdated && state.latestVersion) {
-      console.log(chalk.cyan.bold('━━━ 📦 Upgrading Flow\n'));
-      await upgradeManager.upgradeFlow(state);
-      console.log(chalk.green('✓ Upgrade complete\n'));
-      // Re-detect after upgrade
-      state.version = state.latestVersion;
-      state.outdated = false;
-    }
-
-    // Step 2: Upgrade target (if requested)
-    if (options.upgradeTarget && state.target) {
-      console.log(chalk.cyan.bold(`━━━ 🎯 Upgrading ${state.target}\n`));
-      await upgradeManager.upgradeTarget(state);
-      console.log(chalk.green('✓ Target upgrade complete\n'));
-    }
-
     // Step 2.5: Check component integrity (only if we have valid state)
     await checkComponentIntegrity(state, options);
 

package/src/commands/flow/types.ts

@@ -26,14 +26,15 @@ export interface FlowOptions {
   // Smart configuration options
   selectProvider?: boolean;
   selectAgent?: boolean;
-  useDefaults?: boolean;
   provider?: string;
-  quick?: boolean;
 
   // Execution modes
   print?: boolean;
   continue?: boolean;
 
+  // Attach strategy
+  merge?: boolean; // Merge with user settings instead of replacing (default: replace)
+
   // Loop mode
   loop?: number;
   maxRuns?: number;

package/src/commands/flow-command.ts

@@ -11,49 +11,23 @@ import { StateDetector } from '../core/state-detector.js';
 import { UpgradeManager } from '../core/upgrade-manager.js';
 import { showWelcome } from '../utils/display/banner.js';
 import { showStatus } from '../utils/display/status.js';
-import { executeFlow } from './flow/execute.js';
+import { executeFlow } from './flow/execute-v2.js';
 import type { FlowOptions } from './flow/types.js';
 
 /**
- * Smart flow command
+ * Flow command (simplified for attach mode)
  */
 export const flowCommand = new Command('flow')
-  .description('Intelligent development flow (auto-detect state and act accordingly)')
-
-  // Smart options
-  .option('--init-only', 'Only initialize, do not run')
-  .option('--run-only', 'Only run, skip initialization')
-  .option('--sync', 'Synchronize with Flow templates (delete and re-install template files)')
-  .option('--upgrade', 'Upgrade Sylphx Flow to latest version')
-  .option('--upgrade-target', 'Upgrade target platform (Claude Code/OpenCode)')
-
-  // Smart configuration options
-  .option('--quick', 'Quick mode: use saved defaults and skip all prompts')
-  .option('--select-provider', 'Prompt to select provider each run')
-  .option('--select-agent', 'Prompt to select agent each run')
-  .option('--use-defaults', 'Skip prompts, use saved defaults')
-  .option('--provider <provider>', 'Override provider for this run (anthropic|z.ai|kimi)')
-
-  // Init options
-  .option('--target <type>', 'Target platform (opencode, claude-code, auto-detect)')
-  .option('--verbose', 'Show detailed output')
-  .option('--dry-run', 'Show what would be done without making changes')
-  .option('--no-mcp', 'Skip MCP installation')
-  .option('--no-agents', 'Skip agents installation')
-  .option('--no-rules', 'Skip rules installation')
-  .option('--no-output-styles', 'Skip output styles installation')
-  .option('--no-slash-commands', 'Skip slash commands installation')
-  .option('--no-hooks', 'Skip hooks setup')
-
-  // Run options
+  .description('Run Flow with automatic environment attach')
+
+  // Core options
   .option('--agent <name>', 'Agent to use (default: coder)', 'coder')
   .option('--agent-file <path>', 'Load agent from specific file')
+  .option('--verbose', 'Show detailed output')
+  .option('--dry-run', 'Show what would be done without making changes')
   .option('-p, --print', 'Headless print mode (output only, no interactive)')
   .option('-c, --continue', 'Continue previous conversation (requires print mode)')
-
-  // Loop options
-  .option('--loop [interval]', 'Loop mode: run repeatedly (optional cooldown in seconds)')
-  .option('--max-runs <number>', 'Maximum loop iterations (default: infinite)', parseInt)
+  .option('--merge', 'Merge Flow settings with existing settings (default: replace all)')
 
   // Prompt argument
   .argument('[prompt]', 'Prompt to execute with agent (optional, supports @file.txt for file input)')
@@ -63,34 +37,17 @@ export const flowCommand = new Command('flow')
   });
 
 /**
- * Setup command - alias for `flow --init-only`
- * Kept for backward compatibility
+ * Setup command - deprecated (attach mode is automatic)
  */
 export const setupCommand = new Command('setup')
-  .description('Initialize project configuration (alias for: flow --init-only)')
+  .description('[DEPRECATED] No longer needed - Flow uses automatic attach mode')
   .action(async () => {
-    console.log(chalk.yellow('ℹ  The "setup" command is deprecated.'));
-    console.log(chalk.yellow('   Please use: flow --init-only\n'));
-
-    showWelcome();
-
-    const { runInit } = await import('./init-command.js');
-    await runInit({
-      target: undefined,
-      verbose: false,
-      dryRun: false,
-      clear: false,
-      mcp: true,
-      agents: true,
-      rules: true,
-      outputStyles: true,
-      slashCommands: true,
-      hooks: true,
-      helpOption: () => {},
-    });
-
-    console.log(chalk.green('\n✅ Setup complete!'));
-    console.log(chalk.dim('\nNext time, use: flow --init-only'));
+    console.log(chalk.yellow('⚠️  The "setup" command is deprecated.\n'));
+    console.log(chalk.cyan('Flow now uses automatic attach mode:'));
+    console.log(chalk.dim('   • No installation needed'));
+    console.log(chalk.dim('   • Environment attached automatically'));
+    console.log(chalk.dim('   • Restored on exit\n'));
+    console.log(chalk.green('✨ Just run: sylphx-flow "your prompt"\n'));
   });
 
 /**
@@ -193,11 +150,12 @@ export const doctorCommand = new Command('doctor')
 export const upgradeCommand = new Command('upgrade')
   .description('Upgrade Sylphx Flow and components')
   .option('--check', 'Only check for updates, do not upgrade')
+  .option('--auto', 'Automatically install updates via npm')
   .option('--components', 'Upgrade components (agents, rules, etc)', true)
   .option('--target', 'Upgrade target platform (Claude Code/OpenCode)')
   .option('--verbose', 'Show detailed output')
   .action(async (options) => {
-    console.log(chalk.cyan.bold('📦 检查更新\n'));
+    console.log(chalk.cyan.bold('📦 Checking for updates\n'));
 
     const detector = new StateDetector();
     const upgradeManager = new UpgradeManager();
@@ -205,7 +163,7 @@ export const upgradeCommand = new Command('upgrade')
     const updates = await upgradeManager.checkUpdates();
 
     if (!updates.flowUpdate && !updates.targetUpdate) {
-      console.log(chalk.green('✓ 所有组件已是最新版本\n'));
+      console.log(chalk.green('✓ All components are up to date\n'));
       return;
     }
 
@@ -219,7 +177,7 @@ export const upgradeCommand = new Command('upgrade')
 
     // Check only
     if (options.check) {
-      console.log('\n' + chalk.dim('使用 --no-check 或省略参数进行升级'));
+      console.log('\n' + chalk.dim('Run without --check to upgrade'));
       return;
     }
 
@@ -229,13 +187,13 @@ export const upgradeCommand = new Command('upgrade')
       {
         type: 'confirm',
         name: 'confirm',
-        message: '确认升级到最新版本?',
+        message: 'Upgrade to latest version?',
         default: true,
       },
     ]);
 
     if (!confirm) {
-      console.log(chalk.dim('\n升级已取消'));
+      console.log(chalk.dim('\nUpgrade cancelled'));
       return;
     }
 
@@ -243,16 +201,21 @@ export const upgradeCommand = new Command('upgrade')
     console.log('');
 
     const state = await detector.detect();
+    const autoInstall = options.auto || false;
 
     if (updates.flowUpdate) {
-      console.log(chalk.cyan.bold('\n━ 升级 Sylphx Flow\n'));
-      await upgradeManager.upgradeFlow(state);
+      console.log(chalk.cyan.bold('\n━ Upgrading Sylphx Flow\n'));
+      await upgradeManager.upgradeFlow(state, autoInstall);
     }
 
     if (updates.targetUpdate && options.target) {
-      console.log(chalk.cyan.bold('\n━ 升级 Target\n'));
-      await upgradeManager.upgradeTarget(state);
+      console.log(chalk.cyan.bold('\n━ Upgrading Target\n'));
+      await upgradeManager.upgradeTarget(state, autoInstall);
     }
 
-    console.log(chalk.green('\n✓ 升级完成\n'));
+    console.log(chalk.green('\n✓ Upgrade complete\n'));
+
+    if (!autoInstall) {
+      console.log(chalk.dim('💡 Tip: Use --auto flag to automatically install updates via npm\n'));
+    }
   });