@sylphx/flow 2.1.4 → 2.1.6

package/CHANGELOG.md

@@ -1,5 +1,36 @@
 # @sylphx/flow
 
+## 2.1.6 (2025-11-28)
+
+### 🐛 Bug Fixes
+
+- **settings:** respect saved MCP server enabled state ([8447cea](https://github.com/SylphxAI/flow/commit/8447cea1b2f46e49cfc1bd7e57e557307d072163))
+- **mcp:** return default servers when no config exists ([bd6c588](https://github.com/SylphxAI/flow/commit/bd6c58819cdde8e31bd18cdc2f05c2c45e4f3d39))
+
+### ♻️ Refactoring
+
+- **mcp:** implement SSOT for server configuration ([e0b5ee0](https://github.com/SylphxAI/flow/commit/e0b5ee01d4952e825d81005465147ce39963bbd0))
+
+### 🔧 Chores
+
+- format package.json (tabs to spaces) ([305096a](https://github.com/SylphxAI/flow/commit/305096a9e276a3626415d76b8f313e95dc6daeff))
+
+## 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.6",
 	"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,17 @@
 import chalk from 'chalk';
 import { Command } from 'commander';
 import inquirer from 'inquirer';
+import {
+  computeEffectiveServers,
+  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 } from './settings/index.js';
 
 export const settingsCommand = new Command('settings')
   .description('Configure Sylphx Flow settings')
@@ -106,16 +113,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 +126,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 +149,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}`));
 }
 
 /**
@@ -274,68 +209,60 @@ async function configureMCP(configService: GlobalConfigService): Promise<void> {
   console.log(chalk.cyan.bold('\n━━━ 📡 MCP Server Configuration\n'));
 
   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'] },
-  };
+  const savedServers = mcpConfig.servers || {};
 
-  // Get current enabled servers
-  const currentEnabled = Object.keys(currentServers).filter((key) => currentServers[key].enabled);
+  // SSOT: compute effective state from saved config + defaults
+  const effectiveServers = computeEffectiveServers(savedServers);
+  const allServerIds = Object.keys(MCP_SERVER_REGISTRY) as MCPServerID[];
 
   const { selectedServers } = await inquirer.prompt([
     {
       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 effective = effectiveServers[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: effective.enabled, // Use SSOT effective state
         };
       }),
     },
   ]);
 
-  // Update servers
-  for (const key of Object.keys(availableServers)) {
-    if (selectedServers.includes(key)) {
-      if (currentServers[key]) {
-        currentServers[key].enabled = true;
-      } else {
-        currentServers[key] = { enabled: true, env: {} };
-      }
-    } else if (currentServers[key]) {
-      currentServers[key].enabled = false;
-    }
+  // Update servers - save ALL servers with explicit enabled state
+  const updatedServers: Record<string, { enabled: boolean; env: Record<string, string> }> = {};
+  for (const id of allServerIds) {
+    const effective = effectiveServers[id];
+    updatedServers[id] = {
+      enabled: selectedServers.includes(id),
+      env: effective.env, // Preserve existing env vars
+    };
   }
 
   // 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 serverState = updatedServers[serverId];
 
-      for (const envKey of serverInfo.requiresEnv) {
-        const hasKey = server.env?.[envKey];
+      for (const envKey of requiredEnvVars) {
+        const hasKey = serverState.env?.[envKey];
 
         const { shouldConfigure } = await inquirer.prompt([
           {
             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,
           },
         ]);
@@ -350,16 +277,13 @@ async function configureMCP(configService: GlobalConfigService): Promise<void> {
             },
           ]);
 
-          if (!server.env) {
-            server.env = {};
-          }
-          server.env[envKey] = apiKey;
+          serverState.env[envKey] = apiKey;
         }
       }
     }
   }
 
-  mcpConfig.servers = currentServers;
+  mcpConfig.servers = updatedServers;
   await configService.saveMCPConfig(mcpConfig);
 
   console.log(chalk.green(`\n✓ MCP configuration saved`));
@@ -449,11 +373,7 @@ async function configureTarget(configService: GlobalConfigService): Promise<void
 
   const defaultTarget = await promptForDefaultTarget(installedTargets, settings.defaultTarget);
 
-  settings.defaultTarget = defaultTarget as
-    | 'claude-code'
-    | 'opencode'
-    | 'cursor'
-    | 'ask-every-time';
+  settings.defaultTarget = defaultTarget as 'claude-code' | 'opencode' | 'ask-every-time';
   await configService.saveSettings(settings);
 
   if (defaultTarget === 'ask-every-time') {

package/src/config/servers.ts

@@ -339,3 +339,70 @@ export function getServerDefinition(id: MCPServerID): MCPServerDefinition {
   }
   return server;
 }
+
+// ============================================================================
+// SSOT: Effective Server Config
+// ============================================================================
+
+/**
+ * Saved server state (from user config file)
+ */
+export interface SavedServerState {
+  enabled: boolean;
+  env?: Record<string, string>;
+}
+
+/**
+ * Effective server state (computed from saved + defaults)
+ */
+export interface EffectiveServerState {
+  id: MCPServerID;
+  enabled: boolean;
+  env: Record<string, string>;
+  /** Whether this server was in saved config or using default */
+  isDefault: boolean;
+}
+
+/**
+ * Compute effective server states from saved config
+ * This is the SSOT for determining which servers are enabled
+ *
+ * Logic:
+ * - If server is in savedConfig, use its enabled state
+ * - If server is NOT in savedConfig, use defaultInInit from registry
+ *
+ * @param savedServers - Servers from user's config file (may be empty/undefined)
+ * @returns Map of server ID to effective state
+ */
+export function computeEffectiveServers(
+  savedServers: Record<string, SavedServerState> | undefined
+): Record<MCPServerID, EffectiveServerState> {
+  const result: Record<string, EffectiveServerState> = {};
+  const saved = savedServers || {};
+
+  for (const [id, def] of Object.entries(MCP_SERVER_REGISTRY)) {
+    const serverId = id as MCPServerID;
+    const savedState = saved[id];
+    const isInSaved = id in saved;
+
+    result[serverId] = {
+      id: serverId,
+      enabled: isInSaved ? (savedState?.enabled ?? false) : (def.defaultInInit ?? false),
+      env: savedState?.env || {},
+      isDefault: !isInSaved,
+    };
+  }
+
+  return result as Record<MCPServerID, EffectiveServerState>;
+}
+
+/**
+ * Get only enabled servers from effective config
+ */
+export function getEnabledServersFromEffective(
+  effective: Record<MCPServerID, EffectiveServerState>
+): MCPServerID[] {
+  return Object.entries(effective)
+    .filter(([, state]) => state.enabled)
+    .map(([id]) => id as MCPServerID);
+}