@sylphx/flow 2.1.3 → 2.1.4

package/src/core/backup-manager.ts

@@ -4,17 +4,19 @@
  * Supports multi-project isolation in ~/.sylphx-flow/backups/
  */
 
+import { existsSync } from 'node:fs';
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import { existsSync } from 'node:fs';
 import ora from 'ora';
-import { ProjectManager } from './project-manager.js';
+import type { Target } from '../types/target.types.js';
+import type { ProjectManager } from './project-manager.js';
+import { targetManager } from './target-manager.js';
 
 export interface BackupInfo {
   sessionId: string;
   timestamp: string;
   projectPath: string;
-  target: 'claude-code' | 'opencode';
+  target: string;
   backupPath: string;
 }
 
@@ -22,7 +24,7 @@ export interface BackupManifest {
   sessionId: string;
   timestamp: string;
   projectPath: string;
-  target: 'claude-code' | 'opencode';
+  target: string;
   backup: {
     config?: {
       path: string;
@@ -64,14 +66,27 @@ export class BackupManager {
     this.projectManager = projectManager;
   }
 
+  /**
+   * 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;
+  }
+
   /**
    * Create full backup of project environment
    */
   async createBackup(
     projectPath: string,
     projectHash: string,
-    target: 'claude-code' | 'opencode'
+    targetOrId: Target | string
   ): Promise<BackupInfo> {
+    const target = typeof targetOrId === 'string' ? this.resolveTarget(targetOrId) : targetOrId;
+    const targetId = target.id;
     const sessionId = `session-${Date.now()}`;
     const timestamp = new Date().toISOString();
 
@@ -89,19 +104,17 @@ export class BackupManager {
 
       // Backup entire target directory if it exists
       if (existsSync(targetConfigDir)) {
-        const backupTargetDir = path.join(
-          backupPath,
-          target === 'claude-code' ? '.claude' : '.opencode'
-        );
+        // Use configDir from target config (e.g., '.claude', '.opencode')
+        const backupTargetDir = path.join(backupPath, target.config.configDir);
         await this.copyDirectory(targetConfigDir, backupTargetDir);
       }
 
-      // Create manifest
+      // Create manifest (store target ID as string for JSON serialization)
       const manifest: BackupManifest = {
         sessionId,
         timestamp,
         projectPath,
-        target,
+        target: targetId,
         backup: {
           agents: { user: [], flow: [] },
           commands: { user: [], flow: [] },
@@ -113,10 +126,7 @@ export class BackupManager {
         },
       };
 
-      await fs.writeFile(
-        path.join(backupPath, 'manifest.json'),
-        JSON.stringify(manifest, null, 2)
-      );
+      await fs.writeFile(path.join(backupPath, 'manifest.json'), JSON.stringify(manifest, null, 2));
 
       // Create symlink to latest
       const latestLink = paths.latestBackup;
@@ -131,7 +141,7 @@ export class BackupManager {
         sessionId,
         timestamp,
         projectPath,
-        target,
+        target: targetId,
         backupPath,
       };
     } catch (error) {
@@ -156,12 +166,13 @@ export class BackupManager {
     try {
       // Read manifest
       const manifestPath = path.join(backupPath, 'manifest.json');
-      const manifest: BackupManifest = JSON.parse(
-        await fs.readFile(manifestPath, 'utf-8')
-      );
+      const manifest: BackupManifest = JSON.parse(await fs.readFile(manifestPath, 'utf-8'));
 
       const projectPath = manifest.projectPath;
-      const target = manifest.target;
+      const targetId = manifest.target;
+
+      // Resolve target to get config
+      const target = this.resolveTarget(targetId);
 
       // Get target config directory
       const targetConfigDir = this.projectManager.getTargetConfigDir(projectPath, target);
@@ -171,11 +182,8 @@ export class BackupManager {
         await fs.rm(targetConfigDir, { recursive: true, force: true });
       }
 
-      // Restore from backup
-      const backupTargetDir = path.join(
-        backupPath,
-        target === 'claude-code' ? '.claude' : '.opencode'
-      );
+      // Restore from backup using target config's configDir
+      const backupTargetDir = path.join(backupPath, target.config.configDir);
 
       if (existsSync(backupTargetDir)) {
         await this.copyDirectory(backupTargetDir, targetConfigDir);
@@ -232,7 +240,7 @@ export class BackupManager {
       .filter((e) => e.isDirectory() && e.name.startsWith('session-'))
       .map((e) => ({
         name: e.name,
-        timestamp: parseInt(e.name.replace('session-', '')),
+        timestamp: parseInt(e.name.replace('session-', ''), 10),
       }))
       .sort((a, b) => b.timestamp - a.timestamp);
 
@@ -290,9 +298,7 @@ export class BackupManager {
 
       const manifestPath = path.join(paths.backupsDir, entry.name, 'manifest.json');
       if (existsSync(manifestPath)) {
-        const manifest: BackupManifest = JSON.parse(
-          await fs.readFile(manifestPath, 'utf-8')
-        );
+        const manifest: BackupManifest = JSON.parse(await fs.readFile(manifestPath, 'utf-8'));
         backups.push({
           sessionId: manifest.sessionId,
           timestamp: manifest.timestamp,

package/src/core/cleanup-handler.ts

@@ -5,12 +5,11 @@
  */
 
 import chalk from 'chalk';
-import { ProjectManager } from './project-manager.js';
-import { SessionManager } from './session-manager.js';
-import { BackupManager } from './backup-manager.js';
+import type { BackupManager } from './backup-manager.js';
+import type { ProjectManager } from './project-manager.js';
+import type { SessionManager } from './session-manager.js';
 
 export class CleanupHandler {
-  private projectManager: ProjectManager;
   private sessionManager: SessionManager;
   private backupManager: BackupManager;
   private registered = false;
@@ -82,14 +81,16 @@ export class CleanupHandler {
     }
 
     try {
-      const { shouldRestore, session } = await this.sessionManager.endSession(this.currentProjectHash);
+      const { shouldRestore, session } = await this.sessionManager.endSession(
+        this.currentProjectHash
+      );
 
       if (shouldRestore && session) {
         // Last session - restore backup silently on normal exit
         await this.backupManager.restoreBackup(this.currentProjectHash, session.sessionId);
         await this.backupManager.cleanupOldBackups(this.currentProjectHash, 3);
       }
-    } catch (error) {
+    } catch (_error) {
       // Silent fail on exit
     }
   }
@@ -97,7 +98,7 @@ export class CleanupHandler {
   /**
    * Signal-based cleanup (SIGINT, SIGTERM, etc.) with multi-session support
    */
-  private async onSignal(signal: string): Promise<void> {
+  private async onSignal(_signal: string): Promise<void> {
     if (!this.currentProjectHash) {
       return;
     }
@@ -105,7 +106,9 @@ export class CleanupHandler {
     try {
       console.log(chalk.cyan('🧹 Cleaning up...'));
 
-      const { shouldRestore, session } = await this.sessionManager.endSession(this.currentProjectHash);
+      const { shouldRestore, session } = await this.sessionManager.endSession(
+        this.currentProjectHash
+      );
 
       if (shouldRestore && session) {
         // Last session - restore environment

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);
 };
 
 /**