@sylphx/flow 2.1.4 → 2.1.5

package/src/core/attach-manager.ts

@@ -12,6 +12,7 @@ import chalk from 'chalk';
 import { MCP_SERVER_REGISTRY } 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';
@@ -188,6 +189,7 @@ export class AttachManager {
 
   /**
    * Attach agents (override strategy)
+   * Uses shared attachItemsToDir function
    */
   private async attachAgents(
     projectPath: string,
@@ -196,40 +198,24 @@ 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);
-      }
-
-      // Write Flow agent (override)
-      await fs.writeFile(agentPath, agent.content);
-
-      // Track Flow agent
-      manifest.backup.agents.flow.push(agent.name);
-    }
+    const { stats, manifest: itemManifest } = await attachItemsToDir(agents, agentsDir, 'agent');
+
+    // Update result
+    result.agentsAdded.push(...stats.added);
+    result.agentsOverridden.push(...stats.overridden);
+    result.conflicts.push(
+      ...stats.conflicts.map((c) => ({ ...c, type: 'agent' as const }))
+    );
+
+    // 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 +224,24 @@ 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 +250,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

@@ -10,7 +10,7 @@ import path from 'node:path';
 
 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;

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

@@ -3,14 +3,19 @@ import fs from 'node:fs';
 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 } 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 {
+  transformMCPConfig as transformMCP,
+  detectTargetConfig,
+  stripFrontMatter,
+  setupSlashCommandsTo,
+} 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);
   },
 };
 

package/src/targets/opencode.ts

@@ -11,6 +11,12 @@ import { getAgentsDir, getOutputStylesDir, getSlashCommandsDir } from '../utils/
 import { fileUtils, generateHelpText, yamlUtils } from '../utils/config/target-utils.js';
 import { CLIError } from '../utils/error-handler.js';
 import { secretUtils } from '../utils/security/secret-utils.js';
+import {
+  transformMCPConfig as transformMCP,
+  detectTargetConfig,
+  stripFrontMatter,
+  setupSlashCommandsTo,
+} from './shared/index.js';
 
 /**
  * OpenCode target - composition approach with all original functionality
@@ -80,44 +86,10 @@ export const opencodeTarget: Target = {
 
   /**
    * Transform MCP server configuration for OpenCode
-   * Convert from Claude Code's optimal format to OpenCode's format
+   * Uses shared pure function for bidirectional conversion
    */
   transformMCPConfig(config: MCPServerConfigUnion, _serverId?: string): Record<string, unknown> {
-    // Handle new Claude Code stdio format
-    if (config.type === 'stdio') {
-      // Convert Claude Code format to OpenCode format
-      const openCodeConfig: Record<string, unknown> = {
-        type: 'local',
-        command: [config.command],
-      };
-
-      if (config.args && config.args.length > 0) {
-        openCodeConfig.command.push(...config.args);
-      }
-
-      if (config.env) {
-        openCodeConfig.environment = config.env;
-      }
-
-      return openCodeConfig;
-    }
-
-    // Handle new Claude Code http format
-    if (config.type === 'http') {
-      // Claude Code http format is compatible with OpenCode remote format
-      return {
-        type: 'remote',
-        url: config.url,
-        ...(config.headers && { headers: config.headers }),
-      };
-    }
-
-    // Handle legacy OpenCode formats (pass through)
-    if (config.type === 'local' || config.type === 'remote') {
-      return config;
-    }
-
-    return config;
+    return transformMCP(config, 'opencode');
   },
 
   getConfigPath: (cwd: string) =>
@@ -217,21 +189,14 @@ export const opencodeTarget: Target = {
    * Detect if this target is being used in the current environment
    */
   detectFromEnvironment(): boolean {
-    try {
-      const cwd = process.cwd();
-      return fs.existsSync(path.join(cwd, 'opencode.jsonc'));
-    } catch {
-      return false;
-    }
+    return detectTargetConfig(process.cwd(), 'opencode.jsonc');
   },
 
   /**
    * Transform rules content for OpenCode
    * OpenCode doesn't need front matter in rules files (AGENTS.md)
    */
-  async transformRulesContent(content: string): Promise<string> {
-    return yamlUtils.stripFrontMatter(content);
-  },
+  transformRulesContent: stripFrontMatter,
 
   /**
    * Setup agents for OpenCode
@@ -380,23 +345,7 @@ export const opencodeTarget: Target = {
     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);
   },
 
   /**

package/src/targets/shared/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Shared target utilities
+ * Pure functions for common target operations
+ */
+
+export * from './mcp-transforms.js';
+export * from './target-operations.js';

package/src/targets/shared/mcp-transforms.ts

@@ -0,0 +1,132 @@
+/**
+ * Pure functions for MCP configuration transformations
+ * Bidirectional conversion between Claude Code and OpenCode formats
+ */
+
+import type { MCPServerConfigUnion } from '../../types.js';
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export type MCPFormat = 'claude-code' | 'opencode';
+
+export interface StdioConfig {
+  type: 'stdio';
+  command: string;
+  args?: string[];
+  env?: Record<string, string>;
+}
+
+export interface HttpConfig {
+  type: 'http';
+  url: string;
+  headers?: Record<string, string>;
+}
+
+export interface LocalConfig {
+  type: 'local';
+  command: string[];
+  environment?: Record<string, string>;
+}
+
+export interface RemoteConfig {
+  type: 'remote';
+  url: string;
+  headers?: Record<string, string>;
+}
+
+// ============================================================================
+// Pure Transform Functions
+// ============================================================================
+
+/**
+ * Convert stdio format to local format (Claude Code → OpenCode)
+ */
+export const stdioToLocal = (config: StdioConfig): LocalConfig => ({
+  type: 'local',
+  command: config.args ? [config.command, ...config.args] : [config.command],
+  ...(config.env && { environment: config.env }),
+});
+
+/**
+ * Convert local format to stdio format (OpenCode → Claude Code)
+ */
+export const localToStdio = (config: LocalConfig): StdioConfig => {
+  const [command, ...args] = config.command;
+  return {
+    type: 'stdio',
+    command,
+    ...(args.length > 0 && { args }),
+    ...(config.environment && { env: config.environment }),
+  };
+};
+
+/**
+ * Convert http format to remote format (Claude Code → OpenCode)
+ */
+export const httpToRemote = (config: HttpConfig): RemoteConfig => ({
+  type: 'remote',
+  url: config.url,
+  ...(config.headers && { headers: config.headers }),
+});
+
+/**
+ * Convert remote format to http format (OpenCode → Claude Code)
+ */
+export const remoteToHttp = (config: RemoteConfig): HttpConfig => ({
+  type: 'http',
+  url: config.url,
+  ...(config.headers && { headers: config.headers }),
+});
+
+/**
+ * Normalize stdio config (ensure consistent structure)
+ */
+export const normalizeStdio = (config: StdioConfig): StdioConfig => ({
+  type: 'stdio',
+  command: config.command,
+  ...(config.args && config.args.length > 0 && { args: config.args }),
+  ...(config.env && { env: config.env }),
+});
+
+/**
+ * Normalize http config (ensure consistent structure)
+ */
+export const normalizeHttp = (config: HttpConfig): HttpConfig => ({
+  type: 'http',
+  url: config.url,
+  ...(config.headers && { headers: config.headers }),
+});
+
+// ============================================================================
+// Main Transform Function
+// ============================================================================
+
+/**
+ * Transform MCP config to target format
+ * Pure function - no side effects
+ */
+export const transformMCPConfig = (
+  config: MCPServerConfigUnion,
+  targetFormat: MCPFormat
+): Record<string, unknown> => {
+  // Claude Code format (stdio/http)
+  if (targetFormat === 'claude-code') {
+    if (config.type === 'local') return localToStdio(config as LocalConfig);
+    if (config.type === 'remote') return remoteToHttp(config as RemoteConfig);
+    if (config.type === 'stdio') return normalizeStdio(config as StdioConfig);
+    if (config.type === 'http') return normalizeHttp(config as HttpConfig);
+    return config;
+  }
+
+  // OpenCode format (local/remote)
+  if (targetFormat === 'opencode') {
+    if (config.type === 'stdio') return stdioToLocal(config as StdioConfig);
+    if (config.type === 'http') return httpToRemote(config as HttpConfig);
+    if (config.type === 'local' || config.type === 'remote') return config;
+    return config;
+  }
+
+  return config;
+};