@sylphx/flow 2.1.3 → 2.1.5

package/src/commands/settings-command.ts

@@ -3,13 +3,15 @@
  * Interactive configuration for Sylphx Flow
  */
 
-import { Command } from 'commander';
 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 { UserCancelledError } from '../utils/errors.js';
 import { TargetInstaller } from '../services/target-installer.js';
-import { promptForDefaultTarget, buildAvailableTargets } from '../utils/target-selection.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')
@@ -30,9 +32,10 @@ export const settingsCommand = new Command('settings')
       } else {
         await showMainMenu(configService);
       }
-    } catch (error: any) {
+    } catch (error: unknown) {
       // Handle user cancellation (Ctrl+C)
-      if (error.name === 'ExitPromptError' || error.message?.includes('force closed')) {
+      const err = error as Error & { name?: string };
+      if (err.name === 'ExitPromptError' || err.message?.includes('force closed')) {
         throw new UserCancelledError('Settings cancelled by user');
       }
       throw error;
@@ -105,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',
@@ -122,40 +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,
       })),
@@ -163,113 +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}`));
 }
 
 /**
@@ -281,67 +206,62 @@ 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
-  );
+  const currentEnabled = Object.keys(currentServers).filter((key) => currentServers[key].enabled);
 
   const { selectedServers } = await inquirer.prompt([
     {
       type: 'checkbox',
       name: 'selectedServers',
       message: 'Select MCP servers to enable:',
-      choices: Object.entries(availableServers).map(([key, info]) => {
-        const requiresText = info.requiresEnv.length > 0
-          ? chalk.dim(` (requires ${info.requiresEnv.join(', ')})`)
-          : '';
+      choices: allServerIds.map((id) => {
+        const server = MCP_SERVER_REGISTRY[id];
+        const requiredEnvVars = getRequiredEnvVars(id);
+        const requiresText =
+          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, env: {} };
+  for (const id of allServerIds) {
+    if (selectedServers.includes(id)) {
+      if (currentServers[id]) {
+        currentServers[id].enabled = true;
       } else {
-        currentServers[key].enabled = true;
+        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);
 
-      for (const envKey of serverInfo.requiresEnv) {
-        const hasKey = server.env && server.env[envKey];
+    if (requiredEnvVars.length > 0) {
+      const server = currentServers[serverId];
+
+      for (const envKey of requiredEnvVars) {
+        const hasKey = server.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,
           },
         ]);
@@ -406,7 +326,9 @@ async function configureProvider(configService: GlobalConfigService): Promise<vo
       {
         type: 'confirm',
         name: 'shouldConfigure',
-        message: currentKey ? `Update ${defaultProvider} API key?` : `Configure ${defaultProvider} API key?`,
+        message: currentKey
+          ? `Update ${defaultProvider} API key?`
+          : `Configure ${defaultProvider} API key?`,
         default: !currentKey,
       },
     ]);
@@ -424,8 +346,11 @@ async function configureProvider(configService: GlobalConfigService): Promise<vo
       if (!providerConfig.claudeCode.providers[defaultProvider]) {
         providerConfig.claudeCode.providers[defaultProvider] = { enabled: true };
       }
-      providerConfig.claudeCode.providers[defaultProvider]!.apiKey = apiKey;
-      providerConfig.claudeCode.providers[defaultProvider]!.enabled = true;
+      const provider = providerConfig.claudeCode.providers[defaultProvider];
+      if (provider) {
+        provider.apiKey = apiKey;
+        provider.enabled = true;
+      }
     }
   }
 
@@ -450,7 +375,10 @@ 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/ai-config.ts

@@ -10,12 +10,15 @@
  */
 
 import fs from 'node:fs/promises';
-import path from 'node:path';
 import os from 'node:os';
+import path from 'node:path';
 import { z } from 'zod';
-import { type Result, success, tryCatchAsync } from '../core/functional/result.js';
+import { type Result, tryCatchAsync } from '../core/functional/result.js';
 import { getAllProviders } from '../providers/index.js';
-import type { ProviderId, ProviderConfigValue as ProviderConfigValueType } from '../types/provider.types.js';
+import type {
+  ProviderConfigValue as ProviderConfigValueType,
+  ProviderId,
+} from '../types/provider.types.js';
 
 // Re-export types for backward compatibility
 export type { ProviderId } from '../types/provider.types.js';
@@ -39,14 +42,20 @@ export type ProviderConfigValue = ProviderConfigValueType;
  * Uses generic Record for provider configs - validation happens at provider level
  */
 const aiConfigSchema = z.object({
-  defaultProvider: z.enum(['anthropic', 'openai', 'google', 'openrouter', 'claude-code', 'zai']).optional(),
+  defaultProvider: z
+    .enum(['anthropic', 'openai', 'google', 'openrouter', 'claude-code', 'zai'])
+    .optional(),
   defaultModel: z.string().optional(),
-  providers: z.record(
-    z.string(),
-    z.object({
-      defaultModel: z.string().optional(),
-    }).passthrough() // Allow additional fields defined by provider
-  ).optional(),
+  providers: z
+    .record(
+      z.string(),
+      z
+        .object({
+          defaultModel: z.string().optional(),
+        })
+        .passthrough() // Allow additional fields defined by provider
+    )
+    .optional(),
 });
 
 export type AIConfig = z.infer<typeof aiConfigSchema>;
@@ -61,7 +70,9 @@ const LOCAL_CONFIG_FILE = '.sylphx-flow/settings.local.json';
 /**
  * Get AI config file paths in priority order
  */
-export const getAIConfigPaths = (cwd: string = process.cwd()): {
+export const getAIConfigPaths = (
+  cwd: string = process.cwd()
+): {
   global: string;
   project: string;
   local: string;
@@ -79,8 +90,9 @@ const loadConfigFile = async (filePath: string): Promise<AIConfig | null> => {
     const content = await fs.readFile(filePath, 'utf8');
     const parsed = JSON.parse(content);
     return aiConfigSchema.parse(parsed);
-  } catch (error: any) {
-    if (error.code === 'ENOENT') {
+  } catch (error: unknown) {
+    const err = error as NodeJS.ErrnoException;
+    if (err.code === 'ENOENT') {
       return null; // File doesn't exist
     }
     throw error; // Re-throw other errors
@@ -97,7 +109,7 @@ const mergeConfigs = (a: AIConfig, b: AIConfig): AIConfig => {
     ...Object.keys(b.providers || {}),
   ]);
 
-  const mergedProviders: Record<string, any> = {};
+  const mergedProviders: Record<string, Record<string, unknown>> = {};
   for (const providerId of allProviderIds) {
     mergedProviders[providerId] = {
       ...a.providers?.[providerId],
@@ -117,30 +129,31 @@ const mergeConfigs = (a: AIConfig, b: AIConfig): AIConfig => {
  */
 export const aiConfigExists = async (cwd: string = process.cwd()): Promise<boolean> => {
   const paths = getAIConfigPaths(cwd);
-  try {
-    // Check any of the config files
-    await fs.access(paths.global).catch(() => {});
-    return true;
-  } catch {}
-
-  try {
-    await fs.access(paths.project);
-    return true;
-  } catch {}
 
-  try {
-    await fs.access(paths.local);
-    return true;
-  } catch {}
+  // Check if any config file exists
+  const checks = await Promise.all([
+    fs
+      .access(paths.global)
+      .then(() => true)
+      .catch(() => false),
+    fs
+      .access(paths.project)
+      .then(() => true)
+      .catch(() => false),
+    fs
+      .access(paths.local)
+      .then(() => true)
+      .catch(() => false),
+  ]);
 
-  return false;
+  return checks.some(Boolean);
 };
 
 /**
  * Load AI configuration
  * Merges global, project, and local configs with priority: local > project > global
  */
-export const loadAIConfig = async (cwd: string = process.cwd()): Promise<Result<AIConfig, Error>> => {
+export const loadAIConfig = (cwd: string = process.cwd()): Promise<Result<AIConfig, Error>> => {
   return tryCatchAsync(
     async () => {
       const paths = getAIConfigPaths(cwd);
@@ -156,13 +169,19 @@ export const loadAIConfig = async (cwd: string = process.cwd()): Promise<Result<
       let merged: AIConfig = {};
 
       // Merge in priority order: global < project < local
-      if (globalConfig) merged = mergeConfigs(merged, globalConfig);
-      if (projectConfig) merged = mergeConfigs(merged, projectConfig);
-      if (localConfig) merged = mergeConfigs(merged, localConfig);
+      if (globalConfig) {
+        merged = mergeConfigs(merged, globalConfig);
+      }
+      if (projectConfig) {
+        merged = mergeConfigs(merged, projectConfig);
+      }
+      if (localConfig) {
+        merged = mergeConfigs(merged, localConfig);
+      }
 
       return merged;
     },
-    (error: any) => new Error(`Failed to load AI config: ${error.message}`)
+    (error: unknown) => new Error(`Failed to load AI config: ${(error as Error).message}`)
   );
 };
 
@@ -171,7 +190,7 @@ export const loadAIConfig = async (cwd: string = process.cwd()): Promise<Result<
  * By default, all configuration (including API keys) goes to ~/.sylphx-flow/settings.json
  * Automatically sets default provider if not set
  */
-export const saveAIConfig = async (
+export const saveAIConfig = (
   config: AIConfig,
   cwd: string = process.cwd()
 ): Promise<Result<void, Error>> => {
@@ -211,16 +230,16 @@ export const saveAIConfig = async (
       const validated = aiConfigSchema.parse(configToSave);
 
       // Write config
-      await fs.writeFile(configPath, JSON.stringify(validated, null, 2) + '\n', 'utf8');
+      await fs.writeFile(configPath, `${JSON.stringify(validated, null, 2)}\n`, 'utf8');
     },
-    (error: any) => new Error(`Failed to save AI config: ${error.message}`)
+    (error: unknown) => new Error(`Failed to save AI config: ${(error as Error).message}`)
   );
 };
 
 /**
  * Save AI configuration to a specific location
  */
-export const saveAIConfigTo = async (
+export const saveAIConfigTo = (
   config: AIConfig,
   location: 'global' | 'project' | 'local',
   cwd: string = process.cwd()
@@ -237,9 +256,10 @@ export const saveAIConfigTo = async (
       const validated = aiConfigSchema.parse(config);
 
       // Write config
-      await fs.writeFile(configPath, JSON.stringify(validated, null, 2) + '\n', 'utf8');
+      await fs.writeFile(configPath, `${JSON.stringify(validated, null, 2)}\n`, 'utf8');
     },
-    (error: any) => new Error(`Failed to save AI config to ${location}: ${error.message}`)
+    (error: unknown) =>
+      new Error(`Failed to save AI config to ${location}: ${(error as Error).message}`)
   );
 };
 
@@ -306,4 +326,3 @@ export const getConfiguredProviders = async (
 
   return providers;
 };
-

package/src/core/agent-loader.ts

@@ -3,9 +3,9 @@
  * Loads agent definitions from markdown files with front matter
  */
 
-import { readFile, readdir, access } from 'node:fs/promises';
-import { join, parse, relative, dirname } from 'node:path';
+import { access, readdir, readFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
+import { dirname, join, parse, relative } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import matter from 'gray-matter';
 import type { Agent, AgentMetadata } from '../types/agent.types.js';
@@ -52,7 +52,10 @@ export async function loadAgentFromFile(
 /**
  * Load all agents from a directory (recursively)
  */
-export async function loadAgentsFromDirectory(dirPath: string, isBuiltin: boolean = false): Promise<Agent[]> {
+export async function loadAgentsFromDirectory(
+  dirPath: string,
+  isBuiltin: boolean = false
+): Promise<Agent[]> {
   try {
     // Read directory recursively to support subdirectories
     const files = await readdir(dirPath, { recursive: true, withFileTypes: true });
@@ -72,7 +75,7 @@ export async function loadAgentsFromDirectory(dirPath: string, isBuiltin: boolea
     );
 
     return agents.filter((agent): agent is Agent => agent !== null);
-  } catch (error) {
+  } catch (_error) {
     // Directory doesn't exist or can't be read
     return [];
   }
@@ -117,7 +120,7 @@ export async function loadAllAgents(cwd: string, targetAgentDir?: string): Promi
   const systemPath = await getSystemAgentsPath();
   const [globalPath, projectPath] = getAgentSearchPaths(cwd);
 
-  let allAgentPaths = [systemPath, globalPath, projectPath];
+  const allAgentPaths = [systemPath, globalPath, projectPath];
 
   // If a target-specific agent directory is provided, add it with highest priority
   if (targetAgentDir) {
@@ -126,7 +129,9 @@ export async function loadAllAgents(cwd: string, targetAgentDir?: string): Promi
   }
 
   // Load agents from all paths
-  const loadedAgentsPromises = allAgentPaths.map(path => loadAgentsFromDirectory(path, path === systemPath));
+  const loadedAgentsPromises = allAgentPaths.map((path) =>
+    loadAgentsFromDirectory(path, path === systemPath)
+  );
   const loadedAgentsArrays = await Promise.all(loadedAgentsPromises);
 
   // Flatten and deduplicate