@sylphx/flow 2.1.2 → 2.1.4

package/src/core/error-handling.ts

@@ -14,12 +14,7 @@ export class BaseError extends Error {
   public readonly statusCode: number;
   public readonly details?: Record<string, unknown>;
 
-  constructor(
-    message: string,
-    code: string,
-    statusCode = 500,
-    details?: Record<string, unknown>
-  ) {
+  constructor(message: string, code: string, statusCode = 500, details?: Record<string, unknown>) {
     super(message);
     this.name = this.constructor.name;
     this.code = code;
@@ -176,7 +171,7 @@ export interface ErrorHandler {
 export class LoggerErrorHandler implements ErrorHandler {
   constructor(private level: 'error' | 'warn' | 'info' | 'debug' = 'error') {}
 
-  canHandle(error: Error): boolean {
+  canHandle(_error: Error): boolean {
     return true; // Logger can handle all errors
   }
 
@@ -211,7 +206,7 @@ export class LoggerErrorHandler implements ErrorHandler {
  * Console error handler
  */
 export class ConsoleErrorHandler implements ErrorHandler {
-  canHandle(error: Error): boolean {
+  canHandle(_error: Error): boolean {
     return true; // Console can handle all errors
   }
 
@@ -269,9 +264,7 @@ export class ErrorHandlerChain {
 /**
  * Global error handler
  */
-export const globalErrorHandler = new ErrorHandlerChain([
-  new LoggerErrorHandler('error'),
-]);
+export const globalErrorHandler = new ErrorHandlerChain([new LoggerErrorHandler('error')]);
 
 /**
  * Set up global error handlers
@@ -371,7 +364,7 @@ export async function withRetry<T>(
     onRetry,
   } = options;
 
-  let lastError: Error;
+  let lastError: Error = new Error('Unknown error');
 
   for (let attempt = 1; attempt <= maxAttempts; attempt++) {
     try {
@@ -381,7 +374,8 @@ export async function withRetry<T>(
       lastError = error instanceof Error ? error : new Error(String(error));
 
       // Check if error is retryable
-      const isRetryable = retryableErrors.length === 0 ||
+      const isRetryable =
+        retryableErrors.length === 0 ||
         retryableErrors.includes((lastError as BaseError).code) ||
         retryableErrors.includes(lastError.constructor.name);
 
@@ -396,23 +390,21 @@ export async function withRetry<T>(
       }
 
       // Calculate delay
-      const retryDelay = backoff === 'exponential'
-        ? delay * Math.pow(2, attempt - 1)
-        : delay * attempt;
+      const retryDelay = backoff === 'exponential' ? delay * 2 ** (attempt - 1) : delay * attempt;
 
       // Wait before retry
-      await new Promise(resolve => setTimeout(resolve, retryDelay));
+      await new Promise((resolve) => setTimeout(resolve, retryDelay));
     }
   }
 
-  await globalErrorHandler.handle(lastError!);
-  return { success: false, error: lastError! };
+  await globalErrorHandler.handle(lastError);
+  return { success: false, error: lastError };
 }
 
 /**
  * Timeout wrapper
  */
-export async function withTimeout<T>(
+export function withTimeout<T>(
   fn: () => Promise<T>,
   timeoutMs: number,
   timeoutMessage = 'Operation timed out'
@@ -447,26 +439,27 @@ export class CircuitBreaker {
   private failures = 0;
   private lastFailureTime = 0;
   private state: 'closed' | 'open' | 'half-open' = 'closed';
+  private readonly config: {
+    failureThreshold: number;
+    recoveryTimeMs: number;
+    monitoringPeriodMs: number;
+  };
 
   constructor(
-    private options: {
+    options: {
       failureThreshold?: number;
       recoveryTimeMs?: number;
       monitoringPeriodMs?: number;
     } = {}
   ) {
-    const {
-      failureThreshold = 5,
-      recoveryTimeMs = 60000,
-      monitoringPeriodMs = 10000,
-    } = options;
+    const { failureThreshold = 5, recoveryTimeMs = 60000, monitoringPeriodMs = 10000 } = options;
 
-    this.options = { failureThreshold, recoveryTimeMs, monitoringPeriodMs };
+    this.config = { failureThreshold, recoveryTimeMs, monitoringPeriodMs };
   }
 
   async execute<T>(fn: () => Promise<T>): Promise<Result<T>> {
     if (this.state === 'open') {
-      if (Date.now() - this.lastFailureTime > this.options.recoveryTimeMs!) {
+      if (Date.now() - this.lastFailureTime > this.config.recoveryTimeMs) {
         this.state = 'half-open';
       } else {
         return {
@@ -498,7 +491,7 @@ export class CircuitBreaker {
     this.failures++;
     this.lastFailureTime = Date.now();
 
-    if (this.failures >= this.options.failureThreshold!) {
+    if (this.failures >= this.config.failureThreshold) {
       this.state = 'open';
     }
   }
@@ -516,4 +509,4 @@ export class CircuitBreaker {
     this.state = 'closed';
     this.lastFailureTime = 0;
   }
-}
+}

package/src/core/flow-executor.ts

@@ -5,14 +5,16 @@
  */
 
 import chalk from 'chalk';
-import { ProjectManager } from './project-manager.js';
-import { SessionManager } from './session-manager.js';
+import type { Target } from '../types/target.types.js';
+import { AttachManager, type AttachResult } from './attach-manager.js';
 import { BackupManager } from './backup-manager.js';
-import { AttachManager } from './attach-manager.js';
-import { SecretsManager } from './secrets-manager.js';
 import { CleanupHandler } from './cleanup-handler.js';
-import { TemplateLoader } from './template-loader.js';
 import { GitStashManager } from './git-stash-manager.js';
+import { ProjectManager } from './project-manager.js';
+import { SecretsManager } from './secrets-manager.js';
+import { SessionManager } from './session-manager.js';
+import { targetManager } from './target-manager.js';
+import { TemplateLoader } from './template-loader.js';
 
 export interface FlowExecutorOptions {
   verbose?: boolean;
@@ -49,10 +51,7 @@ export class FlowExecutor {
   /**
    * Execute complete flow with attach mode (with multi-session support)
    */
-  async execute(
-    projectPath: string,
-    options: FlowExecutorOptions = {}
-  ): Promise<void> {
+  async execute(projectPath: string, options: FlowExecutorOptions = {}): Promise<void> {
     // Initialize Flow directories
     await this.projectManager.initialize();
 
@@ -76,7 +75,7 @@ export class FlowExecutor {
       // Joining existing session
       console.log(chalk.cyan('🔗 Joining existing session...'));
 
-      const { session, isFirstSession } = await this.sessionManager.startSession(
+      const { session } = await this.sessionManager.startSession(
         projectPath,
         projectHash,
         target,
@@ -97,31 +96,21 @@ export class FlowExecutor {
     await this.gitStashManager.stashSettingsChanges(projectPath);
 
     console.log(chalk.cyan('💾 Creating backup...'));
-    const backup = await this.backupManager.createBackup(
-      projectPath,
-      projectHash,
-      target
-    );
+    const backup = await this.backupManager.createBackup(projectPath, projectHash, target);
 
     // Step 4: Extract and save secrets
     if (!options.skipSecrets) {
       console.log(chalk.cyan('🔐 Extracting secrets...'));
-      const secrets = await this.secretsManager.extractMCPSecrets(
-        projectPath,
-        projectHash,
-        target
-      );
+      const secrets = await this.secretsManager.extractMCPSecrets(projectPath, projectHash, target);
 
       if (Object.keys(secrets.servers).length > 0) {
         await this.secretsManager.saveSecrets(projectHash, secrets);
-        console.log(
-          chalk.green(`   ✓ Saved ${Object.keys(secrets.servers).length} MCP secret(s)`)
-        );
+        console.log(chalk.green(`   ✓ Saved ${Object.keys(secrets.servers).length} MCP secret(s)`));
       }
     }
 
     // Step 5: Start session (use backup's sessionId to ensure consistency)
-    const { session, isFirstSession } = await this.sessionManager.startSession(
+    const { session } = await this.sessionManager.startSession(
       projectPath,
       projectHash,
       target,
@@ -167,30 +156,31 @@ export class FlowExecutor {
     console.log(chalk.green('\n✓ Flow environment ready!\n'));
   }
 
+  /**
+   * Resolve target from ID string to Target object
+   */
+  private resolveTarget(targetId: string): Target {
+    const targetOption = targetManager.getTarget(targetId);
+    if (targetOption._tag === 'None') {
+      throw new Error(`Unknown target: ${targetId}`);
+    }
+    return targetOption.value;
+  }
+
   /**
    * Clear user settings in replace mode
    * This ensures a clean slate for Flow's configuration
    */
-  private async clearUserSettings(
-    projectPath: string,
-    target: 'claude-code' | 'opencode'
-  ): Promise<void> {
-    const targetDir = this.projectManager.getTargetConfigDir(projectPath, target);
+  private async clearUserSettings(projectPath: string, targetOrId: Target | string): Promise<void> {
+    const target = typeof targetOrId === 'string' ? this.resolveTarget(targetOrId) : targetOrId;
     const fs = await import('node:fs/promises');
     const path = await import('node:path');
     const { existsSync } = await import('node:fs');
 
-    if (!existsSync(targetDir)) {
-      return;
-    }
-
-    // Get directory names for this target
-    const dirs = target === 'claude-code'
-      ? { agents: 'agents', commands: 'commands' }
-      : { agents: 'agent', commands: 'command' };
+    // All paths use target.config.* directly (full paths relative to projectPath)
 
-    // 1. Clear agents directory (including AGENTS.md rules file)
-    const agentsDir = path.join(targetDir, dirs.agents);
+    // 1. Clear agents directory (including AGENTS.md rules file for Claude Code)
+    const agentsDir = path.join(projectPath, target.config.agentDir);
     if (existsSync(agentsDir)) {
       const files = await fs.readdir(agentsDir);
       for (const file of files) {
@@ -198,17 +188,19 @@ export class FlowExecutor {
       }
     }
 
-    // 2. Clear commands directory
-    const commandsDir = path.join(targetDir, dirs.commands);
-    if (existsSync(commandsDir)) {
-      const files = await fs.readdir(commandsDir);
-      for (const file of files) {
-        await fs.unlink(path.join(commandsDir, file));
+    // 2. Clear commands directory (if target supports slash commands)
+    if (target.config.slashCommandsDir) {
+      const commandsDir = path.join(projectPath, target.config.slashCommandsDir);
+      if (existsSync(commandsDir)) {
+        const files = await fs.readdir(commandsDir);
+        for (const file of files) {
+          await fs.unlink(path.join(commandsDir, file));
+        }
       }
     }
 
-    // 3. Clear hooks directory
-    const hooksDir = path.join(targetDir, 'hooks');
+    // 3. Clear hooks directory (in configDir)
+    const hooksDir = path.join(projectPath, target.config.configDir, 'hooks');
     if (existsSync(hooksDir)) {
       const files = await fs.readdir(hooksDir);
       for (const file of files) {
@@ -216,40 +208,33 @@ export class FlowExecutor {
       }
     }
 
-    // 4. Clear MCP configuration completely
-    const configPath = target === 'claude-code'
-      ? path.join(targetDir, 'settings.json')
-      : path.join(targetDir, '.mcp.json');
+    // 4. Clear MCP configuration using target config
+    const configPath = path.join(projectPath, target.config.configFile);
+    const mcpPath = target.config.mcpConfigPath;
 
     if (existsSync(configPath)) {
-      if (target === 'claude-code') {
-        // For Claude Code, clear entire MCP section to remove all user config
-        const config = JSON.parse(await fs.readFile(configPath, 'utf-8'));
-        if (config.mcp) {
-          // Remove entire MCP configuration, not just servers
-          delete config.mcp;
-          await fs.writeFile(configPath, JSON.stringify(config, null, 2));
-        }
-      } else {
-        // For OpenCode, clear the entire .mcp.json file
-        await fs.writeFile(configPath, JSON.stringify({ servers: {} }, null, 2));
+      const config = JSON.parse(await fs.readFile(configPath, 'utf-8'));
+      if (config[mcpPath]) {
+        // Remove entire MCP configuration section
+        delete config[mcpPath];
+        await fs.writeFile(configPath, JSON.stringify(config, null, 2));
       }
     }
 
-    // 5. Clear AGENTS.md rules file (for OpenCode)
-    // Claude Code AGENTS.md is already handled in agents directory
-    if (target === 'opencode') {
-      const rulesPath = path.join(targetDir, 'AGENTS.md');
+    // 5. Clear rules file if target has one defined (for targets like OpenCode)
+    // Claude Code puts AGENTS.md in agents directory, handled above
+    if (target.config.rulesFile) {
+      const rulesPath = path.join(projectPath, target.config.rulesFile);
       if (existsSync(rulesPath)) {
         await fs.unlink(rulesPath);
       }
     }
 
     // 6. Clear single files (output styles like silent.md)
-    // These are now in the target directory, not project root
+    // These are in the configDir
     const singleFiles = ['silent.md']; // Add other known single files here
     for (const fileName of singleFiles) {
-      const filePath = path.join(targetDir, fileName);
+      const filePath = path.join(projectPath, target.config.configDir, fileName);
       if (existsSync(filePath)) {
         await fs.unlink(filePath);
       }
@@ -294,13 +279,11 @@ export class FlowExecutor {
   /**
    * Show attach summary
    */
-  private showAttachSummary(result: any): void {
+  private showAttachSummary(result: AttachResult): void {
     const items = [];
 
     if (result.agentsAdded.length > 0) {
-      items.push(
-        `${result.agentsAdded.length} agent${result.agentsAdded.length > 1 ? 's' : ''}`
-      );
+      items.push(`${result.agentsAdded.length} agent${result.agentsAdded.length > 1 ? 's' : ''}`);
     }
 
     if (result.commandsAdded.length > 0) {
@@ -316,9 +299,7 @@ export class FlowExecutor {
     }
 
     if (result.hooksAdded.length > 0) {
-      items.push(
-        `${result.hooksAdded.length} hook${result.hooksAdded.length > 1 ? 's' : ''}`
-      );
+      items.push(`${result.hooksAdded.length} hook${result.hooksAdded.length > 1 ? 's' : ''}`);
     }
 
     if (result.rulesAppended) {
@@ -329,7 +310,8 @@ export class FlowExecutor {
       console.log(chalk.green(`   ✓ Added: ${items.join(', ')}`));
     }
 
-    const overridden = result.agentsOverridden.length +
+    const overridden =
+      result.agentsOverridden.length +
       result.commandsOverridden.length +
       result.mcpServersOverridden.length +
       result.hooksOverridden.length;

package/src/core/formatting/bytes.ts

@@ -28,16 +28,14 @@ export interface ByteFormatOptions {
 export function formatBytes(bytes: number, options: ByteFormatOptions = {}): string {
   const { decimals = 2, shortUnits = false } = options;
 
-  const units = shortUnits
-    ? ['B', 'KB', 'MB', 'GB', 'TB']
-    : ['Bytes', 'KB', 'MB', 'GB', 'TB'];
+  const units = shortUnits ? ['B', 'KB', 'MB', 'GB', 'TB'] : ['Bytes', 'KB', 'MB', 'GB', 'TB'];
 
   if (bytes === 0) {
     return `0 ${units[0]}`;
   }
 
   const i = Math.min(Math.floor(Math.log(bytes) / Math.log(1024)), units.length - 1);
-  const value = bytes / Math.pow(1024, i);
+  const value = bytes / 1024 ** i;
 
   // Format with specified decimal places
   const formatted = value.toFixed(decimals);

package/src/core/functional/async.ts

@@ -95,7 +95,7 @@ export const retry = async <T>(
 ): AsyncResult<T> => {
   const { maxAttempts, delayMs = 1000, backoff = 2, onRetry } = options;
 
-  let lastError: AppError | null = null;
+  let lastError: AppError = { type: 'unknown', message: 'No attempts made', code: 'NO_ATTEMPTS' };
   let currentDelay = delayMs;
 
   for (let attempt = 1; attempt <= maxAttempts; attempt++) {
@@ -117,7 +117,7 @@ export const retry = async <T>(
     }
   }
 
-  return failure(lastError!);
+  return failure(lastError);
 };
 
 /**
@@ -231,8 +231,9 @@ export const memoizeAsync = <Args extends any[], T>(
   return (...args: Args): AsyncResult<T, AppError> => {
     const key = keyFn ? keyFn(...args) : JSON.stringify(args);
 
-    if (cache.has(key)) {
-      return cache.get(key)!;
+    const cached = cache.get(key);
+    if (cached !== undefined) {
+      return cached;
     }
 
     const result = fn(...args);

package/src/core/functional/error-handler.ts

@@ -81,7 +81,7 @@ export const retry = async <T>(
 ): Promise<Result<T, AppError>> => {
   const { maxRetries, delayMs, backoff = 2, onRetry } = options;
 
-  let lastError: AppError | null = null;
+  let lastError: AppError = { type: 'unknown', message: 'Unknown error', code: 'UNKNOWN' };
   let currentDelay = delayMs;
 
   for (let attempt = 0; attempt <= maxRetries; attempt++) {
@@ -103,7 +103,7 @@ export const retry = async <T>(
     }
   }
 
-  return failure(lastError!);
+  return failure(lastError);
 };
 
 /**

package/src/core/git-stash-manager.ts

@@ -5,10 +5,9 @@
  */
 
 import { exec } from 'node:child_process';
-import { promisify } from 'node:util';
-import fs from 'node:fs/promises';
-import path from 'node:path';
 import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { promisify } from 'node:util';
 import chalk from 'chalk';
 
 const execAsync = promisify(exec);
@@ -39,7 +38,10 @@ export class GitStashManager {
     if (existsSync(claudeDir)) {
       try {
         const { stdout } = await execAsync('git ls-files .claude', { cwd: projectPath });
-        const claudeFiles = stdout.trim().split('\n').filter(f => f);
+        const claudeFiles = stdout
+          .trim()
+          .split('\n')
+          .filter((f) => f);
         files.push(...claudeFiles);
       } catch {
         // Directory not tracked in git
@@ -51,7 +53,10 @@ export class GitStashManager {
     if (existsSync(opencodeDir)) {
       try {
         const { stdout } = await execAsync('git ls-files .opencode', { cwd: projectPath });
-        const opencodeFiles = stdout.trim().split('\n').filter(f => f);
+        const opencodeFiles = stdout
+          .trim()
+          .split('\n')
+          .filter((f) => f);
         files.push(...opencodeFiles);
       } catch {
         // Directory not tracked in git
@@ -90,9 +95,11 @@ export class GitStashManager {
       }
 
       if (this.skipWorktreeFiles.length > 0) {
-        console.log(chalk.dim(`   ✓ Hiding ${this.skipWorktreeFiles.length} settings file(s) from git\n`));
+        console.log(
+          chalk.dim(`   ✓ Hiding ${this.skipWorktreeFiles.length} settings file(s) from git\n`)
+        );
       }
-    } catch (error) {
+    } catch (_error) {
       console.log(chalk.yellow('   ⚠️  Could not hide settings from git\n'));
     }
   }
@@ -116,11 +123,15 @@ export class GitStashManager {
         }
       }
 
-      console.log(chalk.dim(`   ✓ Restored git tracking for ${this.skipWorktreeFiles.length} file(s)\n`));
+      console.log(
+        chalk.dim(`   ✓ Restored git tracking for ${this.skipWorktreeFiles.length} file(s)\n`)
+      );
       this.skipWorktreeFiles = [];
-    } catch (error: any) {
+    } catch {
       console.log(chalk.yellow('   ⚠️  Could not restore git tracking'));
-      console.log(chalk.yellow('   Run manually: git update-index --no-skip-worktree .claude/* .opencode/*\n'));
+      console.log(
+        chalk.yellow('   Run manually: git update-index --no-skip-worktree .claude/* .opencode/*\n')
+      );
     }
   }
 

package/src/core/installers/file-installer.ts

@@ -256,4 +256,3 @@ export async function installFile(
     console.log(`${action} file: ${targetFile.replace(`${process.cwd()}/`, '')}`);
   }
 }
-

package/src/core/installers/mcp-installer.ts

@@ -177,4 +177,3 @@ export function createMCPInstaller(target: Target): MCPInstaller {
     setupMCP,
   };
 }
-

package/src/core/project-manager.ts

@@ -5,10 +5,12 @@
  */
 
 import crypto from 'node:crypto';
-import path from 'node:path';
-import os from 'node:os';
 import { existsSync } from 'node:fs';
 import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import type { Target } from '../types/target.types.js';
+import { targetManager } from './target-manager.js';
 
 export interface ProjectPaths {
   sessionFile: string;
@@ -31,11 +33,7 @@ export class ProjectManager {
    */
   getProjectHash(projectPath: string): string {
     const absolutePath = path.resolve(projectPath);
-    return crypto
-      .createHash('sha256')
-      .update(absolutePath)
-      .digest('hex')
-      .substring(0, 16);
+    return crypto.createHash('sha256').update(absolutePath).digest('hex').substring(0, 16);
   }
 
   /**
@@ -128,12 +126,9 @@ export class ProjectManager {
   /**
    * Save project-specific target preference to global config
    */
-  async saveProjectTargetPreference(
-    projectHash: string,
-    target: 'claude-code' | 'opencode'
-  ): Promise<void> {
+  async saveProjectTargetPreference(projectHash: string, target: string): Promise<void> {
     const prefsPath = path.join(this.flowHomeDir, 'project-preferences.json');
-    let prefs: any = { projects: {} };
+    let prefs: { projects: Record<string, { target?: string }> } = { projects: {} };
 
     if (existsSync(prefsPath)) {
       try {
@@ -156,11 +151,11 @@ export class ProjectManager {
   }
 
   /**
-   * Detect target platform (claude-code or opencode)
+   * Detect target platform
    * New strategy: Detect based on installed commands, not folders
    * Priority: saved preference > installed commands > global default
    */
-  async detectTarget(projectPath: string): Promise<'claude-code' | 'opencode'> {
+  async detectTarget(projectPath: string): Promise<string> {
     const projectHash = this.getProjectHash(projectPath);
 
     // 1. Check if we already have a saved preference for this project
@@ -217,11 +212,22 @@ export class ProjectManager {
 
   /**
    * Get target config directory for project
+   * @param projectPath - The project root path
+   * @param target - Either a Target object or target ID string
    */
-  getTargetConfigDir(projectPath: string, target: 'claude-code' | 'opencode'): string {
-    return target === 'claude-code'
-      ? path.join(projectPath, '.claude')
-      : path.join(projectPath, '.opencode');
+  getTargetConfigDir(projectPath: string, target: Target | string): string {
+    // If target is a string, look up the Target object
+    const targetObj =
+      typeof target === 'string'
+        ? targetManager.getTarget(target)
+        : { _tag: 'Some' as const, value: target };
+
+    if (targetObj._tag === 'None') {
+      // Fallback for unknown targets - use the ID as directory name
+      return path.join(projectPath, `.${target}`);
+    }
+
+    return path.join(projectPath, targetObj.value.config.configDir);
   }
 
   /**