@sylphx/flow 1.8.1 → 2.0.0

package/src/index.ts

@@ -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/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();
+  }
+}

package/src/services/global-config.ts

@@ -0,0 +1,337 @@
+/**
+ * Global Configuration Service
+ * Manages all Flow settings in ~/.sylphx-flow/
+ */
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import { existsSync } from 'node:fs';
+
+export interface GlobalSettings {
+  version: string;
+  defaultTarget?: 'claude-code' | 'opencode';
+  defaultAgent?: string; // Default agent to use (e.g., 'coder', 'writer', 'reviewer', 'orchestrator')
+  firstRun: boolean;
+  lastUpdated: string;
+}
+
+export interface AgentConfig {
+  enabled: boolean;
+}
+
+export interface RuleConfig {
+  enabled: boolean;
+}
+
+export interface OutputStyleConfig {
+  enabled: boolean;
+}
+
+export interface FlowConfig {
+  version: string;
+  agents: Record<string, AgentConfig>; // e.g., { coder: { enabled: true }, writer: { enabled: false } }
+  rules: Record<string, RuleConfig>; // e.g., { core: { enabled: true }, workspace: { enabled: true } }
+  outputStyles: Record<string, OutputStyleConfig>; // e.g., { silent: { enabled: true } }
+}
+
+export interface ProviderConfig {
+  claudeCode: {
+    defaultProvider: 'default' | 'kimi' | 'zai' | 'ask-every-time';
+    providers: {
+      kimi?: {
+        apiKey?: string;
+        enabled: boolean;
+      };
+      zai?: {
+        apiKey?: string;
+        enabled: boolean;
+      };
+    };
+  };
+}
+
+export interface MCPServerConfig {
+  enabled: boolean;
+  command?: string;
+  args?: string[];
+  env?: Record<string, string>;
+}
+
+export interface MCPConfig {
+  version: string;
+  servers: Record<string, MCPServerConfig>;
+}
+
+export class GlobalConfigService {
+  private flowHomeDir: string;
+
+  constructor() {
+    this.flowHomeDir = path.join(os.homedir(), '.sylphx-flow');
+  }
+
+  /**
+   * Get Flow home directory
+   */
+  getFlowHomeDir(): string {
+    return this.flowHomeDir;
+  }
+
+  /**
+   * Initialize Flow home directory structure
+   */
+  async initialize(): Promise<void> {
+    const dirs = [
+      this.flowHomeDir,
+      path.join(this.flowHomeDir, 'sessions'),
+      path.join(this.flowHomeDir, 'backups'),
+      path.join(this.flowHomeDir, 'secrets'),
+    ];
+
+    for (const dir of dirs) {
+      await fs.mkdir(dir, { recursive: true });
+    }
+  }
+
+  /**
+   * Get global settings file path
+   */
+  private getSettingsPath(): string {
+    return path.join(this.flowHomeDir, 'settings.json');
+  }
+
+  /**
+   * Get provider config file path
+   */
+  private getProviderConfigPath(): string {
+    return path.join(this.flowHomeDir, 'provider-config.json');
+  }
+
+  /**
+   * Get MCP config file path
+   */
+  private getMCPConfigPath(): string {
+    return path.join(this.flowHomeDir, 'mcp-config.json');
+  }
+
+  /**
+   * Get Flow config file path
+   */
+  private getFlowConfigPath(): string {
+    return path.join(this.flowHomeDir, 'flow-config.json');
+  }
+
+  /**
+   * Check if this is first run
+   */
+  async isFirstRun(): Promise<boolean> {
+    const settingsPath = this.getSettingsPath();
+    if (!existsSync(settingsPath)) {
+      return true;
+    }
+
+    try {
+      const settings = await this.loadSettings();
+      return settings.firstRun !== false;
+    } catch {
+      return true;
+    }
+  }
+
+  /**
+   * Load global settings
+   */
+  async loadSettings(): Promise<GlobalSettings> {
+    const settingsPath = this.getSettingsPath();
+
+    if (!existsSync(settingsPath)) {
+      return {
+        version: '1.0.0',
+        firstRun: true,
+        lastUpdated: new Date().toISOString(),
+      };
+    }
+
+    const data = await fs.readFile(settingsPath, 'utf-8');
+    return JSON.parse(data);
+  }
+
+  /**
+   * Save global settings
+   */
+  async saveSettings(settings: GlobalSettings): Promise<void> {
+    await this.initialize();
+    const settingsPath = this.getSettingsPath();
+    settings.lastUpdated = new Date().toISOString();
+    await fs.writeFile(settingsPath, JSON.stringify(settings, null, 2));
+  }
+
+  /**
+   * Load provider config
+   */
+  async loadProviderConfig(): Promise<ProviderConfig> {
+    const configPath = this.getProviderConfigPath();
+
+    if (!existsSync(configPath)) {
+      return {
+        claudeCode: {
+          defaultProvider: 'ask-every-time',
+          providers: {
+            kimi: { enabled: false },
+            zai: { enabled: false },
+          },
+        },
+      };
+    }
+
+    const data = await fs.readFile(configPath, 'utf-8');
+    return JSON.parse(data);
+  }
+
+  /**
+   * Save provider config
+   */
+  async saveProviderConfig(config: ProviderConfig): Promise<void> {
+    await this.initialize();
+    const configPath = this.getProviderConfigPath();
+    await fs.writeFile(configPath, JSON.stringify(config, null, 2));
+  }
+
+  /**
+   * Load MCP config
+   */
+  async loadMCPConfig(): Promise<MCPConfig> {
+    const configPath = this.getMCPConfigPath();
+
+    if (!existsSync(configPath)) {
+      return {
+        version: '1.0.0',
+        servers: {},
+      };
+    }
+
+    const data = await fs.readFile(configPath, 'utf-8');
+    return JSON.parse(data);
+  }
+
+  /**
+   * Save MCP config
+   */
+  async saveMCPConfig(config: MCPConfig): Promise<void> {
+    await this.initialize();
+    const configPath = this.getMCPConfigPath();
+    await fs.writeFile(configPath, JSON.stringify(config, null, 2));
+  }
+
+  /**
+   * Get enabled MCP servers
+   */
+  async getEnabledMCPServers(): Promise<Record<string, MCPServerConfig>> {
+    const config = await this.loadMCPConfig();
+    const enabled: Record<string, MCPServerConfig> = {};
+
+    for (const [name, serverConfig] of Object.entries(config.servers)) {
+      if (serverConfig.enabled) {
+        enabled[name] = serverConfig;
+      }
+    }
+
+    return enabled;
+  }
+
+  /**
+   * Load Flow config (agents, rules, output styles)
+   */
+  async loadFlowConfig(): Promise<FlowConfig> {
+    const configPath = this.getFlowConfigPath();
+
+    if (!existsSync(configPath)) {
+      // Default: all agents, all rules, all output styles enabled
+      return {
+        version: '1.0.0',
+        agents: {
+          coder: { enabled: true },
+          writer: { enabled: true },
+          reviewer: { enabled: true },
+          orchestrator: { enabled: true },
+        },
+        rules: {
+          core: { enabled: true },
+          'code-standards': { enabled: true },
+          workspace: { enabled: true },
+        },
+        outputStyles: {
+          silent: { enabled: true },
+        },
+      };
+    }
+
+    const data = await fs.readFile(configPath, 'utf-8');
+    return JSON.parse(data);
+  }
+
+  /**
+   * Save Flow config
+   */
+  async saveFlowConfig(config: FlowConfig): Promise<void> {
+    await this.initialize();
+    const configPath = this.getFlowConfigPath();
+    await fs.writeFile(configPath, JSON.stringify(config, null, 2));
+  }
+
+  /**
+   * Get enabled agents
+   */
+  async getEnabledAgents(): Promise<string[]> {
+    const config = await this.loadFlowConfig();
+    return Object.entries(config.agents)
+      .filter(([_, agentConfig]) => agentConfig.enabled)
+      .map(([name]) => name);
+  }
+
+  /**
+   * Get enabled rules
+   */
+  async getEnabledRules(): Promise<string[]> {
+    const config = await this.loadFlowConfig();
+    return Object.entries(config.rules)
+      .filter(([_, ruleConfig]) => ruleConfig.enabled)
+      .map(([name]) => name);
+  }
+
+  /**
+   * Get enabled output styles
+   */
+  async getEnabledOutputStyles(): Promise<string[]> {
+    const config = await this.loadFlowConfig();
+    return Object.entries(config.outputStyles)
+      .filter(([_, styleConfig]) => styleConfig.enabled)
+      .map(([name]) => name);
+  }
+
+  /**
+   * Update default target
+   */
+  async setDefaultTarget(target: 'claude-code' | 'opencode'): Promise<void> {
+    const settings = await this.loadSettings();
+    settings.defaultTarget = target;
+    await this.saveSettings(settings);
+  }
+
+  /**
+   * Get default target
+   */
+  async getDefaultTarget(): Promise<'claude-code' | 'opencode' | undefined> {
+    const settings = await this.loadSettings();
+    return settings.defaultTarget;
+  }
+
+  /**
+   * Mark first run as complete
+   */
+  async markFirstRunComplete(): Promise<void> {
+    const settings = await this.loadSettings();
+    settings.firstRun = false;
+    await this.saveSettings(settings);
+  }
+}