@sylphx/flow 2.15.0 → 2.15.2

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # @sylphx/flow
 
+## 2.15.2 (2025-12-17)
+
+### ⚡️ Performance
+
+- **auto-upgrade:** non-blocking version check with cache ([0550e44](https://github.com/SylphxAI/flow/commit/0550e44ea9b471ae07b2ea13c196354a7a32a605))
+
+## 2.15.1 (2025-12-17)
+
+### Improvements
+
+- **cli**: Make CLI output truly minimal and modern
+  - Remove all verbose status messages (backup, restore, session recovery)
+  - Remove emoji icons (🔧, ✔) for cleaner output
+  - Remove "Attached" and "Running" status lines
+  - Silent git worktree operations
+  - Silent crash recovery on startup
+  - Only show header: `flow {version} → {target}`
+
+### ♻️ Refactoring
+
+- **cli:** make output truly minimal and modern ([3315e41](https://github.com/SylphxAI/flow/commit/3315e41fa34839d7c866af1ebbe3b6f2d9e3ee71))
+
 ## 2.15.0 (2025-12-17)
 
 ### Features

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@sylphx/flow",
-	"version": "2.15.0",
+	"version": "2.15.2",
 	"description": "One CLI to rule them all. Unified orchestration layer for Claude Code, OpenCode, Cursor and all AI development tools. Auto-detection, auto-installation, auto-upgrade.",
 	"type": "module",
 	"bin": {

package/src/commands/flow/execute-v2.ts

@@ -242,12 +242,12 @@ export async function executeFlowV2(
   const autoUpgrade = new AutoUpgrade(projectPath);
   const upgradeResult = await autoUpgrade.runAutoUpgrade(selectedTargetId);
 
-  // Show upgrade status (only if something was upgraded)
+  // Show upgrade notice (minimal - only if upgraded)
   if (upgradeResult.flowUpgraded && upgradeResult.flowVersion) {
-    console.log(chalk.cyan(`  ↑ Flow ${upgradeResult.flowVersion.latest} (next run)`));
+    console.log(chalk.dim(`↑ flow ${upgradeResult.flowVersion.latest}`));
   }
   if (upgradeResult.targetUpgraded && upgradeResult.targetVersion) {
-    console.log(chalk.cyan(`  ↑ ${targetName} ${upgradeResult.targetVersion.latest}`));
+    console.log(chalk.dim(`↑ ${targetName.toLowerCase()} ${upgradeResult.targetVersion.latest}`));
   }
 
   // Create executor
@@ -263,15 +263,6 @@ export async function executeFlowV2(
       merge: options.merge || false,
     });
 
-    // Show attach summary (single line)
-    if (!attachResult.joined) {
-      console.log(
-        chalk.green(
-          `  ✓ Attached ${attachResult.agents} agents, ${attachResult.commands} commands, ${attachResult.mcp} MCP`
-        )
-      );
-    }
-
     const targetId = selectedTargetId;
 
     // Provider selection (Claude Code only, silent unless prompting)
@@ -289,9 +280,6 @@ export async function executeFlowV2(
       agent = enabledAgents.length > 0 ? enabledAgents[0] : 'coder';
     }
 
-    // Show running agent
-    console.log(chalk.dim(`\n  Running: ${agent}\n`));
-
     // Load agent content
     const enabledRules = await configService.getEnabledRules();
     const enabledOutputStyles = await configService.getEnabledOutputStyles();

package/src/core/backup-manager.ts

@@ -7,7 +7,6 @@
 import { existsSync } from 'node:fs';
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import ora from 'ora';
 import type { Target } from '../types/target.types.js';
 import type { ProjectManager } from './project-manager.js';
 import { targetManager } from './target-manager.js';
@@ -96,72 +95,63 @@ export class BackupManager {
     // Ensure backup directory exists
     await fs.mkdir(backupPath, { recursive: true });
 
-    const spinner = ora('Creating backup...').start();
+    // Get target config directory
+    const targetConfigDir = this.projectManager.getTargetConfigDir(projectPath, target);
 
-    try {
-      // Get target config directory
-      const targetConfigDir = this.projectManager.getTargetConfigDir(projectPath, target);
-
-      // Backup entire target directory if it exists
-      if (existsSync(targetConfigDir)) {
-        // Use configDir from target config (e.g., '.claude', '.opencode')
-        const backupTargetDir = path.join(backupPath, target.config.configDir);
-        await this.copyDirectory(targetConfigDir, backupTargetDir);
-      }
+    // Backup entire target directory if it exists
+    if (existsSync(targetConfigDir)) {
+      // Use configDir from target config (e.g., '.claude', '.opencode')
+      const backupTargetDir = path.join(backupPath, target.config.configDir);
+      await this.copyDirectory(targetConfigDir, backupTargetDir);
+    }
 
-      // Create manifest (store target ID as string for JSON serialization)
-      const manifest: BackupManifest = {
-        sessionId,
-        timestamp,
-        projectPath,
-        target: targetId,
-        backup: {
-          agents: { user: [], flow: [] },
-          commands: { user: [], flow: [] },
-          singleFiles: {},
-        },
-        secrets: {
-          mcpEnvExtracted: false,
-          storedAt: '',
-        },
-      };
-
-      await fs.writeFile(path.join(backupPath, 'manifest.json'), JSON.stringify(manifest, null, 2));
-
-      // Create symlink to latest (with fallback for Windows)
-      const latestLink = paths.latestBackup;
-      if (existsSync(latestLink)) {
-        await fs.unlink(latestLink);
-      }
-      try {
-        await fs.symlink(sessionId, latestLink);
-      } catch (symlinkError: unknown) {
-        // Windows without admin/Developer Mode can't create symlinks
-        // Fall back to writing session ID to a file
-        if (
-          symlinkError instanceof Error &&
-          'code' in symlinkError &&
-          symlinkError.code === 'EPERM'
-        ) {
-          await fs.writeFile(latestLink, sessionId, 'utf-8');
-        } else {
-          throw symlinkError;
-        }
-      }
+    // Create manifest (store target ID as string for JSON serialization)
+    const manifest: BackupManifest = {
+      sessionId,
+      timestamp,
+      projectPath,
+      target: targetId,
+      backup: {
+        agents: { user: [], flow: [] },
+        commands: { user: [], flow: [] },
+        singleFiles: {},
+      },
+      secrets: {
+        mcpEnvExtracted: false,
+        storedAt: '',
+      },
+    };
+
+    await fs.writeFile(path.join(backupPath, 'manifest.json'), JSON.stringify(manifest, null, 2));
 
-      spinner.succeed(`Backup created: ${sessionId}`);
-
-      return {
-        sessionId,
-        timestamp,
-        projectPath,
-        target: targetId,
-        backupPath,
-      };
-    } catch (error) {
-      spinner.fail('Backup failed');
-      throw error;
+    // Create symlink to latest (with fallback for Windows)
+    const latestLink = paths.latestBackup;
+    if (existsSync(latestLink)) {
+      await fs.unlink(latestLink);
     }
+    try {
+      await fs.symlink(sessionId, latestLink);
+    } catch (symlinkError: unknown) {
+      // Windows without admin/Developer Mode can't create symlinks
+      // Fall back to writing session ID to a file
+      if (
+        symlinkError instanceof Error &&
+        'code' in symlinkError &&
+        symlinkError.code === 'EPERM'
+      ) {
+        await fs.writeFile(latestLink, sessionId, 'utf-8');
+      } else {
+        throw symlinkError;
+      }
+    }
+
+    return {
+      sessionId,
+      timestamp,
+      projectPath,
+      target: targetId,
+      backupPath,
+    };
   }
 
   /**
@@ -175,38 +165,29 @@ export class BackupManager {
       throw new Error(`Backup not found: ${sessionId}`);
     }
 
-    const spinner = ora('Restoring backup...').start();
-
-    try {
-      // Read manifest
-      const manifestPath = path.join(backupPath, 'manifest.json');
-      const manifest: BackupManifest = JSON.parse(await fs.readFile(manifestPath, 'utf-8'));
-
-      const projectPath = manifest.projectPath;
-      const targetId = manifest.target;
+    // Read manifest
+    const manifestPath = path.join(backupPath, 'manifest.json');
+    const manifest: BackupManifest = JSON.parse(await fs.readFile(manifestPath, 'utf-8'));
 
-      // Resolve target to get config
-      const target = this.resolveTarget(targetId);
+    const projectPath = manifest.projectPath;
+    const targetId = manifest.target;
 
-      // Get target config directory
-      const targetConfigDir = this.projectManager.getTargetConfigDir(projectPath, target);
+    // Resolve target to get config
+    const target = this.resolveTarget(targetId);
 
-      // Remove current target directory
-      if (existsSync(targetConfigDir)) {
-        await fs.rm(targetConfigDir, { recursive: true, force: true });
-      }
+    // Get target config directory
+    const targetConfigDir = this.projectManager.getTargetConfigDir(projectPath, target);
 
-      // Restore from backup using target config's configDir
-      const backupTargetDir = path.join(backupPath, target.config.configDir);
+    // Remove current target directory
+    if (existsSync(targetConfigDir)) {
+      await fs.rm(targetConfigDir, { recursive: true, force: true });
+    }
 
-      if (existsSync(backupTargetDir)) {
-        await this.copyDirectory(backupTargetDir, targetConfigDir);
-      }
+    // Restore from backup using target config's configDir
+    const backupTargetDir = path.join(backupPath, target.config.configDir);
 
-      spinner.succeed('Backup restored');
-    } catch (error) {
-      spinner.fail('Restore failed');
-      throw error;
+    if (existsSync(backupTargetDir)) {
+      await this.copyDirectory(backupTargetDir, targetConfigDir);
     }
   }
 

package/src/core/cleanup-handler.ts

@@ -4,7 +4,6 @@
  * Handles process signals and ensures backup restoration
  */
 
-import chalk from 'chalk';
 import type { BackupManager } from './backup-manager.js';
 import type { ProjectManager } from './project-manager.js';
 import type { SessionManager } from './session-manager.js';
@@ -43,30 +42,26 @@ export class CleanupHandler {
 
     // SIGINT (Ctrl+C)
     process.on('SIGINT', async () => {
-      console.log(chalk.yellow('\n⚠️  Interrupted by user, cleaning up...'));
       await this.onSignal('SIGINT');
       process.exit(0);
     });
 
     // SIGTERM
     process.on('SIGTERM', async () => {
-      console.log(chalk.yellow('\n⚠️  Terminated, cleaning up...'));
       await this.onSignal('SIGTERM');
       process.exit(0);
     });
 
     // Uncaught exceptions
     process.on('uncaughtException', async (error) => {
-      console.error(chalk.red('\n✗ Uncaught Exception:'));
-      console.error(error);
+      console.error('\nUncaught Exception:', error);
       await this.onSignal('uncaughtException');
       process.exit(1);
     });
 
     // Unhandled rejections
     process.on('unhandledRejection', async (reason) => {
-      console.error(chalk.red('\n✗ Unhandled Rejection:'));
-      console.error(reason);
+      console.error('\nUnhandled Rejection:', reason);
       await this.onSignal('unhandledRejection');
       process.exit(1);
     });
@@ -97,6 +92,7 @@ export class CleanupHandler {
 
   /**
    * Signal-based cleanup (SIGINT, SIGTERM, etc.) with multi-session support
+   * Silent operation - no console output
    */
   private async onSignal(_signal: string): Promise<void> {
     if (!this.currentProjectHash) {
@@ -104,29 +100,22 @@ export class CleanupHandler {
     }
 
     try {
-      console.log(chalk.cyan('🧹 Cleaning up...'));
-
       const { shouldRestore, session } = await this.sessionManager.endSession(
         this.currentProjectHash
       );
 
       if (shouldRestore && session) {
-        // Last session - restore environment
-        console.log(chalk.cyan('   Restoring environment...'));
         await this.backupManager.restoreBackup(this.currentProjectHash, session.sessionId);
-        console.log(chalk.green('✓ Environment restored'));
-      } else if (!shouldRestore && session) {
-        // Other sessions still running
-        console.log(chalk.yellow(`   ${session.refCount} session(s) still running`));
       }
-    } catch (error) {
-      console.error(chalk.red('✗ Cleanup failed:'), error);
+    } catch (_error) {
+      // Silent fail
     }
   }
 
   /**
    * Recover on startup (for all projects)
    * Checks for orphaned sessions from crashes
+   * Silent operation - no console output
    */
   async recoverOnStartup(): Promise<void> {
     const orphanedSessions = await this.sessionManager.detectOrphanedSessions();
@@ -135,21 +124,12 @@ export class CleanupHandler {
       return;
     }
 
-    console.log(chalk.cyan(`\n🔧 Recovering ${orphanedSessions.size} crashed session(s)...\n`));
-
     for (const [projectHash, session] of orphanedSessions) {
-      console.log(chalk.dim(`   Project: ${session.projectPath}`));
-
       try {
-        // Restore backup
         await this.backupManager.restoreBackup(projectHash, session.sessionId);
-
-        // Clean up session
         await this.sessionManager.recoverSession(projectHash, session);
-
-        console.log(chalk.green('   ✓ Environment restored\n'));
-      } catch (error) {
-        console.error(chalk.red('   ✗ Recovery failed:'), error);
+      } catch (_error) {
+        // Silent fail - don't interrupt startup
       }
     }
   }

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

@@ -8,7 +8,6 @@ import { exec } from 'node:child_process';
 import { existsSync } from 'node:fs';
 import path from 'node:path';
 import { promisify } from 'node:util';
-import chalk from 'chalk';
 
 const execAsync = promisify(exec);
 
@@ -93,14 +92,8 @@ export class GitStashManager {
           // File might not exist or not tracked, skip it
         }
       }
-
-      if (this.skipWorktreeFiles.length > 0) {
-        console.log(
-          chalk.dim(`   ✓ Hiding ${this.skipWorktreeFiles.length} settings file(s) from git\n`)
-        );
-      }
     } catch (_error) {
-      console.log(chalk.yellow('   ⚠️  Could not hide settings from git\n'));
+      // Silent fail
     }
   }
 
@@ -123,15 +116,9 @@ export class GitStashManager {
         }
       }
 
-      console.log(
-        chalk.dim(`   ✓ Restored git tracking for ${this.skipWorktreeFiles.length} file(s)\n`)
-      );
       this.skipWorktreeFiles = [];
-    } 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')
-      );
+    } catch (_error) {
+      // Silent fail
     }
   }
 

package/src/services/auto-upgrade.ts

@@ -1,10 +1,13 @@
 /**
  * Auto-Upgrade Service
- * Automatically checks and upgrades Flow and target CLI before each execution
+ * Non-blocking version check with cache
+ * Checks in background, shows result on next run
  */
 
 import { exec } from 'node:child_process';
+import { existsSync } from 'node:fs';
 import fs from 'node:fs/promises';
+import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { promisify } from 'node:util';
@@ -16,6 +19,16 @@ import { TargetInstaller } from './target-installer.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
+// Cache file for version checks (24 hour TTL)
+const CACHE_FILE = path.join(os.homedir(), '.sylphx-flow', 'version-cache.json');
+const CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
+
+interface VersionCache {
+  flowLatest?: string;
+  targetLatest?: Record<string, string>;
+  checkedAt: number;
+}
+
 const execAsync = promisify(exec);
 
 export interface UpgradeStatus {
@@ -43,80 +56,151 @@ export class AutoUpgrade {
   }
 
   /**
-   * Check for available upgrades for Flow and target CLI
-   * @param targetId - Optional target CLI ID to check for upgrades
-   * @returns Upgrade status indicating what needs upgrading
+   * Read version cache (instant, no network)
    */
-  async checkForUpgrades(targetId?: string): Promise<UpgradeStatus> {
-    const [flowVersion, targetVersion] = await Promise.all([
-      this.options.skipFlow ? null : this.checkFlowVersion(),
-      this.options.skipTarget || !targetId ? null : this.checkTargetVersion(targetId),
-    ]);
+  private async readCache(): Promise<VersionCache | null> {
+    try {
+      if (!existsSync(CACHE_FILE)) {
+        return null;
+      }
+      const data = await fs.readFile(CACHE_FILE, 'utf-8');
+      return JSON.parse(data);
+    } catch {
+      return null;
+    }
+  }
 
-    return {
-      flowNeedsUpgrade: !!flowVersion,
-      targetNeedsUpgrade: !!targetVersion,
-      flowVersion,
-      targetVersion,
-    };
+  /**
+   * Write version cache
+   */
+  private async writeCache(cache: VersionCache): Promise<void> {
+    try {
+      const dir = path.dirname(CACHE_FILE);
+      await fs.mkdir(dir, { recursive: true });
+      await fs.writeFile(CACHE_FILE, JSON.stringify(cache, null, 2));
+    } catch {
+      // Silent fail
+    }
   }
 
   /**
-   * Check Flow version
+   * Get current Flow version from package.json (instant, local file)
    */
-  private async checkFlowVersion(): Promise<{ current: string; latest: string } | null> {
+  private async getCurrentFlowVersion(): Promise<string> {
     try {
-      // Get current version from package.json
       const packageJsonPath = path.join(__dirname, '..', '..', 'package.json');
       const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf-8'));
-      const currentVersion = packageJson.version;
-
-      // Get latest version from npm
-      const { stdout } = await execAsync('npm view @sylphx/flow version');
-      const latestVersion = stdout.trim();
-
-      if (currentVersion !== latestVersion) {
-        return { current: currentVersion, latest: latestVersion };
-      }
-
-      return null;
+      return packageJson.version;
     } catch {
-      return null;
+      return 'unknown';
     }
   }
 
   /**
-   * Check target CLI version
+   * Check for available upgrades using CACHE (instant, no network)
+   * Returns cached results from previous background check
    */
-  private async checkTargetVersion(
-    targetId: string
-  ): Promise<{ current: string; latest: string } | null> {
-    const installation = this.targetInstaller.getInstallationInfo(targetId);
-    if (!installation) {
-      return null;
+  async checkForUpgrades(targetId?: string): Promise<UpgradeStatus> {
+    const cache = await this.readCache();
+    const currentVersion = await this.getCurrentFlowVersion();
+
+    // Trigger background check for next run (non-blocking)
+    this.checkInBackground(targetId);
+
+    // No cache or expired = no upgrade info yet
+    if (!cache) {
+      return {
+        flowNeedsUpgrade: false,
+        targetNeedsUpgrade: false,
+        flowVersion: null,
+        targetVersion: null,
+      };
     }
 
-    try {
-      // Get current version
-      const { stdout: currentOutput } = await execAsync(installation.checkCommand);
-      const currentMatch = currentOutput.match(/v?(\d+\.\d+\.\d+)/);
-      if (!currentMatch) {
-        return null;
+    // Check if Flow needs upgrade based on cache
+    const flowVersion =
+      cache.flowLatest && cache.flowLatest !== currentVersion
+        ? { current: currentVersion, latest: cache.flowLatest }
+        : null;
+
+    // Check if target needs upgrade based on cache
+    let targetVersion: { current: string; latest: string } | null = null;
+    if (targetId && cache.targetLatest?.[targetId]) {
+      const installation = this.targetInstaller.getInstallationInfo(targetId);
+      if (installation) {
+        try {
+          const { stdout } = await execAsync(installation.checkCommand);
+          const match = stdout.match(/v?(\d+\.\d+\.\d+)/);
+          if (match && match[1] !== cache.targetLatest[targetId]) {
+            targetVersion = { current: match[1], latest: cache.targetLatest[targetId] };
+          }
+        } catch {
+          // Silent
+        }
       }
-      const currentVersion = currentMatch[1];
+    }
 
-      // Get latest version from npm
-      const { stdout: latestOutput } = await execAsync(`npm view ${installation.package} version`);
-      const latestVersion = latestOutput.trim();
+    return {
+      flowNeedsUpgrade: !!flowVersion,
+      targetNeedsUpgrade: !!targetVersion,
+      flowVersion,
+      targetVersion,
+    };
+  }
 
-      if (currentVersion !== latestVersion) {
-        return { current: currentVersion, latest: latestVersion };
-      }
+  /**
+   * Check versions in background (non-blocking)
+   * Updates cache for next run
+   */
+  private checkInBackground(targetId?: string): void {
+    // Fire and forget - don't await
+    this.performBackgroundCheck(targetId).catch(() => {
+      // Silent fail
+    });
+  }
 
-      return null;
+  /**
+   * Perform the actual version check (called in background)
+   */
+  private async performBackgroundCheck(targetId?: string): Promise<void> {
+    const cache = await this.readCache();
+
+    // Skip if checked recently (within TTL)
+    if (cache && Date.now() - cache.checkedAt < CACHE_TTL_MS) {
+      return;
+    }
+
+    const newCache: VersionCache = {
+      checkedAt: Date.now(),
+      targetLatest: cache?.targetLatest || {},
+    };
+
+    // Check Flow version from npm (with timeout)
+    try {
+      const { stdout } = await execAsync('npm view @sylphx/flow version', { timeout: 5000 });
+      newCache.flowLatest = stdout.trim();
     } catch {
-      return null;
+      // Keep old cache value if check fails
+      newCache.flowLatest = cache?.flowLatest;
+    }
+
+    // Check target version from npm (with timeout)
+    if (targetId) {
+      const installation = this.targetInstaller.getInstallationInfo(targetId);
+      if (installation) {
+        try {
+          const { stdout } = await execAsync(`npm view ${installation.package} version`, {
+            timeout: 5000,
+          });
+          newCache.targetLatest = newCache.targetLatest || {};
+          newCache.targetLatest[targetId] = stdout.trim();
+        } catch {
+          // Keep old cache value
+        }
+      }
     }
+
+    await this.writeCache(newCache);
   }
 
   /**

package/src/utils/agent-enhancer.ts

@@ -59,8 +59,7 @@ async function loadRules(ruleNames?: string[]): Promise<string> {
         const stripped = await yamlUtils.stripFrontMatter(content);
         sections.push(stripped);
       } catch (_error) {
-        // Log warning if rule file not found, but continue with other rules
-        console.warn(`Warning: Rule file not found: ${ruleName}.md`);
+        // Silent - rule file not found, continue with other rules
       }
     }
 
@@ -89,7 +88,7 @@ async function loadOutputStyles(styleNames?: string[]): Promise<string> {
           const stripped = await yamlUtils.stripFrontMatter(content);
           sections.push(stripped);
         } catch (_error) {
-          console.warn(`Warning: Output style file not found: ${styleName}.md`);
+          // Silent - output style file not found, continue
         }
       }
     } else {