@sylphx/flow 2.1.3 → 2.1.4

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

package/src/core/attach-manager.ts

@@ -4,15 +4,17 @@
  * Strategy: Direct override with backup, restore on cleanup
  */
 
+import { createHash } from 'node:crypto';
+import { existsSync } from 'node:fs';
 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';
+import { GlobalConfigService } from '../services/global-config.js';
+import type { Target } from '../types/target.types.js';
+import type { BackupManifest } from './backup-manager.js';
+import type { ProjectManager } from './project-manager.js';
+import { targetManager } from './target-manager.js';
 
 export interface AttachResult {
   agentsAdded: string[];
@@ -39,13 +41,12 @@ export interface FlowTemplates {
   agents: Array<{ name: string; content: string }>;
   commands: Array<{ name: string; content: string }>;
   rules?: string;
-  mcpServers: Array<{ name: string; config: any }>;
+  mcpServers: Array<{ name: string; config: Record<string, unknown> }>;
   hooks: Array<{ name: string; content: string }>;
   singleFiles: Array<{ path: string; content: string }>;
 }
 
 export class AttachManager {
-  private projectManager: ProjectManager;
   private configService: GlobalConfigService;
 
   constructor(projectManager: ProjectManager) {
@@ -66,26 +67,25 @@ export class AttachManager {
   }
 
   /**
-   * Get target-specific directory names
+   * Resolve target from ID string to Target object
    */
-  private getTargetDirs(target: 'claude-code' | 'opencode'): {
-    agents: string;
-    commands: string;
-  } {
-    return target === 'claude-code'
-      ? { agents: 'agents', commands: 'commands' }
-      : { agents: 'agent', commands: 'command' };
+  private resolveTarget(targetId: string): Target {
+    const targetOption = targetManager.getTarget(targetId);
+    if (targetOption._tag === 'None') {
+      throw new Error(`Unknown target: ${targetId}`);
+    }
+    return targetOption.value;
   }
 
   /**
    * Load global MCP servers from ~/.sylphx-flow/mcp-config.json
    */
   private async loadGlobalMCPServers(
-    target: 'claude-code' | 'opencode'
-  ): Promise<Array<{ name: string; config: any }>> {
+    _target: Target
+  ): Promise<Array<{ name: string; config: Record<string, unknown> }>> {
     try {
       const enabledServers = await this.configService.getEnabledMCPServers();
-      const servers: Array<{ name: string; config: any }> = [];
+      const servers: Array<{ name: string; config: Record<string, unknown> }> = [];
 
       for (const [serverKey, serverConfig] of Object.entries(enabledServers)) {
         // Lookup server definition in registry
@@ -97,7 +97,7 @@ export class AttachManager {
         }
 
         // Clone the server config from registry
-        let config: any = { ...serverDef.config };
+        const config: Record<string, unknown> = { ...serverDef.config };
 
         // Merge environment variables from global config
         if (serverConfig.env && Object.keys(serverConfig.env).length > 0) {
@@ -110,7 +110,7 @@ export class AttachManager {
       }
 
       return servers;
-    } catch (error) {
+    } catch (_error) {
       // If global config doesn't exist or fails to load, return empty array
       return [];
     }
@@ -119,15 +119,21 @@ export class AttachManager {
   /**
    * Attach Flow templates to project
    * Strategy: Override with warning, backup handles restoration
+   * @param projectPath - Project root path
+   * @param _projectHash - Project hash (unused but kept for API compatibility)
+   * @param targetOrId - Target object or target ID string
+   * @param templates - Flow templates to attach
+   * @param manifest - Backup manifest to track changes
    */
   async attach(
     projectPath: string,
-    projectHash: string,
-    target: 'claude-code' | 'opencode',
+    _projectHash: string,
+    targetOrId: Target | string,
     templates: FlowTemplates,
     manifest: BackupManifest
   ): Promise<AttachResult> {
-    const targetDir = this.projectManager.getTargetConfigDir(projectPath, target);
+    // Resolve target from ID if needed
+    const target = typeof targetOrId === 'string' ? this.resolveTarget(targetOrId) : targetOrId;
 
     const result: AttachResult = {
       agentsAdded: [],
@@ -143,18 +149,17 @@ export class AttachManager {
       conflicts: [],
     };
 
-    // Ensure target directory exists
-    await fs.mkdir(targetDir, { recursive: true });
+    // All paths are relative to projectPath, using target.config.* directly
 
     // 1. Attach agents
-    await this.attachAgents(targetDir, target, templates.agents, result, manifest);
+    await this.attachAgents(projectPath, target, templates.agents, result, manifest);
 
     // 2. Attach commands
-    await this.attachCommands(targetDir, target, templates.commands, result, manifest);
+    await this.attachCommands(projectPath, target, templates.commands, result, manifest);
 
     // 3. Attach rules (if applicable)
     if (templates.rules) {
-      await this.attachRules(targetDir, target, templates.rules, result, manifest);
+      await this.attachRules(projectPath, target, templates.rules, result, manifest);
     }
 
     // 4. Attach MCP servers (merge global + template servers)
@@ -162,18 +167,12 @@ export class AttachManager {
     const allMCPServers = [...globalMCPServers, ...templates.mcpServers];
 
     if (allMCPServers.length > 0) {
-      await this.attachMCPServers(
-        targetDir,
-        target,
-        allMCPServers,
-        result,
-        manifest
-      );
+      await this.attachMCPServers(projectPath, target, allMCPServers, result, manifest);
     }
 
     // 5. Attach hooks
     if (templates.hooks.length > 0) {
-      await this.attachHooks(targetDir, templates.hooks, result, manifest);
+      await this.attachHooks(projectPath, target, templates.hooks, result, manifest);
     }
 
     // 6. Attach single files
@@ -191,14 +190,14 @@ export class AttachManager {
    * Attach agents (override strategy)
    */
   private async attachAgents(
-    targetDir: string,
-    target: 'claude-code' | 'opencode',
+    projectPath: string,
+    target: Target,
     agents: Array<{ name: string; content: string }>,
     result: AttachResult,
     manifest: BackupManifest
   ): Promise<void> {
-    const dirs = this.getTargetDirs(target);
-    const agentsDir = path.join(targetDir, dirs.agents);
+    // 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) {
@@ -233,14 +232,14 @@ export class AttachManager {
    * Attach commands (override strategy)
    */
   private async attachCommands(
-    targetDir: string,
-    target: 'claude-code' | 'opencode',
+    projectPath: string,
+    target: Target,
     commands: Array<{ name: string; content: string }>,
     result: AttachResult,
     manifest: BackupManifest
   ): Promise<void> {
-    const dirs = this.getTargetDirs(target);
-    const commandsDir = path.join(targetDir, dirs.commands);
+    // 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) {
@@ -275,19 +274,18 @@ export class AttachManager {
    * Attach rules (append strategy for AGENTS.md)
    */
   private async attachRules(
-    targetDir: string,
-    target: 'claude-code' | 'opencode',
+    projectPath: string,
+    target: Target,
     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');
+    // 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
@@ -332,34 +330,43 @@ ${rules}
 
   /**
    * Attach MCP servers (merge strategy)
+   * Uses target.config.configFile and target.config.mcpConfigPath
+   * Note: configFile is relative to project root, not targetDir
    */
   private async attachMCPServers(
-    targetDir: string,
-    target: 'claude-code' | 'opencode',
-    mcpServers: Array<{ name: string; config: any }>,
+    projectPath: string,
+    target: Target,
+    mcpServers: Array<{ name: string; config: Record<string, unknown> }>,
     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');
+    // Use target config for file path and MCP config structure
+    // Claude Code: .mcp.json at project root with mcpServers key
+    // OpenCode: opencode.jsonc at project root with mcp key
+    const configPath = path.join(projectPath, target.config.configFile);
+    const mcpPath = target.config.mcpConfigPath;
 
-    let config: any = {};
+    let config: Record<string, unknown> = {};
 
     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 = {};
+    // Get or create the MCP servers object at the correct path
+    // Claude Code: config.mcpServers = {}
+    // OpenCode: config.mcp = {}
+    let mcpContainer = config[mcpPath] as Record<string, unknown> | undefined;
+    if (!mcpContainer) {
+      mcpContainer = {};
+      config[mcpPath] = mcpContainer;
+    }
 
     // Add Flow MCP servers
     for (const server of mcpServers) {
-      if (config.mcp.servers[server.name]) {
+      // Transform the server config for this target
+      const transformedConfig = target.transformMCPConfig(server.config as any, server.name);
+
+      if (mcpContainer[server.name]) {
         // Conflict: user has same MCP server
         result.mcpServersOverridden.push(server.name);
         result.conflicts.push({
@@ -372,8 +379,8 @@ ${rules}
         result.mcpServersAdded.push(server.name);
       }
 
-      // Override with Flow config
-      config.mcp.servers[server.name] = server.config;
+      // Override with Flow config (transformed for target)
+      mcpContainer[server.name] = transformedConfig;
     }
 
     // Write updated config
@@ -383,7 +390,7 @@ ${rules}
     manifest.backup.config = {
       path: configPath,
       hash: await this.calculateFileHash(configPath),
-      mcpServersCount: Object.keys(config.mcp.servers).length,
+      mcpServersCount: Object.keys(mcpContainer).length,
     };
   }
 
@@ -391,12 +398,14 @@ ${rules}
    * Attach hooks (override strategy)
    */
   private async attachHooks(
-    targetDir: string,
+    projectPath: string,
+    target: Target,
     hooks: Array<{ name: string; content: string }>,
     result: AttachResult,
-    manifest: BackupManifest
+    _manifest: BackupManifest
   ): Promise<void> {
-    const hooksDir = path.join(targetDir, 'hooks');
+    // Hooks are in configDir/hooks
+    const hooksDir = path.join(projectPath, target.config.configDir, 'hooks');
     await fs.mkdir(hooksDir, { recursive: true });
 
     for (const hook of hooks) {
@@ -430,13 +439,16 @@ ${rules}
     result: AttachResult,
     manifest: BackupManifest
   ): Promise<void> {
-    // Get target from manifest to determine correct directory
-    const target = manifest.target;
-    const targetDir = this.projectManager.getTargetConfigDir(projectPath, target);
+    // Get target from manifest to determine config directory
+    const targetOption = targetManager.getTarget(manifest.target);
+    if (targetOption._tag === 'None') {
+      return; // Unknown target, skip
+    }
+    const target = targetOption.value;
 
     for (const file of singleFiles) {
-      // Write to target config directory, not project root
-      const filePath = path.join(targetDir, file.path);
+      // Write to target config directory (e.g., .claude/ or .opencode/)
+      const filePath = path.join(projectPath, target.config.configDir, file.path);
       const existed = existsSync(filePath);
 
       if (existed) {
@@ -474,13 +486,9 @@ ${rules}
     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.yellow(`   • ${conflict.type}: ${conflict.name} - ${conflict.action}`));
     }
 
-    console.log(
-      chalk.dim('\n   Don\'t worry! All overridden content will be restored on exit.\n')
-    );
+    console.log(chalk.dim("\n   Don't worry! All overridden content will be restored on exit.\n"));
   }
 }