@sylphx/flow 2.1.3 → 2.1.5

package/src/core/rule-loader.ts

@@ -1,147 +0,0 @@
-/**
- * Rule Loader
- * Loads rule definitions from markdown files with front matter
- */
-
-import { readFile, readdir, access } from 'node:fs/promises';
-import { join, parse, relative, dirname } from 'node:path';
-import { homedir } from 'node:os';
-import { fileURLToPath } from 'node:url';
-import matter from 'gray-matter';
-import type { Rule, RuleMetadata } from '../types/rule.types.js';
-
-/**
- * Load a single rule from a markdown file
- */
-export async function loadRuleFromFile(
-  filePath: string,
-  isBuiltin: boolean = false,
-  ruleId?: string
-): Promise<Rule | null> {
-  try {
-    const fileContent = await readFile(filePath, 'utf-8');
-    const { data, content } = matter(fileContent);
-
-    // Validate front matter
-    if (!data.name || typeof data.name !== 'string') {
-      console.error(`Rule file ${filePath} missing required 'name' field`);
-      return null;
-    }
-
-    const metadata: RuleMetadata = {
-      name: data.name,
-      description: data.description || '',
-      enabled: data.enabled !== undefined ? Boolean(data.enabled) : true,
-    };
-
-    // Get rule ID from parameter or filename
-    const id = ruleId || parse(filePath).name;
-
-    return {
-      id,
-      metadata,
-      content: content.trim(),
-      isBuiltin,
-      filePath,
-    };
-  } catch (error) {
-    console.error(`Failed to load rule from ${filePath}:`, error);
-    return null;
-  }
-}
-
-/**
- * Load all rules from a directory (recursively)
- */
-export async function loadRulesFromDirectory(dirPath: string, isBuiltin: boolean = false): Promise<Rule[]> {
-  try {
-    // Read directory recursively to support subdirectories
-    const files = await readdir(dirPath, { recursive: true, withFileTypes: true });
-
-    // Filter for .md files and calculate rule IDs from relative paths
-    const ruleFiles = files
-      .filter((f) => f.isFile() && f.name.endsWith('.md'))
-      .map((f) => {
-        const fullPath = join(f.parentPath || f.path, f.name);
-        // Calculate relative path from dirPath and remove .md extension
-        const relativePath = relative(dirPath, fullPath).replace(/\.md$/, '');
-        return { fullPath, ruleId: relativePath };
-      });
-
-    const rules = await Promise.all(
-      ruleFiles.map(({ fullPath, ruleId }) => loadRuleFromFile(fullPath, isBuiltin, ruleId))
-    );
-
-    return rules.filter((rule): rule is Rule => rule !== null);
-  } catch (error) {
-    // Directory doesn't exist or can't be read
-    return [];
-  }
-}
-
-/**
- * Get system rules path (bundled with the app)
- */
-export async function getSystemRulesPath(): Promise<string> {
-  // Get the directory of the current module (cross-platform)
-  const currentFile = fileURLToPath(import.meta.url);
-  const currentDir = dirname(currentFile);
-
-  // In production (dist), assets are at dist/assets/rules
-  // In development (src), go up to project root: src/core -> project root
-  const distPath = join(currentDir, '..', 'assets', 'rules');
-  const devPath = join(currentDir, '..', '..', 'assets', 'rules');
-
-  // Check which one exists (try dist first, then dev)
-  try {
-    await access(distPath);
-    return distPath;
-  } catch {
-    return devPath;
-  }
-}
-
-/**
- * Get all rule search paths
- */
-export function getRuleSearchPaths(cwd: string): string[] {
-  const globalPath = join(homedir(), '.sylphx-flow', 'rules');
-  const projectPath = join(cwd, '.sylphx-flow', 'rules');
-
-  return [globalPath, projectPath];
-}
-
-/**
- * Load all available rules from all sources
- */
-export async function loadAllRules(cwd: string): Promise<Rule[]> {
-  const systemPath = await getSystemRulesPath();
-  const [globalPath, projectPath] = getRuleSearchPaths(cwd);
-
-  const [systemRules, globalRules, projectRules] = await Promise.all([
-    loadRulesFromDirectory(systemPath, true),  // System rules are marked as builtin
-    loadRulesFromDirectory(globalPath, false),
-    loadRulesFromDirectory(projectPath, false),
-  ]);
-
-  // Priority: system < global < project
-  // Use Map to deduplicate by ID (later entries override earlier ones)
-  const ruleMap = new Map<string, Rule>();
-
-  // Add system rules first (lowest priority)
-  for (const rule of systemRules) {
-    ruleMap.set(rule.id, rule);
-  }
-
-  // Add global rules (override system)
-  for (const rule of globalRules) {
-    ruleMap.set(rule.id, rule);
-  }
-
-  // Add project rules (override globals and system)
-  for (const rule of projectRules) {
-    ruleMap.set(rule.id, rule);
-  }
-
-  return Array.from(ruleMap.values());
-}

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';
-  }
-}