@sylphx/flow 1.8.2 → 2.1.0

package/src/index.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env bun
 /**
- * Sylphx Flow - Legacy CLI
- * Project initialization and development flow management
+ * Sylphx Flow CLI
+ * AI-powered development flow management
  */
 
 import { readFileSync } from 'node:fs';
@@ -16,7 +16,9 @@ import {
   doctorCommand,
   upgradeCommand,
 } from './commands/flow-command.js';
-import { executeFlow } from './commands/flow/execute.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
 const __filename = fileURLToPath(import.meta.url);
@@ -52,36 +54,13 @@ export function createCLI(): Command {
   // 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)')
-    .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)')
-    .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)')
-    .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')
     .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 mode options
-    .option('--loop [seconds]', 'Loop mode: wait N seconds between runs (default: 0 = immediate)', (value) => {
-      // If no value provided, default to 0 (no wait time)
-      return value ? parseInt(value) : 0;
-    })
-    .option('--max-runs <count>', 'Maximum iterations before stopping (default: infinite)', parseInt)
+    .option('--merge', 'Merge Flow settings with existing settings (default: replace all)')
 
     .action(async (prompt, options) => {
       await executeFlow(prompt, options);
@@ -94,6 +73,7 @@ export function createCLI(): Command {
   program.addCommand(doctorCommand);
   program.addCommand(upgradeCommand);
   program.addCommand(hookCommand);
+  program.addCommand(settingsCommand);
 
   return program;
 }
@@ -168,6 +148,12 @@ function setupGlobalErrorHandling(): void {
  */
 function handleCommandError(error: unknown): void {
   if (error instanceof Error) {
+    // Handle user cancellation gracefully
+    if (error instanceof UserCancelledError) {
+      console.log('\n⚠️  Operation cancelled by user\n');
+      process.exit(0);
+    }
+
     // Handle Commander.js specific errors
     if (error.name === 'CommanderError') {
       const commanderError = error as any;

package/src/services/auto-upgrade.ts

@@ -0,0 +1,248 @@
+/**
+ * Auto-Upgrade Service
+ * Automatically checks and upgrades Flow and target CLI before each execution
+ */
+
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import chalk from 'chalk';
+import ora from 'ora';
+import { detectPackageManager, getUpgradeCommand } from '../utils/package-manager-detector.js';
+import { TargetInstaller } from './target-installer.js';
+
+const execAsync = promisify(exec);
+
+export interface UpgradeStatus {
+  flowNeedsUpgrade: boolean;
+  targetNeedsUpgrade: boolean;
+  flowVersion: { current: string; latest: string } | null;
+  targetVersion: { current: string; latest: string } | null;
+}
+
+export interface AutoUpgradeOptions {
+  verbose?: boolean;
+  skipFlow?: boolean;
+  skipTarget?: boolean;
+}
+
+export class AutoUpgrade {
+  private projectPath: string;
+  private options: AutoUpgradeOptions;
+  private targetInstaller: TargetInstaller;
+
+  constructor(projectPath: string = process.cwd(), options: AutoUpgradeOptions = {}) {
+    this.projectPath = projectPath;
+    this.options = options;
+    this.targetInstaller = new TargetInstaller(projectPath);
+  }
+
+  /**
+   * Check for available upgrades for Flow and target CLI
+   * @param targetId - Optional target CLI ID to check for upgrades
+   * @returns Upgrade status indicating what needs upgrading
+   */
+  async checkForUpgrades(targetId?: string): Promise<UpgradeStatus> {
+    const [flowVersion, targetVersion] = await Promise.all([
+      this.options.skipFlow ? null : this.checkFlowVersion(),
+      this.options.skipTarget || !targetId ? null : this.checkTargetVersion(targetId),
+    ]);
+
+    return {
+      flowNeedsUpgrade: !!flowVersion,
+      targetNeedsUpgrade: !!targetVersion,
+      flowVersion,
+      targetVersion,
+    };
+  }
+
+  /**
+   * Check Flow version
+   */
+  private async checkFlowVersion(): Promise<{ current: string; latest: string } | null> {
+    try {
+      // Get current version from package.json
+      const packageJsonPath = path.join(__dirname, '..', '..', 'package.json');
+      const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf-8'));
+      const currentVersion = packageJson.version;
+
+      // Get latest version from npm
+      const { stdout } = await execAsync('npm view @sylphx/flow version');
+      const latestVersion = stdout.trim();
+
+      if (currentVersion !== latestVersion) {
+        return { current: currentVersion, latest: latestVersion };
+      }
+
+      return null;
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Check target CLI version
+   */
+  private async checkTargetVersion(
+    targetId: string
+  ): Promise<{ current: string; latest: string } | null> {
+    const installation = this.targetInstaller.getInstallationInfo(targetId);
+    if (!installation) {
+      return null;
+    }
+
+    try {
+      // Get current version
+      const { stdout: currentOutput } = await execAsync(installation.checkCommand);
+      const currentMatch = currentOutput.match(/v?(\d+\.\d+\.\d+)/);
+      if (!currentMatch) {
+        return null;
+      }
+      const currentVersion = currentMatch[1];
+
+      // Get latest version from npm
+      const { stdout: latestOutput } = await execAsync(`npm view ${installation.package} version`);
+      const latestVersion = latestOutput.trim();
+
+      if (currentVersion !== latestVersion) {
+        return { current: currentVersion, latest: latestVersion };
+      }
+
+      return null;
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Upgrade Flow to latest version using detected package manager
+   * @returns True if upgrade successful, false otherwise
+   */
+  async upgradeFlow(): Promise<boolean> {
+    const packageManager = detectPackageManager(this.projectPath);
+    const spinner = ora('Upgrading Flow...').start();
+
+    try {
+      const upgradeCmd = getUpgradeCommand('@sylphx/flow', packageManager);
+      await execAsync(upgradeCmd);
+
+      spinner.succeed(chalk.green('✓ Flow upgraded to latest version'));
+      return true;
+    } catch (error) {
+      spinner.fail(chalk.red('✗ Flow upgrade failed'));
+
+      if (this.options.verbose) {
+        console.error(error);
+      }
+
+      return false;
+    }
+  }
+
+  /**
+   * Upgrade target CLI to latest version
+   * Tries built-in upgrade command first, falls back to package manager
+   * @param targetId - Target CLI ID to upgrade
+   * @returns True if upgrade successful, false otherwise
+   */
+  async upgradeTarget(targetId: string): Promise<boolean> {
+    const installation = this.targetInstaller.getInstallationInfo(targetId);
+    if (!installation) {
+      return false;
+    }
+
+    const packageManager = detectPackageManager(this.projectPath);
+    const spinner = ora(`Upgrading ${installation.name}...`).start();
+
+    try {
+      // For Claude Code, use built-in update command if available
+      if (targetId === 'claude-code') {
+        try {
+          await execAsync('claude update');
+          spinner.succeed(chalk.green(`✓ ${installation.name} upgraded`));
+          return true;
+        } catch {
+          // Fall back to npm upgrade
+        }
+      }
+
+      // For OpenCode, use built-in upgrade command if available
+      if (targetId === 'opencode') {
+        try {
+          await execAsync('opencode upgrade');
+          spinner.succeed(chalk.green(`✓ ${installation.name} upgraded`));
+          return true;
+        } catch {
+          // Fall back to npm upgrade
+        }
+      }
+
+      // Fall back to npm/bun/pnpm/yarn upgrade
+      const upgradeCmd = getUpgradeCommand(installation.package, packageManager);
+      await execAsync(upgradeCmd);
+
+      spinner.succeed(chalk.green(`✓ ${installation.name} upgraded`));
+      return true;
+    } catch (error) {
+      spinner.fail(chalk.red(`✗ ${installation.name} upgrade failed`));
+
+      if (this.options.verbose) {
+        console.error(error);
+      }
+
+      return false;
+    }
+  }
+
+  /**
+   * Run auto-upgrade check and upgrade if needed
+   * Shows upgrade status and performs upgrades automatically
+   * @param targetId - Optional target CLI ID to check and upgrade
+   */
+  async runAutoUpgrade(targetId?: string): Promise<void> {
+    console.log(chalk.cyan('🔄 Checking for updates...\n'));
+
+    const status = await this.checkForUpgrades(targetId);
+
+    // Show upgrade status
+    if (status.flowNeedsUpgrade && status.flowVersion) {
+      console.log(
+        chalk.yellow(
+          `📦 Flow update available: ${status.flowVersion.current} → ${status.flowVersion.latest}`
+        )
+      );
+    } else if (!this.options.skipFlow) {
+      console.log(chalk.green('✓ Flow is up to date'));
+    }
+
+    if (status.targetNeedsUpgrade && status.targetVersion && targetId) {
+      const installation = this.targetInstaller.getInstallationInfo(targetId);
+      console.log(
+        chalk.yellow(
+          `📦 ${installation?.name} update available: ${status.targetVersion.current} → ${status.targetVersion.latest}`
+        )
+      );
+    } else if (!this.options.skipTarget && targetId) {
+      const installation = this.targetInstaller.getInstallationInfo(targetId);
+      console.log(chalk.green(`✓ ${installation?.name} is up to date`));
+    }
+
+    // Perform upgrades if needed
+    if (status.flowNeedsUpgrade || status.targetNeedsUpgrade) {
+      console.log(chalk.cyan('\n📦 Installing updates...\n'));
+
+      if (status.flowNeedsUpgrade) {
+        await this.upgradeFlow();
+      }
+
+      if (status.targetNeedsUpgrade && targetId) {
+        await this.upgradeTarget(targetId);
+      }
+
+      console.log(chalk.green('\n✓ All tools upgraded\n'));
+    } else {
+      console.log();
+    }
+  }
+}

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

@@ -0,0 +1,220 @@
+/**
+ * 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();
+  }
+}