@sylphx/flow 3.18.0 → 3.19.1

package/src/services/config-service.ts

@@ -11,6 +11,7 @@ import {
   getProjectSettingsFile,
   USER_SETTINGS_FILE,
 } from '../config/constants.js';
+import { readJsonFileSafe } from '../utils/files/file-operations.js';
 
 /**
  * User configuration (sensitive data, saved to home directory)
@@ -102,13 +103,8 @@ export class ConfigService {
   /**
    * Load user global settings (mainly for API keys)
    */
-  static async loadHomeSettings(): Promise<UserSettings> {
-    try {
-      const content = await fs.readFile(USER_SETTINGS_FILE, 'utf-8');
-      return JSON.parse(content);
-    } catch {
-      return {};
-    }
+  static loadHomeSettings(): Promise<UserSettings> {
+    return readJsonFileSafe<UserSettings>(USER_SETTINGS_FILE, {});
   }
 
   /**
@@ -154,14 +150,8 @@ export class ConfigService {
   /**
    * Load project-level settings
    */
-  static async loadProjectSettings(cwd: string = process.cwd()): Promise<ProjectSettings> {
-    try {
-      const configPath = getProjectSettingsFile(cwd);
-      const content = await fs.readFile(configPath, 'utf-8');
-      return JSON.parse(content);
-    } catch {
-      return {};
-    }
+  static loadProjectSettings(cwd: string = process.cwd()): Promise<ProjectSettings> {
+    return readJsonFileSafe<ProjectSettings>(getProjectSettingsFile(cwd), {});
   }
 
   /**
@@ -186,14 +176,8 @@ export class ConfigService {
   /**
    * Load project-local settings (overrides everything)
    */
-  static async loadLocalSettings(cwd: string = process.cwd()): Promise<RuntimeChoices> {
-    try {
-      const configPath = getProjectLocalSettingsFile(cwd);
-      const content = await fs.readFile(configPath, 'utf-8');
-      return JSON.parse(content);
-    } catch {
-      return {};
-    }
+  static loadLocalSettings(cwd: string = process.cwd()): Promise<RuntimeChoices> {
+    return readJsonFileSafe<RuntimeChoices>(getProjectLocalSettingsFile(cwd), {});
   }
 
   /**

package/src/services/index.ts

@@ -10,4 +10,4 @@ export {
   installServers,
   listAvailableServers,
   validateServerConfiguration,
-} from './mcp-service';
+} from './mcp-service.js';

package/src/targets/claude-code.ts

@@ -2,11 +2,8 @@ import { spawn } from 'node:child_process';
 import fsPromises from 'node:fs/promises';
 import path from 'node:path';
 import chalk from 'chalk';
-import { installToDirectory } from '../core/installers/file-installer.js';
-import { createMCPInstaller } from '../core/installers/mcp-installer.js';
 import type { AgentMetadata, FrontMatterMetadata } from '../types/target-config.types.js';
 import type { CommonOptions, MCPServerConfigUnion, SetupResult, Target } from '../types.js';
-import { getAgentsDir } from '../utils/config/paths.js';
 import {
   type ConfigData,
   fileUtils,
@@ -14,11 +11,11 @@ import {
   pathUtils,
   yamlUtils,
 } from '../utils/config/target-utils.js';
-import { CLIError } from '../utils/error-handler.js';
+import { CLIError } from '../utils/errors.js';
 import { sanitize } from '../utils/security/security.js';
+import { DEFAULT_CLAUDE_CODE_ENV } from './functional/claude-code-logic.js';
 import {
   detectTargetConfig,
-  setupSlashCommandsTo,
   stripFrontMatter,
   transformMCPConfig as transformMCP,
 } from './shared/index.js';
@@ -40,6 +37,11 @@ interface ProcessExitError extends Error {
   code: number | null;
 }
 
+/** Type guard for Node.js errors with errno/code properties */
+function isNodeError(error: unknown): error is NodeJS.ErrnoException {
+  return error instanceof Error && 'code' in error;
+}
+
 /**
  * Claude Code target - composition approach with all original functionality
  */
@@ -70,6 +72,7 @@ export const claudeCodeTarget: Target = {
       createConfigFile: true,
       useSecretFiles: false,
     },
+    supportsMCP: true,
   },
 
   /**
@@ -271,7 +274,7 @@ Please begin your response with a comprehensive summary of all the instructions
         const child = spawn('claude', args, {
           stdio: 'inherit',
           shell: false,
-          env: process.env, // Pass environment variables including ANTHROPIC_BASE_URL and ANTHROPIC_API_KEY
+          env: { ...process.env, ...DEFAULT_CLAUDE_CODE_ENV },
         });
 
         child.on('spawn', () => {
@@ -298,17 +301,19 @@ Please begin your response with a comprehensive summary of all the instructions
         });
       });
     } catch (error: unknown) {
-      const err = error as NodeJS.ErrnoException & { code?: string | number };
-      if (err.code === 'ENOENT') {
-        throw new CLIError('Claude Code not found. Please install it first.', 'CLAUDE_NOT_FOUND');
+      if (isNodeError(error)) {
+        if (error.code === 'ENOENT') {
+          throw new CLIError('Claude Code not found. Please install it first.', 'CLAUDE_NOT_FOUND');
+        }
+        if (error.code !== undefined) {
+          throw new CLIError(`Claude Code exited with code ${error.code}`, 'CLAUDE_ERROR');
+        }
+        throw new CLIError(`Failed to execute Claude Code: ${error.message}`, 'CLAUDE_ERROR');
       }
-      if (err.code) {
-        throw new CLIError(`Claude Code exited with code ${err.code}`, 'CLAUDE_ERROR');
+      if (error instanceof Error) {
+        throw new CLIError(`Failed to execute Claude Code: ${error.message}`, 'CLAUDE_ERROR');
       }
-      throw new CLIError(
-        `Failed to execute Claude Code: ${(error as Error).message}`,
-        'CLAUDE_ERROR'
-      );
+      throw new CLIError(`Failed to execute Claude Code: ${String(error)}`, 'CLAUDE_ERROR');
     }
   },
 
@@ -333,8 +338,7 @@ Please begin your response with a comprehensive summary of all the instructions
         const content = await fsPromises.readFile(settingsPath, 'utf8');
         settings = JSON.parse(content);
       } catch (error: unknown) {
-        const err = error as NodeJS.ErrnoException;
-        if (err.code !== 'ENOENT') {
+        if (!isNodeError(error) || error.code !== 'ENOENT') {
           throw error;
         }
         // File doesn't exist, will create new
@@ -370,10 +374,10 @@ Please begin your response with a comprehensive summary of all the instructions
   transformRulesContent: stripFrontMatter,
 
   /**
-   * Setup hooks for Claude Code
-   * Configure session and prompt hooks for system information display
+   * Apply Claude Code settings (attribution, hooks, env, thinking mode)
+   * Merges Flow defaults into .claude/settings.json, preserving user settings
    */
-  async setupHooks(cwd: string, _options: CommonOptions): Promise<SetupResult> {
+  async applySettings(cwd: string, _options: CommonOptions): Promise<SetupResult> {
     const { processSettings, generateHookCommands } = await import(
       './functional/claude-code-logic.js'
     );
@@ -425,95 +429,6 @@ Please begin your response with a comprehensive summary of all the instructions
       message: 'Configured notification hook',
     };
   },
-
-  /**
-   * Setup agents for Claude Code
-   * Install agents to .claude/agents/ directory with rules appended
-   * Output styles are applied dynamically at runtime based on user settings
-   */
-  async setupAgents(cwd: string, options: CommonOptions): Promise<SetupResult> {
-    const { enhanceAgentContent } = await import('../utils/agent-enhancer.js');
-    const agentsDir = path.join(cwd, this.config.agentDir);
-
-    const results = await installToDirectory(
-      getAgentsDir(),
-      agentsDir,
-      async (content, sourcePath) => {
-        // Extract rules from ORIGINAL content before transformation
-        const { metadata } = await yamlUtils.extractFrontMatter(content);
-        const rules = metadata.rules as string[] | undefined;
-
-        // Transform agent content (converts to Claude Code format, strips unsupported fields)
-        const transformed = await this.transformAgentContent(content, undefined, sourcePath);
-
-        // Enhance with rules only (output styles are applied dynamically at runtime)
-        const enhanced = await enhanceAgentContent(transformed, rules, []);
-
-        return enhanced;
-      },
-      {
-        ...options,
-        showProgress: false, // UI handled by init-command
-      }
-    );
-
-    return { count: results.length };
-  },
-
-  /**
-   * Setup output styles for Claude Code
-   * Output styles are appended to each agent file
-   */
-  async setupOutputStyles(_cwd: string, _options: CommonOptions): Promise<SetupResult> {
-    // Output styles are appended to each agent file during setupAgents
-    // No separate installation needed
-    return {
-      count: 0,
-      message: 'Output styles included in agent files',
-    };
-  },
-
-  /**
-   * Setup rules for Claude Code
-   * Rules are appended to each agent file
-   */
-  async setupRules(_cwd: string, _options: CommonOptions): Promise<SetupResult> {
-    // Rules are appended to each agent file during setupAgents
-    // No separate CLAUDE.md file needed
-    return {
-      count: 0,
-      message: 'Rules included in agent files',
-    };
-  },
-
-  /**
-   * Setup MCP servers for Claude Code
-   * Select, configure, install, and approve MCP servers
-   */
-  async setupMCP(cwd: string, options: CommonOptions): Promise<SetupResult> {
-    const installer = createMCPInstaller(this);
-    const result = await installer.setupMCP({ ...options, quiet: true });
-
-    // Approve servers in Claude Code settings
-    if (result.selectedServers.length > 0 && !options.dryRun) {
-      if (this.approveMCPServers) {
-        await this.approveMCPServers(cwd, result.selectedServers);
-      }
-    }
-
-    return { count: result.selectedServers.length };
-  },
-
-  /**
-   * Setup slash commands for Claude Code
-   * Install slash command templates to .claude/commands/ directory
-   */
-  async setupSlashCommands(cwd: string, options: CommonOptions): Promise<SetupResult> {
-    if (!this.config.slashCommandsDir) {
-      return { count: 0 };
-    }
-    return setupSlashCommandsTo(path.join(cwd, this.config.slashCommandsDir), undefined, options);
-  },
 };
 
 /**

package/src/targets/functional/claude-code-logic.ts

@@ -12,7 +12,7 @@
 import type { ConfigError } from '../../core/functional/error-types.js';
 import { configError } from '../../core/functional/error-types.js';
 import type { Result } from '../../core/functional/result.js';
-import { failure, success, tryCatch } from '../../core/functional/result.js';
+import { success, tryCatch } from '../../core/functional/result.js';
 
 /**
  * Claude Code settings structure
@@ -44,14 +44,19 @@ export interface ClaudeCodeSettings {
   [key: string]: unknown;
 }
 
+/**
+ * Default environment variables injected into the Claude Code process
+ */
+export const DEFAULT_CLAUDE_CODE_ENV: Record<string, string> = {
+  CLAUDE_CODE_MAX_OUTPUT_TOKENS: '128000',
+  CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS: '1',
+};
+
 /**
  * Default Claude Code settings for optimal experience
  */
-export const DEFAULT_CLAUDE_CODE_SETTINGS: Partial<ClaudeCodeSettings> = {
-  env: {
-    CLAUDE_CODE_MAX_OUTPUT_TOKENS: '128000',
-    CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS: '1',
-  },
+const DEFAULT_CLAUDE_CODE_SETTINGS: Partial<ClaudeCodeSettings> = {
+  env: DEFAULT_CLAUDE_CODE_ENV,
   attribution: {
     commit: '',
     pr: '',
@@ -77,32 +82,20 @@ export const generateHookCommands = async (targetId: string): Promise<HookConfig
  * Default hook commands (fallback)
  * Simplified to only include notification hook
  */
-export const DEFAULT_HOOKS: HookConfig = {
+const DEFAULT_HOOKS: HookConfig = {
   notificationCommand: 'sylphx-flow hook --type notification --target claude-code',
 };
 
 /**
- * Parse JSON settings (pure)
- */
-export const parseSettings = (content: string): Result<ClaudeCodeSettings, ConfigError> => {
-  return tryCatch(
-    () => JSON.parse(content) as ClaudeCodeSettings,
-    (error) =>
-      configError('Failed to parse Claude Code settings', {
-        cause: error instanceof Error ? error : undefined,
-      })
-  );
-};
-
-/**
- * Build hook configuration (pure)
+ * Process settings: parse existing or create new, merge hooks, serialize (pure)
  */
-export const buildHookConfiguration = (
-  config: HookConfig = DEFAULT_HOOKS
-): ClaudeCodeSettings['hooks'] => {
-  const notificationCommand = config.notificationCommand || DEFAULT_HOOKS.notificationCommand!;
+export const processSettings = (
+  existingContent: string | null,
+  hookConfig: HookConfig = DEFAULT_HOOKS
+): Result<string, ConfigError> => {
+  const notificationCommand = hookConfig.notificationCommand || DEFAULT_HOOKS.notificationCommand!;
 
-  return {
+  const hookConfiguration: ClaudeCodeSettings['hooks'] = {
     Notification: [
       {
         matcher: '',
@@ -115,98 +108,49 @@ export const buildHookConfiguration = (
       },
     ],
   };
-};
 
-/**
- * Merge settings with defaults and new hooks (pure)
- * Preserves existing values while adding missing defaults
- */
-export const mergeSettings = (
-  existingSettings: ClaudeCodeSettings,
-  hookConfig: HookConfig = DEFAULT_HOOKS
-): ClaudeCodeSettings => {
-  const newHooks = buildHookConfiguration(hookConfig);
+  const createNewSettings = (): ClaudeCodeSettings => ({
+    ...DEFAULT_CLAUDE_CODE_SETTINGS,
+    hooks: hookConfiguration,
+  });
 
-  return {
-    // Apply defaults first, then existing settings override
+  const serialize = (settings: ClaudeCodeSettings): string => JSON.stringify(settings, null, 2);
+
+  if (existingContent === null || existingContent.trim() === '') {
+    return success(serialize(createNewSettings()));
+  }
+
+  // Parse existing settings
+  const parseResult = tryCatch(
+    () => JSON.parse(existingContent) as ClaudeCodeSettings,
+    (error) =>
+      configError('Failed to parse Claude Code settings', {
+        cause: error instanceof Error ? error : undefined,
+      })
+  );
+
+  if (parseResult._tag === 'Failure') {
+    return success(serialize(createNewSettings()));
+  }
+
+  // Merge with existing
+  const existingSettings = parseResult.value;
+  const merged: ClaudeCodeSettings = {
     ...DEFAULT_CLAUDE_CODE_SETTINGS,
     ...existingSettings,
-    // Deep merge env variables
     env: {
       ...DEFAULT_CLAUDE_CODE_SETTINGS.env,
       ...(existingSettings.env || {}),
     },
-    // Deep merge attribution
     attribution: {
       ...DEFAULT_CLAUDE_CODE_SETTINGS.attribution,
       ...(existingSettings.attribution || {}),
     },
-    // Merge hooks
     hooks: {
       ...(existingSettings.hooks || {}),
-      ...newHooks,
+      ...hookConfiguration,
     },
   };
-};
-
-/**
- * Create settings with defaults and hooks (pure)
- * Includes optimal Claude Code settings for extended output, thinking mode, and clean attribution
- */
-export const createSettings = (hookConfig: HookConfig = DEFAULT_HOOKS): ClaudeCodeSettings => {
-  return {
-    ...DEFAULT_CLAUDE_CODE_SETTINGS,
-    hooks: buildHookConfiguration(hookConfig),
-  };
-};
-
-/**
- * Serialize settings to JSON (pure)
- */
-export const serializeSettings = (settings: ClaudeCodeSettings): string => {
-  return JSON.stringify(settings, null, 2);
-};
-
-/**
- * Get success message (pure)
- */
-export const getSuccessMessage = (): string => {
-  return 'Claude Code hook configured: Notification';
-};
-
-/**
- * Process settings: parse existing or create new, merge hooks, serialize (pure)
- */
-export const processSettings = (
-  existingContent: string | null,
-  hookConfig: HookConfig = DEFAULT_HOOKS
-): Result<string, ConfigError> => {
-  if (existingContent === null || existingContent.trim() === '') {
-    // No existing settings, create new
-    const settings = createSettings(hookConfig);
-    return success(serializeSettings(settings));
-  }
-
-  // Parse existing settings
-  const parseResult = parseSettings(existingContent);
-  if (parseResult._tag === 'Failure') {
-    // If parsing fails, create new settings
-    const settings = createSettings(hookConfig);
-    return success(serializeSettings(settings));
-  }
-
-  // Merge with existing
-  const merged = mergeSettings(parseResult.value, hookConfig);
-  return success(serializeSettings(merged));
-};
-
-/**
- * Validate hook configuration (pure)
- */
-export const validateHookConfig = (config: HookConfig): Result<HookConfig, ConfigError> => {
-  if (config.notificationCommand !== undefined && config.notificationCommand.trim() === '') {
-    return failure(configError('Notification command cannot be empty'));
-  }
 
-  return success(config);
+  return success(serialize(merged));
 };