@sylphx/flow 2.1.4 → 2.1.6

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

@@ -0,0 +1,170 @@
+/**
+ * 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';

package/src/core/attach-manager.ts

@@ -9,9 +9,10 @@ import { existsSync } from 'node:fs';
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import chalk from 'chalk';
-import { MCP_SERVER_REGISTRY } from '../config/servers.js';
+import { MCP_SERVER_REGISTRY, type MCPServerID } from '../config/servers.js';
 import { GlobalConfigService } from '../services/global-config.js';
 import type { Target } from '../types/target.types.js';
+import { attachItemsToDir, attachRulesFile } from './attach/index.js';
 import type { BackupManifest } from './backup-manager.js';
 import type { ProjectManager } from './project-manager.js';
 import { targetManager } from './target-manager.js';
@@ -79,30 +80,33 @@ export class AttachManager {
 
   /**
    * Load global MCP servers from ~/.sylphx-flow/mcp-config.json
+   * Uses SSOT: computeEffectiveServers for determining enabled servers
    */
   private async loadGlobalMCPServers(
     _target: Target
   ): Promise<Array<{ name: string; config: Record<string, unknown> }>> {
     try {
-      const enabledServers = await this.configService.getEnabledMCPServers();
+      const mcpConfig = await this.configService.loadMCPConfig();
+      const enabledServerIds = this.configService.getEnabledServerIds(mcpConfig.servers);
+      const effectiveServers = this.configService.getEffectiveMCPServers(mcpConfig.servers);
+
       const servers: Array<{ name: string; config: Record<string, unknown> }> = [];
 
-      for (const [serverKey, serverConfig] of Object.entries(enabledServers)) {
-        // Lookup server definition in registry
-        const serverDef = MCP_SERVER_REGISTRY[serverKey];
+      for (const serverId of enabledServerIds) {
+        const serverDef = MCP_SERVER_REGISTRY[serverId as MCPServerID];
+        const effective = effectiveServers[serverId as MCPServerID];
 
         if (!serverDef) {
-          console.warn(`MCP server '${serverKey}' not found in registry, skipping`);
           continue;
         }
 
         // Clone the server config from registry
         const config: Record<string, unknown> = { ...serverDef.config };
 
-        // Merge environment variables from global config
-        if (serverConfig.env && Object.keys(serverConfig.env).length > 0) {
+        // Merge environment variables from effective config (SSOT)
+        if (effective.env && Object.keys(effective.env).length > 0) {
           if (config.type === 'stdio' || config.type === 'local') {
-            config.env = { ...config.env, ...serverConfig.env };
+            config.env = { ...config.env, ...effective.env };
           }
         }
 
@@ -188,6 +192,7 @@ export class AttachManager {
 
   /**
    * Attach agents (override strategy)
+   * Uses shared attachItemsToDir function
    */
   private async attachAgents(
     projectPath: string,
@@ -196,40 +201,22 @@ export class AttachManager {
     result: AttachResult,
     manifest: BackupManifest
   ): Promise<void> {
-    // Use full path from target config
     const agentsDir = path.join(projectPath, target.config.agentDir);
-    await fs.mkdir(agentsDir, { recursive: true });
-
-    for (const agent of agents) {
-      const agentPath = path.join(agentsDir, agent.name);
-      const existed = existsSync(agentPath);
-
-      if (existed) {
-        // Conflict: user has same agent
-        result.agentsOverridden.push(agent.name);
-        result.conflicts.push({
-          type: 'agent',
-          name: agent.name,
-          action: 'overridden',
-          message: `Agent '${agent.name}' overridden (will be restored on exit)`,
-        });
-
-        // Track in manifest
-        manifest.backup.agents.user.push(agent.name);
-      } else {
-        result.agentsAdded.push(agent.name);
-      }
+    const { stats, manifest: itemManifest } = await attachItemsToDir(agents, agentsDir, 'agent');
 
-      // Write Flow agent (override)
-      await fs.writeFile(agentPath, agent.content);
+    // Update result
+    result.agentsAdded.push(...stats.added);
+    result.agentsOverridden.push(...stats.overridden);
+    result.conflicts.push(...stats.conflicts.map((c) => ({ ...c, type: 'agent' as const })));
 
-      // Track Flow agent
-      manifest.backup.agents.flow.push(agent.name);
-    }
+    // Update manifest
+    manifest.backup.agents.user.push(...itemManifest.user);
+    manifest.backup.agents.flow.push(...itemManifest.flow);
   }
 
   /**
    * Attach commands (override strategy)
+   * Uses shared attachItemsToDir function
    */
   private async attachCommands(
     projectPath: string,
@@ -238,40 +225,26 @@ export class AttachManager {
     result: AttachResult,
     manifest: BackupManifest
   ): Promise<void> {
-    // Use full path from target config
     const commandsDir = path.join(projectPath, target.config.slashCommandsDir);
-    await fs.mkdir(commandsDir, { recursive: true });
-
-    for (const command of commands) {
-      const commandPath = path.join(commandsDir, command.name);
-      const existed = existsSync(commandPath);
-
-      if (existed) {
-        // Conflict: user has same command
-        result.commandsOverridden.push(command.name);
-        result.conflicts.push({
-          type: 'command',
-          name: command.name,
-          action: 'overridden',
-          message: `Command '${command.name}' overridden (will be restored on exit)`,
-        });
-
-        // Track in manifest
-        manifest.backup.commands.user.push(command.name);
-      } else {
-        result.commandsAdded.push(command.name);
-      }
-
-      // Write Flow command (override)
-      await fs.writeFile(commandPath, command.content);
-
-      // Track Flow command
-      manifest.backup.commands.flow.push(command.name);
-    }
+    const { stats, manifest: itemManifest } = await attachItemsToDir(
+      commands,
+      commandsDir,
+      'command'
+    );
+
+    // Update result
+    result.commandsAdded.push(...stats.added);
+    result.commandsOverridden.push(...stats.overridden);
+    result.conflicts.push(...stats.conflicts.map((c) => ({ ...c, type: 'command' as const })));
+
+    // Update manifest
+    manifest.backup.commands.user.push(...itemManifest.user);
+    manifest.backup.commands.flow.push(...itemManifest.flow);
   }
 
   /**
    * Attach rules (append strategy for AGENTS.md)
+   * Uses shared attachRulesFile function
    */
   private async attachRules(
     projectPath: string,
@@ -280,52 +253,20 @@ export class AttachManager {
     result: AttachResult,
     manifest: BackupManifest
   ): Promise<void> {
-    // Use full paths from target config:
-    // - rulesFile defined (e.g., OpenCode): projectPath/rulesFile
-    // - rulesFile undefined (e.g., Claude Code): projectPath/agentDir/AGENTS.md
     const rulesPath = target.config.rulesFile
       ? path.join(projectPath, target.config.rulesFile)
       : path.join(projectPath, target.config.agentDir, 'AGENTS.md');
 
-    if (existsSync(rulesPath)) {
-      // User has AGENTS.md, append Flow rules
-      const userRules = await fs.readFile(rulesPath, 'utf-8');
-
-      // Check if already appended (avoid duplicates)
-      if (userRules.includes('<!-- Sylphx Flow Rules -->')) {
-        // Already appended, skip
-        return;
-      }
-
-      const merged = `${userRules}
-
-<!-- ========== Sylphx Flow Rules (Auto-injected) ========== -->
-
-${rules}
-
-<!-- ========== End of Sylphx Flow Rules ========== -->
-`;
-
-      await fs.writeFile(rulesPath, merged);
+    const { originalSize, flowContentAdded } = await attachRulesFile(rulesPath, rules);
 
+    if (flowContentAdded) {
       manifest.backup.rules = {
         path: rulesPath,
-        originalSize: userRules.length,
-        flowContentAdded: true,
-      };
-    } else {
-      // User doesn't have AGENTS.md, create new
-      await fs.mkdir(path.dirname(rulesPath), { recursive: true });
-      await fs.writeFile(rulesPath, rules);
-
-      manifest.backup.rules = {
-        path: rulesPath,
-        originalSize: 0,
+        originalSize,
         flowContentAdded: true,
       };
+      result.rulesAppended = true;
     }
-
-    result.rulesAppended = true;
   }
 
   /**

package/src/services/global-config.ts

@@ -7,10 +7,15 @@ import { existsSync } from 'node:fs';
 import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
+import {
+  computeEffectiveServers,
+  getEnabledServersFromEffective,
+  type MCPServerID,
+} from '../config/servers.js';
 
 export interface GlobalSettings {
   version: string;
-  defaultTarget?: 'claude-code' | 'opencode' | 'cursor' | 'ask-every-time';
+  defaultTarget?: 'claude-code' | 'opencode' | 'ask-every-time';
   defaultAgent?: string; // Default agent to use (e.g., 'coder', 'writer', 'reviewer', 'orchestrator')
   firstRun: boolean;
   lastUpdated: string;
@@ -198,22 +203,35 @@ export class GlobalConfigService {
   }
 
   /**
-   * Load MCP config
+   * Load raw MCP config from file (may be empty if no file)
    */
   async loadMCPConfig(): Promise<MCPConfig> {
     const configPath = this.getMCPConfigPath();
 
     if (!existsSync(configPath)) {
-      return {
-        version: '1.0.0',
-        servers: {},
-      };
+      return { version: '1.0.0', servers: {} };
     }
 
     const data = await fs.readFile(configPath, 'utf-8');
     return JSON.parse(data);
   }
 
+  /**
+   * Get effective MCP servers using SSOT computation
+   * Merges saved config with defaults from registry
+   */
+  getEffectiveMCPServers(savedServers: Record<string, MCPServerConfig> | undefined) {
+    return computeEffectiveServers(savedServers);
+  }
+
+  /**
+   * Get enabled server IDs using SSOT
+   */
+  getEnabledServerIds(savedServers: Record<string, MCPServerConfig> | undefined): MCPServerID[] {
+    const effective = computeEffectiveServers(savedServers);
+    return getEnabledServersFromEffective(effective);
+  }
+
   /**
    * Save MCP config
    */

package/src/services/target-installer.ts

@@ -1,6 +1,6 @@
 /**
  * Target Installation Service
- * Auto-detects and installs AI CLI tools (Claude Code, OpenCode, Cursor)
+ * Auto-detects and installs AI CLI tools (Claude Code, OpenCode)
  */
 
 import { exec } from 'node:child_process';
@@ -14,7 +14,7 @@ import { detectPackageManager, type PackageManager } from '../utils/package-mana
 const execAsync = promisify(exec);
 
 export interface TargetInstallation {
-  id: 'claude-code' | 'opencode' | 'cursor';
+  id: 'claude-code' | 'opencode';
   name: string;
   package: string;
   checkCommand: string;
@@ -61,16 +61,6 @@ const TARGET_INSTALLATIONS: TargetInstallation[] = [
       }
     },
   },
-  {
-    id: 'cursor',
-    name: 'Cursor',
-    package: 'cursor',
-    checkCommand: 'cursor --version',
-    installCommand: () => {
-      // Cursor is typically installed via installer, not npm
-      return 'Visit https://cursor.sh to download and install';
-    },
-  },
 ];
 
 export class TargetInstaller {
@@ -160,13 +150,6 @@ export class TargetInstaller {
       return false;
     }
 
-    // Special handling for Cursor (not npm-installable)
-    if (targetId === 'cursor') {
-      console.log(chalk.yellow('\n⚠️  Cursor requires manual installation'));
-      console.log(chalk.cyan('   Visit https://cursor.sh to download and install\n'));
-      return false;
-    }
-
     // Confirm installation unless auto-confirm is enabled
     if (!autoConfirm) {
       try {

package/src/targets/claude-code.ts

@@ -1,5 +1,4 @@
 import { spawn } from 'node:child_process';
-import fs from 'node:fs';
 import fsPromises from 'node:fs/promises';
 import path from 'node:path';
 import chalk from 'chalk';
@@ -7,10 +6,16 @@ import { installToDirectory } from '../core/installers/file-installer.js';
 import { createMCPInstaller } from '../core/installers/mcp-installer.js';
 import type { AgentMetadata } from '../types/target-config.types.js';
 import type { CommonOptions, MCPServerConfigUnion, SetupResult, Target } from '../types.js';
-import { getAgentsDir, getSlashCommandsDir } from '../utils/config/paths.js';
+import { getAgentsDir } from '../utils/config/paths.js';
 import { fileUtils, generateHelpText, pathUtils, yamlUtils } from '../utils/config/target-utils.js';
 import { CLIError } from '../utils/error-handler.js';
 import { sanitize } from '../utils/security/security.js';
+import {
+  detectTargetConfig,
+  setupSlashCommandsTo,
+  stripFrontMatter,
+  transformMCPConfig as transformMCP,
+} from './shared/index.js';
 
 /**
  * Claude Code target - composition approach with all original functionality
@@ -68,50 +73,10 @@ export const claudeCodeTarget: Target = {
 
   /**
    * Transform MCP server configuration for Claude Code
-   * Convert from various formats to Claude Code's optimal format
+   * Uses shared pure function for bidirectional conversion
    */
   transformMCPConfig(config: MCPServerConfigUnion, _serverId?: string): Record<string, unknown> {
-    // Handle legacy OpenCode 'local' type
-    if (config.type === 'local') {
-      // Convert OpenCode 'local' array command to Claude Code format
-      const [command, ...args] = config.command;
-      return {
-        type: 'stdio',
-        command,
-        ...(args && args.length > 0 && { args }),
-        ...(config.environment && { env: config.environment }),
-      };
-    }
-
-    // Handle new stdio format (already optimized for Claude Code)
-    if (config.type === 'stdio') {
-      return {
-        type: 'stdio',
-        command: config.command,
-        ...(config.args && config.args.length > 0 && { args: config.args }),
-        ...(config.env && { env: config.env }),
-      };
-    }
-
-    // Handle legacy OpenCode 'remote' type
-    if (config.type === 'remote') {
-      return {
-        type: 'http',
-        url: config.url,
-        ...(config.headers && { headers: config.headers }),
-      };
-    }
-
-    // Handle new http format (already optimized for Claude Code)
-    if (config.type === 'http') {
-      return {
-        type: 'http',
-        url: config.url,
-        ...(config.headers && { headers: config.headers }),
-      };
-    }
-
-    return config;
+    return transformMCP(config, 'claude-code');
   },
 
   getConfigPath: (cwd: string) =>
@@ -321,12 +286,7 @@ Please begin your response with a comprehensive summary of all the instructions
    * Detect if this target is being used in the current environment
    */
   detectFromEnvironment(): boolean {
-    try {
-      const cwd = process.cwd();
-      return fs.existsSync(path.join(cwd, '.mcp.json'));
-    } catch {
-      return false;
-    }
+    return detectTargetConfig(process.cwd(), '.mcp.json');
   },
 
   /**
@@ -377,9 +337,7 @@ Please begin your response with a comprehensive summary of all the instructions
    * Transform rules content for Claude Code
    * Claude Code doesn't need front matter in rules files (CLAUDE.md)
    */
-  async transformRulesContent(content: string): Promise<string> {
-    return yamlUtils.stripFrontMatter(content);
-  },
+  transformRulesContent: stripFrontMatter,
 
   /**
    * Setup hooks for Claude Code
@@ -524,23 +482,7 @@ Please begin your response with a comprehensive summary of all the instructions
     if (!this.config.slashCommandsDir) {
       return { count: 0 };
     }
-
-    const slashCommandsDir = path.join(cwd, this.config.slashCommandsDir);
-
-    const results = await installToDirectory(
-      getSlashCommandsDir(),
-      slashCommandsDir,
-      async (content) => {
-        // Slash commands are plain markdown with front matter - no transformation needed
-        return content;
-      },
-      {
-        ...options,
-        showProgress: false, // UI handled by init-command
-      }
-    );
-
-    return { count: results.length };
+    return setupSlashCommandsTo(path.join(cwd, this.config.slashCommandsDir), undefined, options);
   },
 };