@sylphx/flow 2.1.4 → 2.1.5

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @sylphx/flow
 
+## 2.1.5 (2025-11-28)
+
+### 🐛 Bug Fixes
+
+- **settings:** use MCP_SERVER_REGISTRY instead of hardcoded list ([79fb625](https://github.com/SylphxAI/flow/commit/79fb625c27f58f7f62902314d92c205fdc84a06e))
+
+### ♻️ Refactoring
+
+- **settings:** extract checkbox configuration handler ([66303bb](https://github.com/SylphxAI/flow/commit/66303bb21a5281e5f358c69b8a6c143f3866fa76))
+- **attach:** extract file attachment pure functions ([5723be3](https://github.com/SylphxAI/flow/commit/5723be3817804228014ceec8de27f267c990fbe8))
+- **targets:** extract shared pure functions for MCP transforms ([0bba2cb](https://github.com/SylphxAI/flow/commit/0bba2cbc4a4233e0d63a78875346a2e9c341d803))
+
+### 🔧 Chores
+
+- remove dead cursor target references ([bf16f75](https://github.com/SylphxAI/flow/commit/bf16f759ec4705ddf0a763ea0ef6c778c91ccbbe))
+
 ## 2.1.4 (2025-11-28)
 
 ### ♻️ Refactoring

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@sylphx/flow",
-	"version": "2.1.4",
+	"version": "2.1.5",
 	"description": "One CLI to rule them all. Unified orchestration layer for Claude Code, OpenCode, Cursor and all AI development tools. Auto-detection, auto-installation, auto-upgrade.",
 	"type": "module",
 	"bin": {

package/src/commands/settings/checkbox-config.ts

@@ -0,0 +1,128 @@
+/**
+ * Generic checkbox configuration handler
+ * Pure functions for settings UI patterns
+ */
+
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export interface ConfigItem {
+  enabled: boolean;
+}
+
+export type ConfigMap = Record<string, ConfigItem>;
+
+export interface CheckboxConfigOptions<T extends string> {
+  /** Section title (e.g., "Agents Configuration") */
+  title: string;
+  /** Icon for the section (e.g., "🤖") */
+  icon: string;
+  /** Prompt message (e.g., "Select agents to enable:") */
+  message: string;
+  /** Available items with display names */
+  available: Record<T, string>;
+  /** Current config state */
+  current: ConfigMap;
+  /** Item type name for confirmation (e.g., "agents", "rules") */
+  itemType: string;
+}
+
+export interface CheckboxConfigResult<T extends string> {
+  selected: T[];
+  updated: ConfigMap;
+}
+
+// ============================================================================
+// Pure Functions
+// ============================================================================
+
+/**
+ * Get currently enabled keys from config
+ */
+export const getEnabledKeys = (config: ConfigMap): string[] =>
+  Object.keys(config).filter((key) => config[key]?.enabled);
+
+/**
+ * Build checkbox choices from available items
+ */
+export const buildChoices = <T extends string>(
+  available: Record<T, string>,
+  enabledKeys: string[]
+): Array<{ name: string; value: T; checked: boolean }> =>
+  Object.entries(available).map(([key, name]) => ({
+    name: name as string,
+    value: key as T,
+    checked: enabledKeys.includes(key),
+  }));
+
+/**
+ * Update config based on selection
+ * Returns new config object (immutable)
+ */
+export const updateConfig = <T extends string>(
+  available: Record<T, string>,
+  selected: T[]
+): ConfigMap => {
+  const updated: ConfigMap = {};
+  for (const key of Object.keys(available)) {
+    updated[key] = { enabled: selected.includes(key as T) };
+  }
+  return updated;
+};
+
+/**
+ * Print section header
+ */
+export const printHeader = (icon: string, title: string): void => {
+  console.log(chalk.cyan.bold(`\n━━━ ${icon} ${title}\n`));
+};
+
+/**
+ * Print confirmation message
+ */
+export const printConfirmation = (itemType: string, count: number): void => {
+  console.log(chalk.green(`\n✓ ${itemType} configuration saved`));
+  console.log(chalk.dim(`  Enabled ${itemType.toLowerCase()}: ${count}`));
+};
+
+// ============================================================================
+// Main Handler
+// ============================================================================
+
+/**
+ * Generic checkbox configuration handler
+ * Handles the common pattern of select → update → save
+ */
+export const handleCheckboxConfig = async <T extends string>(
+  options: CheckboxConfigOptions<T>
+): Promise<CheckboxConfigResult<T>> => {
+  const { title, icon, message, available, current, itemType } = options;
+
+  // Print header
+  printHeader(icon, title);
+
+  // Get current enabled items
+  const enabledKeys = getEnabledKeys(current);
+
+  // Show checkbox prompt
+  const { selected } = await inquirer.prompt([
+    {
+      type: 'checkbox',
+      name: 'selected',
+      message,
+      choices: buildChoices(available, enabledKeys),
+    },
+  ]);
+
+  // Update config
+  const updated = updateConfig(available, selected);
+
+  // Print confirmation
+  printConfirmation(itemType, selected.length);
+
+  return { selected, updated };
+};

package/src/commands/settings/index.ts

@@ -0,0 +1,6 @@
+/**
+ * Settings utilities
+ * Shared handlers for settings UI patterns
+ */
+
+export * from './checkbox-config.js';

package/src/commands/settings-command.ts

@@ -6,10 +6,12 @@
 import chalk from 'chalk';
 import { Command } from 'commander';
 import inquirer from 'inquirer';
+import { getRequiredEnvVars, MCP_SERVER_REGISTRY, type MCPServerID } from '../config/servers.js';
 import { GlobalConfigService } from '../services/global-config.js';
 import { TargetInstaller } from '../services/target-installer.js';
 import { UserCancelledError } from '../utils/errors.js';
 import { buildAvailableTargets, promptForDefaultTarget } from '../utils/target-selection.js';
+import { handleCheckboxConfig, printHeader, printConfirmation } from './settings/index.js';
 
 export const settingsCommand = new Command('settings')
   .description('Configure Sylphx Flow settings')
@@ -106,16 +108,12 @@ async function openSection(section: string, configService: GlobalConfigService):
 }
 
 /**
- * Configure Agents
+ * Configure Agents - uses shared checkbox handler + default selection
  */
 async function configureAgents(configService: GlobalConfigService): Promise<void> {
-  console.log(chalk.cyan.bold('\n━━━ 🤖 Agent Configuration\n'));
-
   const flowConfig = await configService.loadFlowConfig();
   const settings = await configService.loadSettings();
-  const currentAgents = flowConfig.agents || {};
 
-  // Available agents
   const availableAgents = {
     coder: 'Coder - Write and modify code',
     writer: 'Writer - Documentation and explanation',
@@ -123,38 +121,22 @@ async function configureAgents(configService: GlobalConfigService): Promise<void
     orchestrator: 'Orchestrator - Task coordination',
   };
 
-  // Get current enabled agents
-  const currentEnabled = Object.keys(currentAgents).filter((key) => currentAgents[key].enabled);
-
-  const { selectedAgents } = await inquirer.prompt([
-    {
-      type: 'checkbox',
-      name: 'selectedAgents',
-      message: 'Select agents to enable:',
-      choices: Object.entries(availableAgents).map(([key, name]) => ({
-        name,
-        value: key,
-        checked: currentEnabled.includes(key),
-      })),
-    },
-  ]);
-
-  // Update agents
-  for (const key of Object.keys(availableAgents)) {
-    if (selectedAgents.includes(key)) {
-      currentAgents[key] = { enabled: true };
-    } else {
-      currentAgents[key] = { enabled: false };
-    }
-  }
+  const { selected, updated } = await handleCheckboxConfig({
+    title: 'Agent Configuration',
+    icon: '🤖',
+    message: 'Select agents to enable:',
+    available: availableAgents,
+    current: flowConfig.agents || {},
+    itemType: 'Agents',
+  });
 
-  // Select default agent
+  // Additional step: select default agent from enabled ones
   const { defaultAgent } = await inquirer.prompt([
     {
       type: 'list',
       name: 'defaultAgent',
       message: 'Select default agent:',
-      choices: selectedAgents.map((key: string) => ({
+      choices: selected.map((key) => ({
         name: availableAgents[key as keyof typeof availableAgents],
         value: key,
       })),
@@ -162,109 +144,57 @@ async function configureAgents(configService: GlobalConfigService): Promise<void
     },
   ]);
 
-  flowConfig.agents = currentAgents;
+  flowConfig.agents = updated;
   await configService.saveFlowConfig(flowConfig);
 
   settings.defaultAgent = defaultAgent;
   await configService.saveSettings(settings);
 
-  console.log(chalk.green(`\n✓ Agent configuration saved`));
-  console.log(chalk.dim(`  Enabled agents: ${selectedAgents.length}`));
   console.log(chalk.dim(`  Default agent: ${defaultAgent}`));
 }
 
 /**
- * Configure Rules
+ * Configure Rules - uses shared checkbox handler
  */
 async function configureRules(configService: GlobalConfigService): Promise<void> {
-  console.log(chalk.cyan.bold('\n━━━ 📋 Rules Configuration\n'));
-
   const flowConfig = await configService.loadFlowConfig();
-  const currentRules = flowConfig.rules || {};
-
-  // Available rules
-  const availableRules = {
-    core: 'Core - Identity, personality, execution',
-    'code-standards': 'Code Standards - Quality, patterns, anti-patterns',
-    workspace: 'Workspace - Documentation management',
-  };
-
-  // Get current enabled rules
-  const currentEnabled = Object.keys(currentRules).filter((key) => currentRules[key].enabled);
 
-  const { selectedRules } = await inquirer.prompt([
-    {
-      type: 'checkbox',
-      name: 'selectedRules',
-      message: 'Select rules to enable:',
-      choices: Object.entries(availableRules).map(([key, name]) => ({
-        name,
-        value: key,
-        checked: currentEnabled.includes(key),
-      })),
+  const { updated } = await handleCheckboxConfig({
+    title: 'Rules Configuration',
+    icon: '📋',
+    message: 'Select rules to enable:',
+    available: {
+      core: 'Core - Identity, personality, execution',
+      'code-standards': 'Code Standards - Quality, patterns, anti-patterns',
+      workspace: 'Workspace - Documentation management',
     },
-  ]);
-
-  // Update rules
-  for (const key of Object.keys(availableRules)) {
-    if (selectedRules.includes(key)) {
-      currentRules[key] = { enabled: true };
-    } else {
-      currentRules[key] = { enabled: false };
-    }
-  }
+    current: flowConfig.rules || {},
+    itemType: 'Rules',
+  });
 
-  flowConfig.rules = currentRules;
+  flowConfig.rules = updated;
   await configService.saveFlowConfig(flowConfig);
-
-  console.log(chalk.green(`\n✓ Rules configuration saved`));
-  console.log(chalk.dim(`  Enabled rules: ${selectedRules.length}`));
 }
 
 /**
- * Configure Output Styles
+ * Configure Output Styles - uses shared checkbox handler
  */
 async function configureOutputStyles(configService: GlobalConfigService): Promise<void> {
-  console.log(chalk.cyan.bold('\n━━━ 🎨 Output Styles Configuration\n'));
-
   const flowConfig = await configService.loadFlowConfig();
-  const currentStyles = flowConfig.outputStyles || {};
 
-  // Available output styles
-  const availableStyles = {
-    silent: 'Silent - Execution without narration',
-  };
-
-  // Get current enabled styles
-  const currentEnabled = Object.keys(currentStyles).filter((key) => currentStyles[key].enabled);
-
-  const { selectedStyles } = await inquirer.prompt([
-    {
-      type: 'checkbox',
-      name: 'selectedStyles',
-      message: 'Select output styles to enable:',
-      choices: Object.entries(availableStyles).map(([key, name]) => ({
-        name,
-        value: key,
-        checked: currentEnabled.includes(key),
-      })),
+  const { updated } = await handleCheckboxConfig({
+    title: 'Output Styles Configuration',
+    icon: '🎨',
+    message: 'Select output styles to enable:',
+    available: {
+      silent: 'Silent - Execution without narration',
     },
-  ]);
-
-  // Update styles
-  for (const key of Object.keys(availableStyles)) {
-    if (selectedStyles.includes(key)) {
-      currentStyles[key] = { enabled: true };
-    } else {
-      currentStyles[key] = { enabled: false };
-    }
-  }
+    current: flowConfig.outputStyles || {},
+    itemType: 'Output styles',
+  });
 
-  flowConfig.outputStyles = currentStyles;
+  flowConfig.outputStyles = updated;
   await configService.saveFlowConfig(flowConfig);
-
-  console.log(chalk.green(`\n✓ Output styles configuration saved`));
-  console.log(chalk.dim(`  Enabled styles: ${selectedStyles.length}`));
 }
 
 /**
@@ -276,14 +206,8 @@ async function configureMCP(configService: GlobalConfigService): Promise<void> {
   const mcpConfig = await configService.loadMCPConfig();
   const currentServers = mcpConfig.servers || {};
 
-  // Available MCP servers (from MCP_SERVER_REGISTRY)
-  const availableServers = {
-    grep: { name: 'GitHub Code Search (grep.app)', requiresEnv: [] },
-    context7: { name: 'Context7 Docs', requiresEnv: [] },
-    playwright: { name: 'Playwright Browser Control', requiresEnv: [] },
-    github: { name: 'GitHub', requiresEnv: ['GITHUB_TOKEN'] },
-    notion: { name: 'Notion', requiresEnv: ['NOTION_API_KEY'] },
-  };
+  // Get all servers from registry
+  const allServerIds = Object.keys(MCP_SERVER_REGISTRY) as MCPServerID[];
 
   // Get current enabled servers
   const currentEnabled = Object.keys(currentServers).filter((key) => currentServers[key].enabled);
@@ -293,40 +217,42 @@ async function configureMCP(configService: GlobalConfigService): Promise<void> {
       type: 'checkbox',
       name: 'selectedServers',
       message: 'Select MCP servers to enable:',
-      choices: Object.entries(availableServers).map(([key, info]) => {
+      choices: allServerIds.map((id) => {
+        const server = MCP_SERVER_REGISTRY[id];
+        const requiredEnvVars = getRequiredEnvVars(id);
         const requiresText =
-          info.requiresEnv.length > 0
-            ? chalk.dim(` (requires ${info.requiresEnv.join(', ')})`)
-            : '';
+          requiredEnvVars.length > 0 ? chalk.dim(` (requires ${requiredEnvVars.join(', ')})`) : '';
         return {
-          name: `${info.name}${requiresText}`,
-          value: key,
-          checked: currentEnabled.includes(key),
+          name: `${server.name} - ${server.description}${requiresText}`,
+          value: id,
+          checked: currentEnabled.includes(id) || server.defaultInInit,
         };
       }),
     },
   ]);
 
   // Update servers
-  for (const key of Object.keys(availableServers)) {
-    if (selectedServers.includes(key)) {
-      if (currentServers[key]) {
-        currentServers[key].enabled = true;
+  for (const id of allServerIds) {
+    if (selectedServers.includes(id)) {
+      if (currentServers[id]) {
+        currentServers[id].enabled = true;
       } else {
-        currentServers[key] = { enabled: true, env: {} };
+        currentServers[id] = { enabled: true, env: {} };
       }
-    } else if (currentServers[key]) {
-      currentServers[key].enabled = false;
+    } else if (currentServers[id]) {
+      currentServers[id].enabled = false;
     }
   }
 
   // Ask for API keys for newly enabled servers
-  for (const serverKey of selectedServers) {
-    const serverInfo = availableServers[serverKey as keyof typeof availableServers];
-    if (serverInfo.requiresEnv.length > 0) {
-      const server = currentServers[serverKey];
+  for (const serverId of selectedServers as MCPServerID[]) {
+    const serverDef = MCP_SERVER_REGISTRY[serverId];
+    const requiredEnvVars = getRequiredEnvVars(serverId);
+
+    if (requiredEnvVars.length > 0) {
+      const server = currentServers[serverId];
 
-      for (const envKey of serverInfo.requiresEnv) {
+      for (const envKey of requiredEnvVars) {
         const hasKey = server.env?.[envKey];
 
         const { shouldConfigure } = await inquirer.prompt([
@@ -334,8 +260,8 @@ async function configureMCP(configService: GlobalConfigService): Promise<void> {
             type: 'confirm',
             name: 'shouldConfigure',
             message: hasKey
-              ? `Update ${envKey} for ${serverInfo.name}?`
-              : `Configure ${envKey} for ${serverInfo.name}?`,
+              ? `Update ${envKey} for ${serverDef.name}?`
+              : `Configure ${envKey} for ${serverDef.name}?`,
             default: !hasKey,
           },
         ]);
@@ -452,7 +378,6 @@ async function configureTarget(configService: GlobalConfigService): Promise<void
   settings.defaultTarget = defaultTarget as
     | 'claude-code'
     | 'opencode'
-    | 'cursor'
     | 'ask-every-time';
   await configService.saveSettings(settings);
 

package/src/core/attach/file-attacher.ts

@@ -0,0 +1,172 @@
+/**
+ * Pure functions for file attachment operations
+ * Generic utilities for attaching files with conflict tracking
+ */
+
+import { existsSync } from 'node:fs';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export interface AttachItem {
+  name: string;
+  content: string;
+}
+
+export interface ConflictInfo {
+  type: string;
+  name: string;
+  action: 'overridden' | 'added' | 'skipped';
+  message: string;
+}
+
+export interface AttachStats {
+  added: string[];
+  overridden: string[];
+  conflicts: ConflictInfo[];
+}
+
+export interface ManifestTracker {
+  user: string[];
+  flow: string[];
+}
+
+// ============================================================================
+// Pure Functions
+// ============================================================================
+
+/**
+ * Create conflict info object
+ */
+export const createConflict = (
+  type: string,
+  name: string,
+  action: 'overridden' | 'added' | 'skipped' = 'overridden'
+): ConflictInfo => ({
+  type,
+  name,
+  action,
+  message: `${type.charAt(0).toUpperCase() + type.slice(1)} '${name}' ${action} (will be restored on exit)`,
+});
+
+/**
+ * Check if file exists at path
+ */
+export const fileExists = (filePath: string): boolean => existsSync(filePath);
+
+/**
+ * Ensure directory exists
+ */
+export const ensureDir = (dirPath: string): Promise<void> =>
+  fs.mkdir(dirPath, { recursive: true }).then(() => {});
+
+/**
+ * Write file content
+ */
+export const writeFile = (filePath: string, content: string): Promise<void> =>
+  fs.writeFile(filePath, content);
+
+/**
+ * Read file content
+ */
+export const readFile = (filePath: string): Promise<string> =>
+  fs.readFile(filePath, 'utf-8');
+
+// ============================================================================
+// Generic Attach Function
+// ============================================================================
+
+/**
+ * Attach multiple items to a directory with conflict tracking
+ * Pure function that returns stats and manifest updates
+ */
+export const attachItemsToDir = async (
+  items: AttachItem[],
+  targetDir: string,
+  itemType: string
+): Promise<{ stats: AttachStats; manifest: ManifestTracker }> => {
+  await ensureDir(targetDir);
+
+  const stats: AttachStats = {
+    added: [],
+    overridden: [],
+    conflicts: [],
+  };
+
+  const manifest: ManifestTracker = {
+    user: [],
+    flow: [],
+  };
+
+  for (const item of items) {
+    const itemPath = path.join(targetDir, item.name);
+    const existed = fileExists(itemPath);
+
+    if (existed) {
+      stats.overridden.push(item.name);
+      stats.conflicts.push(createConflict(itemType, item.name, 'overridden'));
+      manifest.user.push(item.name);
+    } else {
+      stats.added.push(item.name);
+    }
+
+    await writeFile(itemPath, item.content);
+    manifest.flow.push(item.name);
+  }
+
+  return { stats, manifest };
+};
+
+// ============================================================================
+// Rules Attachment (Append Strategy)
+// ============================================================================
+
+const FLOW_RULES_START = '<!-- ========== Sylphx Flow Rules (Auto-injected) ========== -->';
+const FLOW_RULES_END = '<!-- ========== End of Sylphx Flow Rules ========== -->';
+const FLOW_RULES_MARKER = '<!-- Sylphx Flow Rules -->';
+
+/**
+ * Check if content already has Flow rules appended
+ */
+export const hasFlowRules = (content: string): boolean =>
+  content.includes(FLOW_RULES_MARKER);
+
+/**
+ * Wrap rules content with markers
+ */
+export const wrapRulesContent = (rules: string): string =>
+  `\n\n${FLOW_RULES_START}\n\n${rules}\n\n${FLOW_RULES_END}\n`;
+
+/**
+ * Append rules to existing content
+ */
+export const appendRules = (existingContent: string, rules: string): string =>
+  existingContent + wrapRulesContent(rules);
+
+/**
+ * Attach rules file with append strategy
+ */
+export const attachRulesFile = async (
+  rulesPath: string,
+  rules: string
+): Promise<{ originalSize: number; flowContentAdded: boolean }> => {
+  if (fileExists(rulesPath)) {
+    const existingContent = await readFile(rulesPath);
+
+    // Skip if already appended
+    if (hasFlowRules(existingContent)) {
+      return { originalSize: existingContent.length, flowContentAdded: false };
+    }
+
+    await writeFile(rulesPath, appendRules(existingContent, rules));
+    return { originalSize: existingContent.length, flowContentAdded: true };
+  }
+
+  // Create new file
+  await ensureDir(path.dirname(rulesPath));
+  await writeFile(rulesPath, rules);
+  return { originalSize: 0, flowContentAdded: true };
+};

package/src/core/attach/index.ts

@@ -0,0 +1,5 @@
+/**
+ * Attach module - Pure functions for file attachment
+ */
+
+export * from './file-attacher.js';