@sylphx/flow 1.8.2 → 2.1.0

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' | 'cursor' | 'ask-every-time';
+  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);
+  }
+}

package/src/services/target-installer.ts

@@ -0,0 +1,254 @@
+/**
+ * Target Installation Service
+ * Auto-detects and installs AI CLI tools (Claude Code, OpenCode, Cursor)
+ */
+
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+import chalk from 'chalk';
+import ora from 'ora';
+import inquirer from 'inquirer';
+import { detectPackageManager, type PackageManager } from '../utils/package-manager-detector.js';
+import { UserCancelledError } from '../utils/errors.js';
+
+const execAsync = promisify(exec);
+
+export interface TargetInstallation {
+  id: 'claude-code' | 'opencode' | 'cursor';
+  name: string;
+  package: string;
+  checkCommand: string;
+  installCommand: (pm: PackageManager) => string;
+}
+
+/**
+ * Supported target installations
+ */
+const TARGET_INSTALLATIONS: TargetInstallation[] = [
+  {
+    id: 'claude-code',
+    name: 'Claude Code',
+    package: '@anthropic-ai/claude-code',
+    checkCommand: 'claude --version',
+    installCommand: (pm: PackageManager) => {
+      switch (pm) {
+        case 'npm':
+          return 'npm install -g @anthropic-ai/claude-code';
+        case 'bun':
+          return 'bun install -g @anthropic-ai/claude-code';
+        case 'pnpm':
+          return 'pnpm install -g @anthropic-ai/claude-code';
+        case 'yarn':
+          return 'yarn global add @anthropic-ai/claude-code';
+      }
+    },
+  },
+  {
+    id: 'opencode',
+    name: 'OpenCode',
+    package: 'opencode-ai',
+    checkCommand: 'opencode --version',
+    installCommand: (pm: PackageManager) => {
+      switch (pm) {
+        case 'npm':
+          return 'npm install -g opencode-ai@latest';
+        case 'bun':
+          return 'bun install -g opencode-ai@latest';
+        case 'pnpm':
+          return 'pnpm install -g opencode-ai@latest';
+        case 'yarn':
+          return 'yarn global add opencode-ai@latest';
+      }
+    },
+  },
+  {
+    id: 'cursor',
+    name: 'Cursor',
+    package: 'cursor',
+    checkCommand: 'cursor --version',
+    installCommand: () => {
+      // Cursor is typically installed via installer, not npm
+      return 'Visit https://cursor.sh to download and install';
+    },
+  },
+];
+
+export class TargetInstaller {
+  private packageManager: PackageManager;
+
+  constructor(projectPath: string = process.cwd()) {
+    this.packageManager = detectPackageManager(projectPath);
+  }
+
+  /**
+   * Check if a target CLI is installed
+   * @param targetId - Target ID to check
+   * @returns True if installed, false otherwise
+   */
+  async isInstalled(targetId: string): Promise<boolean> {
+    const installation = TARGET_INSTALLATIONS.find((t) => t.id === targetId);
+    if (!installation) {
+      return false;
+    }
+
+    try {
+      await execAsync(installation.checkCommand);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Detect which target CLIs are currently installed
+   * @returns Array of installed target IDs
+   */
+  async detectInstalledTargets(): Promise<string[]> {
+    const installed: string[] = [];
+
+    for (const installation of TARGET_INSTALLATIONS) {
+      if (await this.isInstalled(installation.id)) {
+        installed.push(installation.id);
+      }
+    }
+
+    return installed;
+  }
+
+  /**
+   * Prompt user to select a target to install
+   * @returns Selected target ID
+   * @throws {UserCancelledError} If user cancels the prompt
+   */
+  async promptForTargetSelection(): Promise<string> {
+    try {
+      const { targetId } = await inquirer.prompt([
+        {
+          type: 'list',
+          name: 'targetId',
+          message: 'No AI CLI detected. Which would you like to use?',
+          choices: TARGET_INSTALLATIONS.map((t) => ({
+            name: t.name,
+            value: t.id,
+          })),
+          default: 'claude-code',
+        },
+      ]);
+
+      return targetId;
+    } catch (error: any) {
+      // Handle user cancellation (Ctrl+C)
+      if (error.name === 'ExitPromptError' || error.message?.includes('force closed')) {
+        throw new UserCancelledError('Target selection cancelled');
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Install a target CLI using detected package manager
+   * @param targetId - Target ID to install
+   * @param autoConfirm - Skip confirmation prompt if true
+   * @returns True if installation successful, false otherwise
+   * @throws {UserCancelledError} If user cancels installation
+   */
+  async install(targetId: string, autoConfirm: boolean = false): Promise<boolean> {
+    const installation = TARGET_INSTALLATIONS.find((t) => t.id === targetId);
+    if (!installation) {
+      console.log(chalk.red(`✗ Unknown target: ${targetId}`));
+      return false;
+    }
+
+    // Special handling for Cursor (not npm-installable)
+    if (targetId === 'cursor') {
+      console.log(chalk.yellow('\n⚠️  Cursor requires manual installation'));
+      console.log(chalk.cyan('   Visit https://cursor.sh to download and install\n'));
+      return false;
+    }
+
+    // Confirm installation unless auto-confirm is enabled
+    if (!autoConfirm) {
+      try {
+        const { confirmInstall } = await inquirer.prompt([
+          {
+            type: 'confirm',
+            name: 'confirmInstall',
+            message: `Install ${installation.name}?`,
+            default: true,
+          },
+        ]);
+
+        if (!confirmInstall) {
+          console.log(chalk.yellow('\n⚠️  Installation cancelled\n'));
+          return false;
+        }
+      } catch (error: any) {
+        // Handle user cancellation (Ctrl+C)
+        if (error.name === 'ExitPromptError' || error.message?.includes('force closed')) {
+          throw new UserCancelledError('Installation cancelled');
+        }
+        throw error;
+      }
+    }
+
+    const spinner = ora(`Installing ${installation.name}...`).start();
+
+    try {
+      const installCmd = installation.installCommand(this.packageManager);
+      await execAsync(installCmd);
+
+      spinner.succeed(chalk.green(`✓ ${installation.name} installed successfully`));
+      return true;
+    } catch (error) {
+      spinner.fail(chalk.red(`✗ Failed to install ${installation.name}`));
+
+      const installCmd = installation.installCommand(this.packageManager);
+      console.log(chalk.yellow('\n⚠️  Auto-install failed. Please run manually:'));
+      console.log(chalk.cyan(`   ${installCmd}\n`));
+
+      return false;
+    }
+  }
+
+  /**
+   * Auto-detect installed targets or prompt to install one
+   * @returns Target ID if found or installed, null if installation failed
+   * @throws {UserCancelledError} If user cancels selection or installation
+   */
+  async autoDetectAndInstall(): Promise<string | null> {
+    console.log(chalk.cyan('🔍 Detecting installed AI CLIs...\n'));
+
+    const installedTargets = await this.detectInstalledTargets();
+
+    // If we found installed targets, return the first one (priority order)
+    if (installedTargets.length > 0) {
+      const targetId = installedTargets[0];
+      const installation = TARGET_INSTALLATIONS.find((t) => t.id === targetId);
+      console.log(chalk.green(`✓ Found ${installation?.name}\n`));
+      return targetId;
+    }
+
+    // No targets found - prompt user to select one
+    console.log(chalk.yellow('⚠️  No AI CLI detected\n'));
+    const selectedTargetId = await this.promptForTargetSelection();
+
+    // Try to install the selected target
+    console.log();
+    const installed = await this.install(selectedTargetId, false);
+
+    if (!installed) {
+      return null;
+    }
+
+    return selectedTargetId;
+  }
+
+  /**
+   * Get installation metadata for a target
+   * @param targetId - Target ID to get info for
+   * @returns Installation info or undefined if target not found
+   */
+  getInstallationInfo(targetId: string): TargetInstallation | undefined {
+    return TARGET_INSTALLATIONS.find((t) => t.id === targetId);
+  }
+}

package/src/targets/claude-code.ts

@@ -3,8 +3,8 @@ import fs from 'node:fs';
 import fsPromises from 'node:fs/promises';
 import path from 'node:path';
 import chalk from 'chalk';
-import { FileInstaller } from '../core/installers/file-installer.js';
-import { MCPInstaller } from '../core/installers/mcp-installer.js';
+import { installToDirectory } from '../core/installers/file-installer.js';
+import { createMCPInstaller } from '../core/installers/mcp-installer.js';
 import type { AgentMetadata } from '../types/target-config.types.js';
 import type { CommonOptions, MCPServerConfigUnion, SetupResult, Target } from '../types.js';
 import { CLIError } from '../utils/error-handler.js';
@@ -432,10 +432,9 @@ Please begin your response with a comprehensive summary of all the instructions
    */
   async setupAgents(cwd: string, options: CommonOptions): Promise<SetupResult> {
     const { enhanceAgentContent } = await import('../utils/agent-enhancer.js');
-    const installer = new FileInstaller();
     const agentsDir = path.join(cwd, this.config.agentDir);
 
-    const results = await installer.installToDirectory(
+    const results = await installToDirectory(
       getAgentsDir(),
       agentsDir,
       async (content, sourcePath) => {
@@ -491,7 +490,7 @@ Please begin your response with a comprehensive summary of all the instructions
    * Select, configure, install, and approve MCP servers
    */
   async setupMCP(cwd: string, options: CommonOptions): Promise<SetupResult> {
-    const installer = new MCPInstaller(this);
+    const installer = createMCPInstaller(this);
     const result = await installer.setupMCP({ ...options, quiet: true });
 
     // Approve servers in Claude Code settings
@@ -513,10 +512,9 @@ Please begin your response with a comprehensive summary of all the instructions
       return { count: 0 };
     }
 
-    const installer = new FileInstaller();
     const slashCommandsDir = path.join(cwd, this.config.slashCommandsDir);
 
-    const results = await installer.installToDirectory(
+    const results = await installToDirectory(
       getSlashCommandsDir(),
       slashCommandsDir,
       async (content) => {

package/src/targets/opencode.ts

@@ -3,8 +3,8 @@ import path from 'node:path';
 import chalk from 'chalk';
 import { getRulesPath, ruleFileExists } from '../config/rules.js';
 import { MCP_SERVER_REGISTRY } from '../config/servers.js';
-import { FileInstaller } from '../core/installers/file-installer.js';
-import { MCPInstaller } from '../core/installers/mcp-installer.js';
+import { installToDirectory, installFile } from '../core/installers/file-installer.js';
+import { createMCPInstaller } from '../core/installers/mcp-installer.js';
 import type { AgentMetadata } from '../types/target-config.types.js';
 import type { CommonOptions, MCPServerConfigUnion, SetupResult, Target } from '../types.js';
 import { getAgentsDir, getOutputStylesDir, getSlashCommandsDir } from '../utils/config/paths.js';
@@ -232,19 +232,9 @@ export const opencodeTarget: Target = {
    * Install agents to .opencode/agent/ directory
    */
   async setupAgents(cwd: string, options: CommonOptions): Promise<SetupResult> {
-    // Clean up old 'commands' directory if it exists (migration from old structure)
-    // This ensures OpenCode won't crash with ConfigDirectoryTypoError
-    const oldCommandsDir = path.join(cwd, '.opencode/commands');
-    try {
-      await fs.rm(oldCommandsDir, { recursive: true, force: true });
-    } catch {
-      // Ignore if doesn't exist
-    }
-
-    const installer = new FileInstaller();
     const agentsDir = path.join(cwd, this.config.agentDir);
 
-    const results = await installer.installToDirectory(
+    const results = await installToDirectory(
       getAgentsDir(),
       agentsDir,
       async (content, sourcePath) => {
@@ -336,11 +326,10 @@ export const opencodeTarget: Target = {
       throw new Error('Core rules file not found');
     }
 
-    const installer = new FileInstaller();
     const rulesDestPath = path.join(cwd, this.config.rulesFile);
     const rulePath = getRulesPath('core');
 
-    await installer.installFile(
+    await installFile(
       rulePath,
       rulesDestPath,
       async (content) => {
@@ -371,7 +360,7 @@ export const opencodeTarget: Target = {
     }
 
     // Install MCP servers
-    const installer = new MCPInstaller(this);
+    const installer = createMCPInstaller(this);
     const result = await installer.setupMCP({ ...options, quiet: true });
 
     return { count: result.selectedServers.length };
@@ -386,18 +375,9 @@ export const opencodeTarget: Target = {
       return { count: 0 };
     }
 
-    // Clean up old 'commands' directory if it exists (migration from old structure)
-    const oldCommandsDir = path.join(cwd, '.opencode/commands');
-    try {
-      await fs.rm(oldCommandsDir, { recursive: true, force: true });
-    } catch {
-      // Ignore if doesn't exist
-    }
-
-    const installer = new FileInstaller();
     const slashCommandsDir = path.join(cwd, this.config.slashCommandsDir);
 
-    const results = await installer.installToDirectory(
+    const results = await installToDirectory(
       getSlashCommandsDir(),
       slashCommandsDir,
       async (content) => {