@sylphx/flow 1.8.2 → 2.1.0

package/src/config/ai-config.ts

@@ -58,11 +58,6 @@ const GLOBAL_CONFIG_FILE = path.join(os.homedir(), '.sylphx-flow', 'settings.jso
 const PROJECT_CONFIG_FILE = '.sylphx-flow/settings.json';
 const LOCAL_CONFIG_FILE = '.sylphx-flow/settings.local.json';
 
-/**
- * Deprecated config file (for migration)
- */
-const LEGACY_CONFIG_FILE = '.sylphx-flow/ai-config.json';
-
 /**
  * Get AI config file paths in priority order
  */
@@ -70,12 +65,10 @@ export const getAIConfigPaths = (cwd: string = process.cwd()): {
   global: string;
   project: string;
   local: string;
-  legacy: string;
 } => ({
   global: GLOBAL_CONFIG_FILE,
   project: path.join(cwd, PROJECT_CONFIG_FILE),
   local: path.join(cwd, LOCAL_CONFIG_FILE),
-  legacy: path.join(cwd, LEGACY_CONFIG_FILE),
 });
 
 /**
@@ -140,18 +133,12 @@ export const aiConfigExists = async (cwd: string = process.cwd()): Promise<boole
     return true;
   } catch {}
 
-  try {
-    await fs.access(paths.legacy);
-    return true;
-  } catch {}
-
   return false;
 };
 
 /**
  * Load AI configuration
  * Merges global, project, and local configs with priority: local > project > global
- * Automatically migrates legacy config on first load
  */
 export const loadAIConfig = async (cwd: string = process.cwd()): Promise<Result<AIConfig, Error>> => {
   return tryCatchAsync(
@@ -159,39 +146,19 @@ export const loadAIConfig = async (cwd: string = process.cwd()): Promise<Result<
       const paths = getAIConfigPaths(cwd);
 
       // Load all config files
-      const [globalConfig, projectConfig, localConfig, legacyConfig] = await Promise.all([
+      const [globalConfig, projectConfig, localConfig] = await Promise.all([
         loadConfigFile(paths.global),
         loadConfigFile(paths.project),
         loadConfigFile(paths.local),
-        loadConfigFile(paths.legacy),
       ]);
 
-      // Auto-migrate legacy config if it exists and global doesn't
-      if (legacyConfig && !globalConfig) {
-        await migrateLegacyConfig(cwd);
-        // Reload global config after migration
-        const migratedGlobal = await loadConfigFile(paths.global);
-        if (migratedGlobal) {
-          // Start with empty config
-          let merged: AIConfig = {};
-
-          // Merge in priority order: global < project < local
-          merged = mergeConfigs(merged, migratedGlobal);
-          if (projectConfig) merged = mergeConfigs(merged, projectConfig);
-          if (localConfig) merged = mergeConfigs(merged, localConfig);
-
-          return merged;
-        }
-      }
-
       // Start with empty config
       let merged: AIConfig = {};
 
-      // Merge in priority order: global < project < local < legacy (for backwards compat)
+      // 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 (legacyConfig) merged = mergeConfigs(merged, legacyConfig);
 
       return merged;
     },
@@ -340,37 +307,3 @@ export const getConfiguredProviders = async (
   return providers;
 };
 
-/**
- * Migrate legacy ai-config.json to new settings system
- * Automatically called on first load if legacy config exists
- */
-export const migrateLegacyConfig = async (cwd: string = process.cwd()): Promise<Result<void, Error>> => {
-  return tryCatchAsync(
-    async () => {
-      const paths = getAIConfigPaths(cwd);
-
-      // Check if legacy config exists
-      const legacyConfig = await loadConfigFile(paths.legacy);
-      if (!legacyConfig) {
-        return; // No legacy config to migrate
-      }
-
-      // Check if global config already exists
-      const globalConfig = await loadConfigFile(paths.global);
-      if (globalConfig) {
-        // Global config exists, don't overwrite it
-        console.log('Legacy config found but global config already exists. Skipping migration.');
-        console.log(`You can manually delete ${paths.legacy} if migration is complete.`);
-        return;
-      }
-
-      // Migrate to global config
-      await fs.mkdir(path.dirname(paths.global), { recursive: true });
-      await fs.writeFile(paths.global, JSON.stringify(legacyConfig, null, 2) + '\n', 'utf8');
-
-      console.log(`✓ Migrated configuration from ${paths.legacy} to ${paths.global}`);
-      console.log(`  You can now safely delete the legacy file: ${paths.legacy}`);
-    },
-    (error: any) => new Error(`Failed to migrate legacy config: ${error.message}`)
-  );
-};

package/src/config/targets.ts

@@ -113,14 +113,3 @@ export const isTargetImplemented = (id: string): boolean => {
  * Utility type for target IDs
  */
 export type TargetID = ReturnType<typeof getAllTargetIDs>[number];
-
-/**
- * Legacy aliases for backward compatibility
- * @deprecated Use getAllTargets() instead
- */
-export const ALL_TARGETS = getAllTargets;
-
-/**
- * @deprecated Use getImplementedTargets() instead
- */
-export const IMPLEMENTED_TARGETS = getImplementedTargets;

package/src/core/attach-manager.ts

@@ -0,0 +1,495 @@
+/**
+ * Attach Manager
+ * Handles merging Flow templates into user's project environment
+ * Strategy: Direct override with backup, restore on cleanup
+ */
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { existsSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import chalk from 'chalk';
+import { ProjectManager } from './project-manager.js';
+import type { BackupManifest } from './backup-manager.js';
+import { GlobalConfigService } from '../services/global-config.js';
+import { MCP_SERVER_REGISTRY } from '../config/servers.js';
+
+export interface AttachResult {
+  agentsAdded: string[];
+  agentsOverridden: string[];
+  commandsAdded: string[];
+  commandsOverridden: string[];
+  rulesAppended: boolean;
+  mcpServersAdded: string[];
+  mcpServersOverridden: string[];
+  singleFilesMerged: string[];
+  hooksAdded: string[];
+  hooksOverridden: string[];
+  conflicts: ConflictInfo[];
+}
+
+export interface ConflictInfo {
+  type: 'agent' | 'command' | 'mcp' | 'hook';
+  name: string;
+  action: 'overridden' | 'merged';
+  message: string;
+}
+
+export interface FlowTemplates {
+  agents: Array<{ name: string; content: string }>;
+  commands: Array<{ name: string; content: string }>;
+  rules?: string;
+  mcpServers: Array<{ name: string; config: any }>;
+  hooks: Array<{ name: string; content: string }>;
+  singleFiles: Array<{ path: string; content: string }>;
+}
+
+export class AttachManager {
+  private projectManager: ProjectManager;
+  private configService: GlobalConfigService;
+
+  constructor(projectManager: ProjectManager) {
+    this.projectManager = projectManager;
+    this.configService = new GlobalConfigService();
+  }
+
+  /**
+   * Calculate SHA256 hash of file content
+   */
+  private async calculateFileHash(filePath: string): Promise<string> {
+    try {
+      const content = await fs.readFile(filePath, 'utf-8');
+      return createHash('sha256').update(content).digest('hex');
+    } catch {
+      return '';
+    }
+  }
+
+  /**
+   * Get target-specific directory names
+   */
+  private getTargetDirs(target: 'claude-code' | 'opencode'): {
+    agents: string;
+    commands: string;
+  } {
+    return target === 'claude-code'
+      ? { agents: 'agents', commands: 'commands' }
+      : { agents: 'agent', commands: 'command' };
+  }
+
+  /**
+   * Load global MCP servers from ~/.sylphx-flow/mcp-config.json
+   */
+  private async loadGlobalMCPServers(
+    target: 'claude-code' | 'opencode'
+  ): Promise<Array<{ name: string; config: any }>> {
+    try {
+      const enabledServers = await this.configService.getEnabledMCPServers();
+      const servers: Array<{ name: string; config: any }> = [];
+
+      for (const [serverKey, serverConfig] of Object.entries(enabledServers)) {
+        // Lookup server definition in registry
+        const serverDef = MCP_SERVER_REGISTRY[serverKey];
+
+        if (!serverDef) {
+          console.warn(`MCP server '${serverKey}' not found in registry, skipping`);
+          continue;
+        }
+
+        // Clone the server config from registry
+        let config: any = { ...serverDef.config };
+
+        // Merge environment variables from global config
+        if (serverConfig.env && Object.keys(serverConfig.env).length > 0) {
+          if (config.type === 'stdio' || config.type === 'local') {
+            config.env = { ...config.env, ...serverConfig.env };
+          }
+        }
+
+        servers.push({ name: serverDef.name, config });
+      }
+
+      return servers;
+    } catch (error) {
+      // If global config doesn't exist or fails to load, return empty array
+      return [];
+    }
+  }
+
+  /**
+   * Attach Flow templates to project
+   * Strategy: Override with warning, backup handles restoration
+   */
+  async attach(
+    projectPath: string,
+    projectHash: string,
+    target: 'claude-code' | 'opencode',
+    templates: FlowTemplates,
+    manifest: BackupManifest
+  ): Promise<AttachResult> {
+    const targetDir = this.projectManager.getTargetConfigDir(projectPath, target);
+
+    const result: AttachResult = {
+      agentsAdded: [],
+      agentsOverridden: [],
+      commandsAdded: [],
+      commandsOverridden: [],
+      rulesAppended: false,
+      mcpServersAdded: [],
+      mcpServersOverridden: [],
+      singleFilesMerged: [],
+      hooksAdded: [],
+      hooksOverridden: [],
+      conflicts: [],
+    };
+
+    // Ensure target directory exists
+    await fs.mkdir(targetDir, { recursive: true });
+
+    // 1. Attach agents
+    await this.attachAgents(targetDir, target, templates.agents, result, manifest);
+
+    // 2. Attach commands
+    await this.attachCommands(targetDir, target, templates.commands, result, manifest);
+
+    // 3. Attach rules (if applicable)
+    if (templates.rules) {
+      await this.attachRules(targetDir, target, templates.rules, result, manifest);
+    }
+
+    // 4. Attach MCP servers (merge global + template servers)
+    const globalMCPServers = await this.loadGlobalMCPServers(target);
+    const allMCPServers = [...globalMCPServers, ...templates.mcpServers];
+
+    if (allMCPServers.length > 0) {
+      await this.attachMCPServers(
+        targetDir,
+        target,
+        allMCPServers,
+        result,
+        manifest
+      );
+    }
+
+    // 5. Attach hooks
+    if (templates.hooks.length > 0) {
+      await this.attachHooks(targetDir, templates.hooks, result, manifest);
+    }
+
+    // 6. Attach single files
+    if (templates.singleFiles.length > 0) {
+      await this.attachSingleFiles(projectPath, templates.singleFiles, result, manifest);
+    }
+
+    // Show conflict warnings
+    this.showConflictWarnings(result);
+
+    return result;
+  }
+
+  /**
+   * Attach agents (override strategy)
+   */
+  private async attachAgents(
+    targetDir: string,
+    target: 'claude-code' | 'opencode',
+    agents: Array<{ name: string; content: string }>,
+    result: AttachResult,
+    manifest: BackupManifest
+  ): Promise<void> {
+    const dirs = this.getTargetDirs(target);
+    const agentsDir = path.join(targetDir, dirs.agents);
+    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);
+    }
+  }
+
+  /**
+   * Attach commands (override strategy)
+   */
+  private async attachCommands(
+    targetDir: string,
+    target: 'claude-code' | 'opencode',
+    commands: Array<{ name: string; content: string }>,
+    result: AttachResult,
+    manifest: BackupManifest
+  ): Promise<void> {
+    const dirs = this.getTargetDirs(target);
+    const commandsDir = path.join(targetDir, dirs.commands);
+    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);
+    }
+  }
+
+  /**
+   * Attach rules (append strategy for AGENTS.md)
+   */
+  private async attachRules(
+    targetDir: string,
+    target: 'claude-code' | 'opencode',
+    rules: string,
+    result: AttachResult,
+    manifest: BackupManifest
+  ): Promise<void> {
+    // Claude Code: .claude/agents/AGENTS.md
+    // OpenCode: .opencode/AGENTS.md
+    const dirs = this.getTargetDirs(target);
+    const rulesPath =
+      target === 'claude-code'
+        ? path.join(targetDir, dirs.agents, 'AGENTS.md')
+        : path.join(targetDir, '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);
+
+      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,
+        flowContentAdded: true,
+      };
+    }
+
+    result.rulesAppended = true;
+  }
+
+  /**
+   * Attach MCP servers (merge strategy)
+   */
+  private async attachMCPServers(
+    targetDir: string,
+    target: 'claude-code' | 'opencode',
+    mcpServers: Array<{ name: string; config: any }>,
+    result: AttachResult,
+    manifest: BackupManifest
+  ): Promise<void> {
+    // Claude Code: .claude/settings.json (mcp.servers)
+    // OpenCode: .opencode/.mcp.json
+    const configPath =
+      target === 'claude-code'
+        ? path.join(targetDir, 'settings.json')
+        : path.join(targetDir, '.mcp.json');
+
+    let config: any = {};
+
+    if (existsSync(configPath)) {
+      config = JSON.parse(await fs.readFile(configPath, 'utf-8'));
+    }
+
+    // Ensure mcp.servers exists
+    if (!config.mcp) config.mcp = {};
+    if (!config.mcp.servers) config.mcp.servers = {};
+
+    // Add Flow MCP servers
+    for (const server of mcpServers) {
+      if (config.mcp.servers[server.name]) {
+        // Conflict: user has same MCP server
+        result.mcpServersOverridden.push(server.name);
+        result.conflicts.push({
+          type: 'mcp',
+          name: server.name,
+          action: 'overridden',
+          message: `MCP server '${server.name}' overridden (will be restored on exit)`,
+        });
+      } else {
+        result.mcpServersAdded.push(server.name);
+      }
+
+      // Override with Flow config
+      config.mcp.servers[server.name] = server.config;
+    }
+
+    // Write updated config
+    await fs.writeFile(configPath, JSON.stringify(config, null, 2));
+
+    // Track in manifest
+    manifest.backup.config = {
+      path: configPath,
+      hash: await this.calculateFileHash(configPath),
+      mcpServersCount: Object.keys(config.mcp.servers).length,
+    };
+  }
+
+  /**
+   * Attach hooks (override strategy)
+   */
+  private async attachHooks(
+    targetDir: string,
+    hooks: Array<{ name: string; content: string }>,
+    result: AttachResult,
+    manifest: BackupManifest
+  ): Promise<void> {
+    const hooksDir = path.join(targetDir, 'hooks');
+    await fs.mkdir(hooksDir, { recursive: true });
+
+    for (const hook of hooks) {
+      const hookPath = path.join(hooksDir, hook.name);
+      const existed = existsSync(hookPath);
+
+      if (existed) {
+        result.hooksOverridden.push(hook.name);
+        result.conflicts.push({
+          type: 'hook',
+          name: hook.name,
+          action: 'overridden',
+          message: `Hook '${hook.name}' overridden (will be restored on exit)`,
+        });
+      } else {
+        result.hooksAdded.push(hook.name);
+      }
+
+      await fs.writeFile(hookPath, hook.content);
+    }
+  }
+
+  /**
+   * Attach single files (CLAUDE.md, .cursorrules, etc.)
+   */
+  private async attachSingleFiles(
+    projectPath: string,
+    singleFiles: Array<{ path: string; content: string }>,
+    result: AttachResult,
+    manifest: BackupManifest
+  ): Promise<void> {
+    for (const file of singleFiles) {
+      const filePath = path.join(projectPath, file.path);
+      const existed = existsSync(filePath);
+
+      if (existed) {
+        // User has file, append Flow content
+        const userContent = await fs.readFile(filePath, 'utf-8');
+
+        // Check if already appended
+        if (userContent.includes('<!-- Sylphx Flow Enhancement -->')) {
+          continue;
+        }
+
+        const merged = `${userContent}
+
+---
+
+**Sylphx Flow Enhancement:**
+
+${file.content}
+`;
+
+        await fs.writeFile(filePath, merged);
+
+        manifest.backup.singleFiles[file.path] = {
+          existed: true,
+          originalSize: userContent.length,
+          flowContentAdded: true,
+        };
+      } else {
+        // Create new file
+        await fs.writeFile(filePath, file.content);
+
+        manifest.backup.singleFiles[file.path] = {
+          existed: false,
+          originalSize: 0,
+          flowContentAdded: true,
+        };
+      }
+
+      result.singleFilesMerged.push(file.path);
+    }
+  }
+
+  /**
+   * Show conflict warnings to user
+   */
+  private showConflictWarnings(result: AttachResult): void {
+    if (result.conflicts.length === 0) {
+      return;
+    }
+
+    console.log(chalk.yellow('\n⚠️  Conflicts detected:\n'));
+
+    for (const conflict of result.conflicts) {
+      console.log(
+        chalk.yellow(`   • ${conflict.type}: ${conflict.name} - ${conflict.action}`)
+      );
+    }
+
+    console.log(
+      chalk.dim('\n   Don\'t worry! All overridden content will be restored on exit.\n')
+    );
+  }
+}