@sylphx/flow 2.1.2 → 2.1.4

package/src/core/rule-manager.ts

@@ -1,240 +0,0 @@
-/**
- * Rule Manager
- * Manages rule state and operations
- */
-
-import type { Rule } from '../types/rule.types.js';
-import { loadAllRules } from './rule-loader.js';
-
-/**
- * Rule manager state
- */
-interface RuleManagerState {
-  rules: Map<string, Rule>;
-  cwd: string;
-}
-
-let state: RuleManagerState | null = null;
-
-/**
- * Get the app store (lazy import to avoid circular dependencies)
- */
-let getAppStore: (() => any) | null = null;
-
-/**
- * Set the app store getter (called during initialization)
- */
-export function setRuleAppStoreGetter(getter: () => any): void {
-  getAppStore = getter;
-}
-
-/**
- * Initialize rule manager
- */
-export async function initializeRuleManager(cwd: string): Promise<void> {
-  const allRules = await loadAllRules(cwd);
-
-  const ruleMap = new Map<string, Rule>();
-  for (const rule of allRules) {
-    ruleMap.set(rule.id, rule);
-  }
-
-  state = {
-    rules: ruleMap,
-    cwd,
-  };
-
-  // Initialize store with default enabled rules
-  if (getAppStore) {
-    const store = getAppStore();
-    if (store.getState) {
-      const currentEnabledRules = store.getState().enabledRuleIds || [];
-
-      // If no rules are enabled yet, enable all rules that have enabled: true in metadata
-      if (currentEnabledRules.length === 0) {
-        const defaultEnabledRules = allRules
-          .filter((rule) => rule.metadata.enabled !== false)
-          .map((rule) => rule.id);
-
-        if (defaultEnabledRules.length > 0) {
-          store.getState().setEnabledRuleIds(defaultEnabledRules);
-        }
-      }
-    }
-  }
-}
-
-/**
- * Get all available rules
- */
-export function getAllRules(): Rule[] {
-  if (!state) {
-    return [];
-  }
-  return Array.from(state.rules.values());
-}
-
-/**
- * Get rule by ID
- */
-export function getRuleById(id: string): Rule | null {
-  if (!state) {
-    return null;
-  }
-  return state.rules.get(id) || null;
-}
-
-/**
- * Get enabled rule IDs from store
- */
-export function getEnabledRuleIds(): string[] {
-  if (getAppStore) {
-    const store = getAppStore();
-    if (store.getState) {
-      return store.getState().enabledRuleIds || [];
-    }
-  }
-  return [];
-}
-
-/**
- * Get enabled rules
- */
-export function getEnabledRules(): Rule[] {
-  if (!state) {
-    return [];
-  }
-
-  const enabledIds = getEnabledRuleIds();
-  return enabledIds
-    .map((id) => state!.rules.get(id))
-    .filter((rule): rule is Rule => rule !== null);
-}
-
-/**
- * Toggle a rule on/off
- */
-export function toggleRule(ruleId: string): boolean {
-  if (!state || !state.rules.has(ruleId)) {
-    return false;
-  }
-
-  if (getAppStore) {
-    const store = getAppStore();
-    if (store.getState) {
-      const currentEnabled = store.getState().enabledRuleIds || [];
-
-      if (currentEnabled.includes(ruleId)) {
-        // Disable: remove from list
-        store.getState().setEnabledRuleIds(currentEnabled.filter((id) => id !== ruleId));
-      } else {
-        // Enable: add to list
-        store.getState().setEnabledRuleIds([...currentEnabled, ruleId]);
-      }
-      return true;
-    }
-  }
-
-  return false;
-}
-
-/**
- * Enable a rule
- */
-export function enableRule(ruleId: string): boolean {
-  if (!state || !state.rules.has(ruleId)) {
-    return false;
-  }
-
-  if (getAppStore) {
-    const store = getAppStore();
-    if (store.getState) {
-      const currentEnabled = store.getState().enabledRuleIds || [];
-
-      if (!currentEnabled.includes(ruleId)) {
-        store.getState().setEnabledRuleIds([...currentEnabled, ruleId]);
-      }
-      return true;
-    }
-  }
-
-  return false;
-}
-
-/**
- * Disable a rule
- */
-export function disableRule(ruleId: string): boolean {
-  if (!state || !state.rules.has(ruleId)) {
-    return false;
-  }
-
-  if (getAppStore) {
-    const store = getAppStore();
-    if (store.getState) {
-      const currentEnabled = store.getState().enabledRuleIds || [];
-      store.getState().setEnabledRuleIds(currentEnabled.filter((id) => id !== ruleId));
-      return true;
-    }
-  }
-
-  return false;
-}
-
-/**
- * Reload rules from disk
- */
-export async function reloadRules(): Promise<void> {
-  if (!state) {
-    return;
-  }
-
-  const cwd = state.cwd;
-  const currentEnabled = getEnabledRuleIds();
-
-  await initializeRuleManager(cwd);
-
-  // Keep only enabled rules that still exist
-  if (state && getAppStore) {
-    const store = getAppStore();
-    if (store.getState) {
-      const validEnabled = currentEnabled.filter((id) => state!.rules.has(id));
-      store.getState().setEnabledRuleIds(validEnabled);
-    }
-  }
-}
-
-/**
- * Set enabled rules (replaces current enabled rules)
- */
-export function setEnabledRules(ruleIds: string[]): boolean {
-  if (!state) {
-    return false;
-  }
-
-  // Validate all rule IDs exist
-  const validRuleIds = ruleIds.filter((id) => state!.rules.has(id));
-
-  if (getAppStore) {
-    const store = getAppStore();
-    if (store.getState) {
-      store.getState().setEnabledRuleIds(validRuleIds);
-      return true;
-    }
-  }
-
-  return false;
-}
-
-/**
- * Get combined content of all enabled rules
- */
-export function getEnabledRulesContent(): string {
-  const enabledRules = getEnabledRules();
-
-  if (enabledRules.length === 0) {
-    return '';
-  }
-
-  return enabledRules.map((rule) => rule.content).join('\n\n');
-}

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

@@ -1,252 +0,0 @@
-/**
- * Claude Configuration Service
- * Handles Claude Code provider configuration with layered settings
- */
-
-import inquirer from 'inquirer';
-import chalk from 'chalk';
-import { ConfigService } from './config-service.js';
-import { loadAllAgents } from '../core/agent-loader.js';
-
-export interface ClaudeConfig {
-  claudeProvider?: string;
-  claudeProviderConfig?: {
-    ANTHROPIC_BASE_URL: string;
-    description: string;
-  };
-  claudeApiKey?: string;
-  defaultAgent?: string;
-  target?: string;
-}
-
-export class ClaudeConfigService {
-  /**
-   * Load layered Claude configuration from all sources
-   */
-  static async loadConfig(): Promise<ClaudeConfig> {
-    // API keys are in home directory
-    const userSettings = await ConfigService.loadHomeSettings();
-
-    // Other settings are in project directory
-    const projectSettings = await ConfigService.loadProjectSettings();
-
-    // Merge with project settings taking precedence over home (except API key)
-    const merged = {
-      claudeProvider: userSettings.claudeProvider || projectSettings.claudeProvider,
-      claudeProviderConfig: userSettings.claudeProviderConfig || projectSettings.claudeProviderConfig,
-      claudeApiKey: userSettings.claudeApiKey,
-      defaultAgent: projectSettings.defaultAgent,
-      target: projectSettings.target,
-    };
-
-    // Local settings have highest priority for everything except API key
-    const localSettings = await ConfigService.loadLocalSettings();
-
-    return {
-      ...merged,
-      ...localSettings,
-      // Keep API key from user settings
-      claudeApiKey: merged.claudeApiKey,
-    };
-  }
-
-  /**
-   * Save user-specific config (API keys to home, project settings to project)
-   */
-  static async saveConfig(config: ClaudeConfig): Promise<void> {
-    // Separate user-specific settings (API keys)
-    const userSettings = {
-      claudeApiKey: config.claudeApiKey,
-      claudeProvider: config.claudeProvider,
-      claudeProviderConfig: config.claudeProviderConfig,
-    };
-
-    // Other settings go to project (shareable)
-    const projectSettings = {
-      claudeProvider: config.claudeProvider,
-      defaultAgent: config.defaultAgent,
-      target: config.target,
-    };
-
-    // Save API keys to home directory (never commit)
-    if (userSettings.claudeApiKey) {
-      await ConfigService.saveHomeSettings(userSettings);
-    }
-
-    // Save project settings
-    await ConfigService.saveProjectSettings(projectSettings);
-  }
-
-  /**
-   * Configure Claude provider interactively - saves API keys to home dir
-   */
-  static async configureProvider(verbose: boolean = false): Promise<ClaudeConfig> {
-    const config = await this.loadConfig();
-
-    // Check if we already have API key configured
-    if (!config.claudeApiKey || !config.claudeProvider || verbose) {
-      console.log(chalk.cyan('📋 Claude Code Configuration\n'));
-
-      const providerAnswer = await inquirer.prompt([
-        {
-          type: 'list',
-          name: 'provider',
-          message: 'Select Claude API Provider:',
-          choices: [
-            { name: 'Anthropic (Official)', value: 'anthropic' },
-            { name: 'Z.ai (Recommended)', value: 'z.ai' },
-            { name: 'Kimi', value: 'kimi' },
-          ],
-          default: config.claudeProvider || 'z.ai',
-        },
-      ]);
-
-      // Ask for API Key
-      const keyAnswer = await inquirer.prompt([
-        {
-          type: 'password',
-          name: 'apiKey',
-          message: `Enter API Key for ${providerAnswer.provider}:`,
-          mask: '*',
-          validate: (input) => input.length > 10 || 'API Key appears too short',
-        },
-      ]);
-
-      // Provider configurations
-      const providerEnvs = {
-        'anthropic': {
-          ANTHROPIC_BASE_URL: 'https://api.anthropic.com',
-          description: 'Anthropic Official API',
-        },
-        'z.ai': {
-          ANTHROPIC_BASE_URL: 'https://api.z.ai/api/anthropic',
-          description: 'Z.ai Proxy',
-        },
-        'kimi': {
-          ANTHROPIC_BASE_URL: 'https://api.kimi.com/coding/',
-          description: 'Kimi Proxy',
-        },
-      };
-
-      const providerConfig = providerEnvs[providerAnswer.provider as keyof typeof providerEnvs];
-
-      // Save API keys to home directory (never commit)
-      await ConfigService.saveHomeSettings({
-        claudeProvider: providerAnswer.provider,
-        claudeProviderConfig: providerConfig,
-        claudeApiKey: keyAnswer.apiKey,
-      });
-
-      console.log(chalk.green(`✓ API Key saved to ~/.sylphx-flow/settings.json (secure)\n`));
-      console.log(chalk.dim(`  Provider: ${providerConfig.description}`));
-      console.log(chalk.dim(`  API Key: ${keyAnswer.apiKey.slice(0, 5)}...${keyAnswer.apiKey.slice(-4)}\n`));
-
-      // Update config for return
-      config.claudeProvider = providerAnswer.provider;
-      config.claudeProviderConfig = providerConfig;
-      config.claudeApiKey = keyAnswer.apiKey;
-
-      return config;
-    }
-
-    if (verbose) {
-      console.log(chalk.green('✓ Claude provider already configured\n'));
-      console.log(chalk.dim(`  Provider: ${config.claudeProviderConfig?.description}\n`));
-    }
-
-    return config;
-  }
-
-  /**
-   * Configure agent interactively - saves to project config (shareable)
-   * Dynamically loads available agents instead of hardcoded list
-   */
-  static async configureAgent(verbose: boolean = false): Promise<string> {
-    const config = await this.loadConfig();
-
-    if (!config.defaultAgent || verbose) {
-      try {
-        // Dynamically load all available agents
-        const agents = await loadAllAgents(process.cwd());
-
-        if (agents.length === 0) {
-          console.log(chalk.yellow('⚠ No agents found. Defaulting to "coder".\n'));
-          const defaultAgent = 'coder';
-          await ConfigService.saveProjectSettings({
-            defaultAgent,
-          });
-          return defaultAgent;
-        }
-
-        // Create choices from dynamically loaded agents
-        const choices = agents.map(agent => ({
-          name: agent.metadata.name || agent.id,
-          value: agent.id,
-        }));
-
-        const agentAnswer = await inquirer.prompt([
-          {
-            type: 'list',
-            name: 'agent',
-            message: 'Select default Agent:',
-            choices,
-            default: config.defaultAgent || (agents.find(a => a.id === 'coder')?.id || agents[0].id),
-          },
-        ]);
-
-        // Save to project-level config (shareable)
-        await ConfigService.saveProjectSettings({
-          defaultAgent: agentAnswer.agent,
-        });
-
-        const selectedAgent = agents.find(a => a.id === agentAnswer.agent);
-        const displayName = selectedAgent?.metadata.name || agentAnswer.agent;
-        console.log(chalk.green(`✓ Agent set to: ${displayName}\n`));
-
-        return agentAnswer.agent;
-      } catch (error) {
-        console.log(chalk.yellow('⚠ Failed to load agents. Defaulting to "coder".\n'));
-        console.error(error);
-
-        const defaultAgent = 'coder';
-        await ConfigService.saveProjectSettings({
-          defaultAgent,
-        });
-        return defaultAgent;
-      }
-    }
-
-    return config.defaultAgent;
-  }
-
-  /**
-   * Setup environment variables for Claude Code
-   */
-  static async setupEnvironment(verbose: boolean = false): Promise<void> {
-    const config = await this.loadConfig();
-
-    if (!config.claudeProviderConfig) {
-      throw new Error('Provider not configured. Run configureProvider() first.');
-    }
-
-    // Set environment variables
-    process.env.ANTHROPIC_BASE_URL = config.claudeProviderConfig.ANTHROPIC_BASE_URL;
-
-    if (config.claudeApiKey) {
-      process.env.ANTHROPIC_API_KEY = config.claudeApiKey;
-
-      if (verbose) {
-        console.log(chalk.dim(`  Provider: ${config.claudeProviderConfig.description}`));
-        console.log(chalk.dim(`  API Key: ${config.claudeApiKey.slice(0, 5)}...${config.claudeApiKey.slice(-4)}\n`));
-      }
-    }
-  }
-
-  /**
-   * Get the default agent
-   */
-  static async getDefaultAgent(): Promise<string> {
-    const config = await this.loadConfig();
-    return config.defaultAgent || 'coder';
-  }
-}

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