@sylphx/flow 1.0.2 → 1.0.4

package/src/services/smart-config-service.ts

@@ -0,0 +1,385 @@
+/**
+ * Smart Configuration Service
+ * Handles intelligent provider and agent selection with user preferences
+ */
+
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { ConfigService, UserSettings, RuntimeChoices } from './config-service.js';
+import { loadAllAgents } from '../core/agent-loader.js';
+
+export interface SmartConfigOptions {
+  selectProvider?: boolean;
+  selectAgent?: boolean;
+  useDefaults?: boolean;
+  provider?: string;
+  agent?: string;
+}
+
+export class SmartConfigService {
+  /**
+   * Initial setup - configure API keys once
+   */
+  static async initialSetup(): Promise<void> {
+    console.log(chalk.cyan.bold('🔑 Initial Setup - Configure API Keys\n'));
+
+    const userSettings = await ConfigService.loadHomeSettings();
+    const apiKeys = userSettings.apiKeys || {};
+
+    // Configure providers
+    const providers = [
+      { id: 'kimi', name: 'Kimi', hasKey: !!apiKeys.kimi },
+      { id: 'z.ai', name: 'Z.ai (Recommended)', hasKey: !!apiKeys['z.ai'] },
+    ];
+
+    const missingProviders = providers.filter(p => !p.hasKey);
+    const existingProviders = providers.filter(p => p.hasKey);
+
+    // Ask which providers to configure
+    console.log(chalk.cyan('Available providers:\n'));
+    console.log(chalk.dim('  • Default (uses Claude Code configuration)'));
+    providers.forEach(p => {
+      const status = p.hasKey ? chalk.green('✓') : chalk.yellow('○');
+      console.log(`  ${status} ${p.name}`);
+    });
+    console.log('');
+
+    const { selectedProvider } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'selectedProvider',
+        message: 'Select provider:',
+        choices: [
+          {
+            name: 'Default (Use Claude Code configuration)',
+            value: 'default',
+          },
+          {
+            name: 'Kimi',
+            value: 'kimi',
+          },
+          {
+            name: 'Z.ai (Recommended)',
+            value: 'z.ai',
+          },
+        ],
+      },
+    ]);
+
+    if (selectedProvider !== 'default') {
+      await this.configureSelectedProviders([selectedProvider], apiKeys);
+    } else {
+      console.log(chalk.dim('Using Claude Code default configuration.'));
+    }
+
+    if (existingProviders.length > 0) {
+      console.log(chalk.green('\n✅ Already configured:'));
+      existingProviders.forEach(p => {
+        console.log(chalk.dim(`  • ${p.name}`));
+      });
+    }
+
+    // Mark setup as completed (no need for default preferences prompt)
+    await ConfigService.saveHomeSettings({ hasCompletedSetup: true });
+    console.log(chalk.green('\n✓ Setup complete!\n'));
+  }
+
+  /**
+   * Configure selected providers
+   */
+  private static async configureSelectedProviders(
+    selectedProviders: string[],
+    existingApiKeys: any
+  ): Promise<void> {
+    for (const providerId of selectedProviders) {
+      const providerName = providerId === 'kimi' ? 'Kimi' : 'Z.ai';
+      console.log(chalk.cyan(`\n📋 Configure ${providerName}\n`));
+
+      const { apiKey } = await inquirer.prompt([
+        {
+          type: 'password',
+          name: 'apiKey',
+          message: `Enter API Key for ${providerName}:`,
+          mask: '*',
+          validate: (input) => input.length > 10 || 'API Key appears too short',
+        },
+      ]);
+
+      existingApiKeys[providerId] = apiKey;
+      console.log(chalk.green(`✓ API Key configured for ${providerName}`));
+    }
+
+    // Save all API keys
+    await ConfigService.saveHomeSettings({ apiKeys: existingApiKeys });
+  }
+
+  /**
+   * Setup default preferences
+   */
+  private static async setupDefaultPreferences(): Promise<void> {
+    console.log(chalk.cyan('⚙️  Setup Default Preferences\n'));
+
+    const userSettings = await ConfigService.loadHomeSettings();
+    const availableProviders = ConfigService.getAvailableProviders(userSettings);
+
+    if (availableProviders.length === 0) {
+      console.log(chalk.yellow('⚠  No API keys configured yet. Skipping preferences setup.'));
+      return;
+    }
+
+    const { setupDefaults } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'setupDefaults',
+        message: 'Set up default preferences?',
+        default: true,
+      },
+    ]);
+
+    if (!setupDefaults) {
+      console.log(chalk.dim('Skipping preferences setup.'));
+      return;
+    }
+
+    // Select default provider
+    if (availableProviders.length > 1) {
+      const { defaultProvider } = await inquirer.prompt([
+        {
+          type: 'list',
+          name: 'defaultProvider',
+          message: 'Select default provider:',
+          choices: availableProviders.map(p => ({
+            name: p.charAt(0).toUpperCase() + p.slice(1),
+            value: p,
+          })),
+          default: userSettings.defaultProvider || availableProviders[0],
+        },
+      ]);
+
+      userSettings.defaultProvider = defaultProvider;
+    }
+
+    // Set default agent (will use dynamic loading)
+    const { useDefaultAgent } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'useDefaultAgent',
+        message: 'Set default agent?',
+        default: true,
+      },
+    ]);
+
+    if (useDefaultAgent) {
+      try {
+        const agents = await loadAllAgents(process.cwd());
+        if (agents.length > 0) {
+          const { defaultAgent } = await inquirer.prompt([
+            {
+              type: 'list',
+              name: 'defaultAgent',
+              message: 'Select default agent:',
+              choices: agents.map(a => ({
+                name: a.metadata.name || a.id,
+                value: a.id,
+              })),
+              default: userSettings.defaultAgent || (agents.find(a => a.id === 'coder')?.id || agents[0].id),
+            },
+          ]);
+
+          userSettings.defaultAgent = defaultAgent;
+        }
+      } catch (error) {
+        console.log(chalk.yellow('⚠  Could not load agents, using "coder" as default'));
+        userSettings.defaultAgent = 'coder';
+      }
+    }
+
+    await ConfigService.saveHomeSettings(userSettings);
+    console.log(chalk.green('✓ Default preferences saved'));
+  }
+
+  /**
+   * Runtime selection - choose provider and agent for this run
+   *
+   * DESIGN PRINCIPLE: Smart Defaults
+   * - Has saved default → Use it (no prompt)
+   * - No saved default → Prompt user
+   * - Explicit flag (--select-provider/--select-agent) → Force prompt (override)
+   * - Explicit option (--provider/--agent) → Use specified value
+   */
+  static async selectRuntimeChoices(options: SmartConfigOptions): Promise<RuntimeChoices> {
+    const config = await ConfigService.loadConfiguration();
+    const choices: RuntimeChoices = {};
+
+    // Handle provider selection
+    if (options.provider) {
+      // 1. Explicit option provided
+      choices.provider = options.provider;
+    } else if (options.selectProvider) {
+      // 2. Force selection (override defaults)
+      choices.provider = await this.selectProvider(config.user);
+    } else if (config.user.defaultProvider) {
+      // 3. Use saved default (SMART DEFAULT - no prompt needed)
+      choices.provider = config.user.defaultProvider;
+      console.log(chalk.dim(`  ✓ Provider: ${choices.provider}`));
+    } else {
+      // 4. No default saved, must prompt
+      choices.provider = await this.selectProvider(config.user);
+    }
+
+    // Handle agent selection
+    if (options.agent) {
+      // 1. Explicit option provided
+      choices.agent = options.agent;
+    } else if (options.selectAgent) {
+      // 2. Force selection (override defaults)
+      choices.agent = await this.selectAgent(config.user.defaultAgent);
+    } else if (config.user.defaultAgent) {
+      // 3. Use saved default (SMART DEFAULT - no prompt needed)
+      choices.agent = config.user.defaultAgent;
+      console.log(chalk.dim(`  ✓ Agent: ${choices.agent}`));
+    } else {
+      // 4. No default saved, must prompt
+      choices.agent = await this.selectAgent(config.user.defaultAgent);
+    }
+
+    // Save choices for next time
+    await ConfigService.saveHomeSettings({
+      defaultProvider: choices.provider,
+      defaultAgent: choices.agent,
+    });
+
+    return choices;
+  }
+
+  /**
+   * Select provider for this run
+   */
+  private static async selectProvider(userSettings: UserSettings): Promise<string> {
+    const apiKeys = userSettings.apiKeys || {};
+
+    // Always show all 3 providers
+    const allProviders = [
+      { id: 'default', name: 'Default (Claude Code configuration)', hasKey: true },
+      { id: 'kimi', name: 'Kimi', hasKey: !!apiKeys.kimi },
+      { id: 'z.ai', name: 'Z.ai (Recommended)', hasKey: !!apiKeys['z.ai'] },
+    ];
+
+    // Show last used provider hint
+    const lastUsed = userSettings.defaultProvider;
+    const message = lastUsed
+      ? `Select provider (last used: ${lastUsed}):`
+      : 'Select provider:';
+
+    const { provider } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'provider',
+        message,
+        choices: allProviders.map(p => ({
+          name: p.hasKey ? p.name : `${p.name} (Need API key)`,
+          value: p.id,
+        })),
+        default: lastUsed || 'default',
+      },
+    ]);
+
+    // If user selected a provider without API key, prompt for it
+    if (provider !== 'default' && !apiKeys[provider]) {
+      console.log(chalk.cyan(`\n🔑 Configure ${provider} API key:\n`));
+      const { apiKey } = await inquirer.prompt([
+        {
+          type: 'password',
+          name: 'apiKey',
+          message: `Enter API Key for ${provider}:`,
+          mask: '*',
+          validate: (input) => input.length > 10 || 'API Key appears too short',
+        },
+      ]);
+
+      // Save the API key
+      apiKeys[provider] = apiKey;
+      await ConfigService.saveHomeSettings({ apiKeys });
+      console.log(chalk.green(`✓ API Key saved for ${provider}\n`));
+    }
+
+    return provider;
+  }
+
+  /**
+   * Select agent for this run
+   */
+  private static async selectAgent(lastUsed?: string): Promise<string> {
+    try {
+      const agents = await loadAllAgents(process.cwd());
+
+      if (agents.length === 0) {
+        console.log(chalk.yellow('⚠  No agents found, using "coder"'));
+        return 'coder';
+      }
+
+      // Build message with last used hint
+      const message = lastUsed
+        ? `Select agent (last used: ${lastUsed}):`
+        : 'Select agent:';
+
+      const { agent } = await inquirer.prompt([
+        {
+          type: 'list',
+          name: 'agent',
+          message,
+          choices: agents.map(a => ({
+            name: a.metadata.name || a.id,
+            value: a.id,
+          })),
+          default: lastUsed || agents.find(a => a.id === 'coder')?.id || agents[0].id,
+        },
+      ]);
+
+      return agent;
+    } catch (error) {
+      console.log(chalk.yellow('⚠  Could not load agents, using "coder"'));
+      return 'coder';
+    }
+  }
+
+  /**
+   * Setup environment variables based on runtime choices
+   */
+  static async setupEnvironment(provider: string): Promise<void> {
+    const userSettings = await ConfigService.loadHomeSettings();
+    const apiKeys = userSettings.apiKeys || {};
+
+    if (provider !== 'default' && !apiKeys[provider]) {
+      throw new Error(`No API key configured for provider: ${provider}`);
+    }
+
+    const providerConfigs = {
+      default: {
+        description: 'Default (No Override)',
+      },
+      kimi: {
+        ANTHROPIC_BASE_URL: 'https://api.kimi.com/coding/',
+        description: 'Kimi',
+      },
+      'z.ai': {
+        ANTHROPIC_BASE_URL: 'https://api.z.ai/api/anthropic',
+        description: 'Z.ai Proxy',
+      },
+    };
+
+    // Setup environment based on provider
+    if (provider === 'default') {
+      // Don't override anything - use user's existing Claude Code configuration
+      console.log(chalk.dim('  ✓ Using Claude Code default configuration'));
+      return;
+    }
+
+    const config = providerConfigs[provider as keyof typeof providerConfigs];
+    process.env.ANTHROPIC_BASE_URL = config.ANTHROPIC_BASE_URL;
+    process.env.ANTHROPIC_AUTH_TOKEN = apiKeys[provider]; // Claude Code uses ANTHROPIC_AUTH_TOKEN, not ANTHROPIC_API_KEY
+
+    // Success message
+    console.log(chalk.green(`  ✓ Environment configured for ${provider}`));
+  }
+}