@sylphx/flow 2.1.3 → 2.1.5

package/src/services/first-run-setup.ts

@@ -1,220 +0,0 @@
-/**
- * First Run Setup
- * Quick configuration wizard for new users
- */
-
-import chalk from 'chalk';
-import inquirer from 'inquirer';
-import { GlobalConfigService } from './global-config.js';
-import { UserCancelledError } from '../utils/errors.js';
-
-export interface QuickSetupResult {
-  target: 'claude-code' | 'opencode';
-  provider?: 'default' | 'kimi' | 'zai' | 'ask-every-time';
-  mcpServers: string[];
-  apiKeys: Record<string, Record<string, string>>;
-}
-
-export class FirstRunSetup {
-  private configService: GlobalConfigService;
-
-  constructor() {
-    this.configService = new GlobalConfigService();
-  }
-
-  /**
-   * Run setup wizard
-   */
-  async run(): Promise<QuickSetupResult> {
-    try {
-      console.log(chalk.cyan.bold('\n╭─────────────────────────────────────────────────╮'));
-      console.log(chalk.cyan.bold('│                                                 │'));
-      console.log(chalk.cyan.bold('│  Welcome to Sylphx Flow!                        │'));
-      console.log(chalk.cyan.bold('│  Let\'s configure your environment               │'));
-      console.log(chalk.cyan.bold('│                                                 │'));
-      console.log(chalk.cyan.bold('╰─────────────────────────────────────────────────╯\n'));
-
-    // Step 1: Select target platform
-    console.log(chalk.cyan('🔧 Setup (1/3) - Target Platform\n'));
-    const { target } = await inquirer.prompt([
-      {
-        type: 'list',
-        name: 'target',
-        message: 'Select your preferred platform:',
-        choices: [
-          { name: 'Claude Code', value: 'claude-code' },
-          { name: 'OpenCode', value: 'opencode' },
-        ],
-        default: 'claude-code',
-      },
-    ]);
-
-    let provider: string | undefined = 'ask-every-time';
-    const apiKeys: Record<string, Record<string, string>> = {};
-
-    // Step 2: Provider setup (Claude Code only)
-    if (target === 'claude-code') {
-      console.log(chalk.cyan('\n🔧 Setup (2/3) - Provider\n'));
-      const { selectedProvider } = await inquirer.prompt([
-        {
-          type: 'list',
-          name: 'selectedProvider',
-          message: 'Select your preferred provider:',
-          choices: [
-            { name: 'Ask me every time', value: 'ask-every-time' },
-            { name: 'Default (Claude Code built-in)', value: 'default' },
-            { name: 'Kimi (requires API key)', value: 'kimi' },
-            { name: 'Z.ai (requires API key)', value: 'zai' },
-          ],
-          default: 'ask-every-time',
-        },
-      ]);
-
-      provider = selectedProvider;
-
-      // Configure API key if needed
-      if (provider === 'kimi' || provider === 'zai') {
-        const { apiKey } = await inquirer.prompt([
-          {
-            type: 'password',
-            name: 'apiKey',
-            message: provider === 'kimi' ? 'Enter Kimi API key:' : 'Enter Z.ai API key:',
-            mask: '*',
-          },
-        ]);
-
-        apiKeys[provider] = { apiKey };
-      }
-    }
-
-    // Step 3: MCP Servers
-    const stepNumber = target === 'claude-code' ? '3/3' : '2/2';
-    console.log(chalk.cyan('\n🔧 Setup (' + stepNumber + ') - MCP Servers\n'));
-
-    const { mcpServers } = await inquirer.prompt([
-      {
-        type: 'checkbox',
-        name: 'mcpServers',
-        message: 'Select MCP servers to enable:',
-        choices: [
-          { name: 'GitHub Code Search (grep.app)', value: 'grep', checked: true },
-          { name: 'Context7 Docs', value: 'context7', checked: true },
-          { name: 'Playwright Browser Control', value: 'playwright', checked: true },
-          { name: 'GitHub (requires GITHUB_TOKEN)', value: 'github' },
-          { name: 'Notion (requires NOTION_API_KEY)', value: 'notion' },
-        ],
-      },
-    ]);
-
-    // Configure MCP API keys
-    const mcpServerRequirements: Record<string, string[]> = {
-      github: ['GITHUB_TOKEN'],
-      notion: ['NOTION_API_KEY'],
-    };
-
-    for (const serverKey of mcpServers) {
-      const requirements = mcpServerRequirements[serverKey];
-      if (requirements) {
-        const configMessage = 'Configure ' + requirements[0] + ' for ' + serverKey + '?';
-        const { shouldConfigure } = await inquirer.prompt([
-          {
-            type: 'confirm',
-            name: 'shouldConfigure',
-            message: configMessage,
-            default: true,
-          },
-        ]);
-
-        if (shouldConfigure) {
-          const questions = requirements.map((key) => {
-            return {
-              type: 'password' as const,
-              name: key,
-              message: 'Enter ' + key + ':',
-              mask: '*',
-            };
-          });
-          const answers = await inquirer.prompt(questions);
-
-          apiKeys[serverKey] = answers;
-        }
-      }
-    }
-
-    // Save configuration
-    await this.saveConfiguration({
-      target,
-      provider,
-      mcpServers,
-      apiKeys,
-    });
-
-    console.log(chalk.green('\n✓ Configuration saved to ~/.sylphx-flow/\n'));
-
-    return {
-      target,
-      provider: provider as any,
-      mcpServers,
-      apiKeys,
-    };
-    } catch (error: any) {
-      // Handle user cancellation (Ctrl+C)
-      if (error.name === 'ExitPromptError' || error.message?.includes('force closed')) {
-        throw new UserCancelledError('Setup cancelled by user');
-      }
-      throw error;
-    }
-  }
-
-  /**
-   * Save configuration to global config files
-   */
-  private async saveConfiguration(result: QuickSetupResult): Promise<void> {
-    // Save global settings
-    await this.configService.saveSettings({
-      version: '1.0.0',
-      defaultTarget: result.target,
-      firstRun: false,
-      lastUpdated: new Date().toISOString(),
-    });
-
-    // Save provider config (Claude Code)
-    if (result.target === 'claude-code' && result.provider) {
-      const providerConfig = await this.configService.loadProviderConfig();
-      providerConfig.claudeCode.defaultProvider = result.provider;
-
-      // Save API keys
-      if (result.provider === 'kimi' && result.apiKeys.kimi) {
-        providerConfig.claudeCode.providers.kimi = {
-          apiKey: result.apiKeys.kimi.apiKey,
-          enabled: true,
-        };
-      }
-      if (result.provider === 'zai' && result.apiKeys.zai) {
-        providerConfig.claudeCode.providers.zai = {
-          apiKey: result.apiKeys.zai.apiKey,
-          enabled: true,
-        };
-      }
-
-      await this.configService.saveProviderConfig(providerConfig);
-    }
-
-    // Save MCP config
-    const mcpConfig = await this.configService.loadMCPConfig();
-    for (const serverKey of result.mcpServers) {
-      mcpConfig.servers[serverKey] = {
-        enabled: true,
-        env: result.apiKeys[serverKey] || {},
-      };
-    }
-    await this.configService.saveMCPConfig(mcpConfig);
-  }
-
-  /**
-   * Check if we should run quick setup
-   */
-  async shouldRun(): Promise<boolean> {
-    return await this.configService.isFirstRun();
-  }
-}

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

@@ -1,269 +0,0 @@
-/**
- * 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 (only save API keys, no defaults)
-    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 });
-  }
-
-
-  /**
-   * Runtime selection - choose provider and agent for this run
-   *
-   * DESIGN PRINCIPLE: Always Ask (Simple & Explicit)
-   * - Has args (--provider/--agent) → Use them directly
-   * - No args → Always prompt user
-   * - Never save runtime choices as defaults
-   */
-  static async selectRuntimeChoices(options: SmartConfigOptions): Promise<RuntimeChoices> {
-    const config = await ConfigService.loadConfiguration();
-    const choices: RuntimeChoices = {};
-
-    // Handle provider selection
-    if (options.provider) {
-      // Explicit option provided via args
-      choices.provider = options.provider;
-    } else {
-      // Always prompt
-      choices.provider = await this.selectProvider(config.user);
-    }
-
-    // Handle agent selection
-    if (options.agent) {
-      // Explicit option provided via args
-      choices.agent = options.agent;
-    } else {
-      // Always prompt
-      choices.agent = await this.selectAgent();
-    }
-
-    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'] },
-    ];
-
-    const { provider } = await inquirer.prompt([
-      {
-        type: 'list',
-        name: 'provider',
-        message: 'Select provider:',
-        choices: allProviders.map(p => ({
-          name: p.hasKey ? p.name : `${p.name} (Need API key)`,
-          value: p.id,
-        })),
-        default: '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(): Promise<string> {
-    try {
-      const agents = await loadAllAgents(process.cwd());
-
-      if (agents.length === 0) {
-        console.log(chalk.yellow('⚠  No agents found, using "coder"'));
-        return 'coder';
-      }
-
-      const { agent } = await inquirer.prompt([
-        {
-          type: 'list',
-          name: 'agent',
-          message: 'Select agent:',
-          choices: agents.map(a => ({
-            name: a.metadata.name || a.id,
-            value: a.id,
-          })),
-          default: 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}`));
-  }
-}

package/src/types/api.types.ts

@@ -1,9 +0,0 @@
-/**
- * Backward compatibility layer for API types
- * Re-exports from the organized API types module
- *
- * @deprecated Import from './types/api' instead
- */
-
-// Re-export everything from the organized API types module
-export * from './types/api/index.js';