@sylphx/flow 2.0.0 → 2.1.0

package/src/core/attach-manager.ts

@@ -7,6 +7,7 @@
 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';
@@ -52,6 +53,18 @@ export class AttachManager {
     this.configService = new GlobalConfigService();
   }
 
+  /**
+   * Calculate SHA256 hash of file content
+   */
+  private async calculateFileHash(filePath: string): Promise<string> {
+    try {
+      const content = await fs.readFile(filePath, 'utf-8');
+      return createHash('sha256').update(content).digest('hex');
+    } catch {
+      return '';
+    }
+  }
+
   /**
    * Get target-specific directory names
    */
@@ -369,7 +382,7 @@ ${rules}
     // Track in manifest
     manifest.backup.config = {
       path: configPath,
-      hash: '', // TODO: calculate hash
+      hash: await this.calculateFileHash(configPath),
       mcpServersCount: Object.keys(config.mcp.servers).length,
     };
   }

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

@@ -257,60 +257,3 @@ export async function installFile(
   }
 }
 
-/**
- * File installer interface for backward compatibility
- */
-export interface FileInstaller {
-  installToDirectory(
-    sourceDir: string,
-    targetDir: string,
-    transform: FileTransformFn,
-    options?: InstallOptions
-  ): Promise<ProcessResult[]>;
-  appendToFile(
-    sourceDir: string,
-    targetFile: string,
-    transform: FileTransformFn,
-    options?: InstallOptions
-  ): Promise<void>;
-  installFile(
-    sourceFile: string,
-    targetFile: string,
-    transform: FileTransformFn,
-    options?: InstallOptions
-  ): Promise<void>;
-}
-
-/**
- * Composable file installer
- * Handles copying files from source to destination with optional transformation
- * @deprecated Use standalone functions (installToDirectory, appendToFile, installFile) for new code
- */
-export class FileInstaller {
-  async installToDirectory(
-    sourceDir: string,
-    targetDir: string,
-    transform: FileTransformFn,
-    options: InstallOptions = {}
-  ): Promise<ProcessResult[]> {
-    return installToDirectory(sourceDir, targetDir, transform, options);
-  }
-
-  async appendToFile(
-    sourceDir: string,
-    targetFile: string,
-    transform: FileTransformFn,
-    options: InstallOptions = {}
-  ): Promise<void> {
-    return appendToFile(sourceDir, targetFile, transform, options);
-  }
-
-  async installFile(
-    sourceFile: string,
-    targetFile: string,
-    transform: FileTransformFn,
-    options: InstallOptions = {}
-  ): Promise<void> {
-    return installFile(sourceFile, targetFile, transform, options);
-  }
-}

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

@@ -178,36 +178,3 @@ export function createMCPInstaller(target: Target): MCPInstaller {
   };
 }
 
-/**
- * @deprecated Use createMCPInstaller() for new code
- */
-export class MCPInstaller {
-  private installer: ReturnType<typeof createMCPInstaller>;
-
-  constructor(target: Target) {
-    this.installer = createMCPInstaller(target);
-  }
-
-  async selectServers(options: { quiet?: boolean } = {}): Promise<MCPServerID[]> {
-    return this.installer.selectServers(options);
-  }
-
-  async configureServers(
-    selectedServers: MCPServerID[],
-    options: { quiet?: boolean } = {}
-  ): Promise<Record<MCPServerID, Record<string, string>>> {
-    return this.installer.configureServers(selectedServers, options);
-  }
-
-  async installServers(
-    selectedServers: MCPServerID[],
-    serverConfigsMap: Record<MCPServerID, Record<string, string>>,
-    options: { quiet?: boolean } = {}
-  ): Promise<void> {
-    return this.installer.installServers(selectedServers, serverConfigsMap, options);
-  }
-
-  async setupMCP(options: { quiet?: boolean; dryRun?: boolean } = {}): Promise<MCPInstallResult> {
-    return this.installer.setupMCP(options);
-  }
-}

package/src/index.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env bun
 /**
- * Sylphx Flow - Legacy CLI
- * Project initialization and development flow management
+ * Sylphx Flow CLI
+ * AI-powered development flow management
  */
 
 import { readFileSync } from 'node:fs';

package/src/services/auto-upgrade.ts

@@ -0,0 +1,248 @@
+/**
+ * Auto-Upgrade Service
+ * Automatically checks and upgrades Flow and target CLI before each execution
+ */
+
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import chalk from 'chalk';
+import ora from 'ora';
+import { detectPackageManager, getUpgradeCommand } from '../utils/package-manager-detector.js';
+import { TargetInstaller } from './target-installer.js';
+
+const execAsync = promisify(exec);
+
+export interface UpgradeStatus {
+  flowNeedsUpgrade: boolean;
+  targetNeedsUpgrade: boolean;
+  flowVersion: { current: string; latest: string } | null;
+  targetVersion: { current: string; latest: string } | null;
+}
+
+export interface AutoUpgradeOptions {
+  verbose?: boolean;
+  skipFlow?: boolean;
+  skipTarget?: boolean;
+}
+
+export class AutoUpgrade {
+  private projectPath: string;
+  private options: AutoUpgradeOptions;
+  private targetInstaller: TargetInstaller;
+
+  constructor(projectPath: string = process.cwd(), options: AutoUpgradeOptions = {}) {
+    this.projectPath = projectPath;
+    this.options = options;
+    this.targetInstaller = new TargetInstaller(projectPath);
+  }
+
+  /**
+   * 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
+   */
+  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),
+    ]);
+
+    return {
+      flowNeedsUpgrade: !!flowVersion,
+      targetNeedsUpgrade: !!targetVersion,
+      flowVersion,
+      targetVersion,
+    };
+  }
+
+  /**
+   * Check Flow version
+   */
+  private async checkFlowVersion(): Promise<{ current: string; latest: string } | null> {
+    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;
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Check target CLI version
+   */
+  private async checkTargetVersion(
+    targetId: string
+  ): Promise<{ current: string; latest: string } | null> {
+    const installation = this.targetInstaller.getInstallationInfo(targetId);
+    if (!installation) {
+      return null;
+    }
+
+    try {
+      // Get current version
+      const { stdout: currentOutput } = await execAsync(installation.checkCommand);
+      const currentMatch = currentOutput.match(/v?(\d+\.\d+\.\d+)/);
+      if (!currentMatch) {
+        return null;
+      }
+      const currentVersion = currentMatch[1];
+
+      // Get latest version from npm
+      const { stdout: latestOutput } = await execAsync(`npm view ${installation.package} version`);
+      const latestVersion = latestOutput.trim();
+
+      if (currentVersion !== latestVersion) {
+        return { current: currentVersion, latest: latestVersion };
+      }
+
+      return null;
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Upgrade Flow to latest version using detected package manager
+   * @returns True if upgrade successful, false otherwise
+   */
+  async upgradeFlow(): Promise<boolean> {
+    const packageManager = detectPackageManager(this.projectPath);
+    const spinner = ora('Upgrading Flow...').start();
+
+    try {
+      const upgradeCmd = getUpgradeCommand('@sylphx/flow', packageManager);
+      await execAsync(upgradeCmd);
+
+      spinner.succeed(chalk.green('✓ Flow upgraded to latest version'));
+      return true;
+    } catch (error) {
+      spinner.fail(chalk.red('✗ Flow upgrade failed'));
+
+      if (this.options.verbose) {
+        console.error(error);
+      }
+
+      return false;
+    }
+  }
+
+  /**
+   * Upgrade target CLI to latest version
+   * Tries built-in upgrade command first, falls back to package manager
+   * @param targetId - Target CLI ID to upgrade
+   * @returns True if upgrade successful, false otherwise
+   */
+  async upgradeTarget(targetId: string): Promise<boolean> {
+    const installation = this.targetInstaller.getInstallationInfo(targetId);
+    if (!installation) {
+      return false;
+    }
+
+    const packageManager = detectPackageManager(this.projectPath);
+    const spinner = ora(`Upgrading ${installation.name}...`).start();
+
+    try {
+      // For Claude Code, use built-in update command if available
+      if (targetId === 'claude-code') {
+        try {
+          await execAsync('claude update');
+          spinner.succeed(chalk.green(`✓ ${installation.name} upgraded`));
+          return true;
+        } catch {
+          // Fall back to npm upgrade
+        }
+      }
+
+      // For OpenCode, use built-in upgrade command if available
+      if (targetId === 'opencode') {
+        try {
+          await execAsync('opencode upgrade');
+          spinner.succeed(chalk.green(`✓ ${installation.name} upgraded`));
+          return true;
+        } catch {
+          // Fall back to npm upgrade
+        }
+      }
+
+      // Fall back to npm/bun/pnpm/yarn upgrade
+      const upgradeCmd = getUpgradeCommand(installation.package, packageManager);
+      await execAsync(upgradeCmd);
+
+      spinner.succeed(chalk.green(`✓ ${installation.name} upgraded`));
+      return true;
+    } catch (error) {
+      spinner.fail(chalk.red(`✗ ${installation.name} upgrade failed`));
+
+      if (this.options.verbose) {
+        console.error(error);
+      }
+
+      return false;
+    }
+  }
+
+  /**
+   * Run auto-upgrade check and upgrade if needed
+   * Shows upgrade status and performs upgrades automatically
+   * @param targetId - Optional target CLI ID to check and upgrade
+   */
+  async runAutoUpgrade(targetId?: string): Promise<void> {
+    console.log(chalk.cyan('🔄 Checking for updates...\n'));
+
+    const status = await this.checkForUpgrades(targetId);
+
+    // Show upgrade status
+    if (status.flowNeedsUpgrade && status.flowVersion) {
+      console.log(
+        chalk.yellow(
+          `📦 Flow update available: ${status.flowVersion.current} → ${status.flowVersion.latest}`
+        )
+      );
+    } else if (!this.options.skipFlow) {
+      console.log(chalk.green('✓ Flow is up to date'));
+    }
+
+    if (status.targetNeedsUpgrade && status.targetVersion && targetId) {
+      const installation = this.targetInstaller.getInstallationInfo(targetId);
+      console.log(
+        chalk.yellow(
+          `📦 ${installation?.name} update available: ${status.targetVersion.current} → ${status.targetVersion.latest}`
+        )
+      );
+    } else if (!this.options.skipTarget && targetId) {
+      const installation = this.targetInstaller.getInstallationInfo(targetId);
+      console.log(chalk.green(`✓ ${installation?.name} is up to date`));
+    }
+
+    // Perform upgrades if needed
+    if (status.flowNeedsUpgrade || status.targetNeedsUpgrade) {
+      console.log(chalk.cyan('\n📦 Installing updates...\n'));
+
+      if (status.flowNeedsUpgrade) {
+        await this.upgradeFlow();
+      }
+
+      if (status.targetNeedsUpgrade && targetId) {
+        await this.upgradeTarget(targetId);
+      }
+
+      console.log(chalk.green('\n✓ All tools upgraded\n'));
+    } else {
+      console.log();
+    }
+  }
+}

package/src/services/global-config.ts

@@ -10,7 +10,7 @@ import { existsSync } from 'node:fs';
 
 export interface GlobalSettings {
   version: string;
-  defaultTarget?: 'claude-code' | 'opencode';
+  defaultTarget?: 'claude-code' | 'opencode' | 'cursor' | 'ask-every-time';
   defaultAgent?: string; // Default agent to use (e.g., 'coder', 'writer', 'reviewer', 'orchestrator')
   firstRun: boolean;
   lastUpdated: string;

package/src/services/target-installer.ts

@@ -0,0 +1,254 @@
+/**
+ * Target Installation Service
+ * Auto-detects and installs AI CLI tools (Claude Code, OpenCode, Cursor)
+ */
+
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+import chalk from 'chalk';
+import ora from 'ora';
+import inquirer from 'inquirer';
+import { detectPackageManager, type PackageManager } from '../utils/package-manager-detector.js';
+import { UserCancelledError } from '../utils/errors.js';
+
+const execAsync = promisify(exec);
+
+export interface TargetInstallation {
+  id: 'claude-code' | 'opencode' | 'cursor';
+  name: string;
+  package: string;
+  checkCommand: string;
+  installCommand: (pm: PackageManager) => string;
+}
+
+/**
+ * Supported target installations
+ */
+const TARGET_INSTALLATIONS: TargetInstallation[] = [
+  {
+    id: 'claude-code',
+    name: 'Claude Code',
+    package: '@anthropic-ai/claude-code',
+    checkCommand: 'claude --version',
+    installCommand: (pm: PackageManager) => {
+      switch (pm) {
+        case 'npm':
+          return 'npm install -g @anthropic-ai/claude-code';
+        case 'bun':
+          return 'bun install -g @anthropic-ai/claude-code';
+        case 'pnpm':
+          return 'pnpm install -g @anthropic-ai/claude-code';
+        case 'yarn':
+          return 'yarn global add @anthropic-ai/claude-code';
+      }
+    },
+  },
+  {
+    id: 'opencode',
+    name: 'OpenCode',
+    package: 'opencode-ai',
+    checkCommand: 'opencode --version',
+    installCommand: (pm: PackageManager) => {
+      switch (pm) {
+        case 'npm':
+          return 'npm install -g opencode-ai@latest';
+        case 'bun':
+          return 'bun install -g opencode-ai@latest';
+        case 'pnpm':
+          return 'pnpm install -g opencode-ai@latest';
+        case 'yarn':
+          return 'yarn global add opencode-ai@latest';
+      }
+    },
+  },
+  {
+    id: 'cursor',
+    name: 'Cursor',
+    package: 'cursor',
+    checkCommand: 'cursor --version',
+    installCommand: () => {
+      // Cursor is typically installed via installer, not npm
+      return 'Visit https://cursor.sh to download and install';
+    },
+  },
+];
+
+export class TargetInstaller {
+  private packageManager: PackageManager;
+
+  constructor(projectPath: string = process.cwd()) {
+    this.packageManager = detectPackageManager(projectPath);
+  }
+
+  /**
+   * Check if a target CLI is installed
+   * @param targetId - Target ID to check
+   * @returns True if installed, false otherwise
+   */
+  async isInstalled(targetId: string): Promise<boolean> {
+    const installation = TARGET_INSTALLATIONS.find((t) => t.id === targetId);
+    if (!installation) {
+      return false;
+    }
+
+    try {
+      await execAsync(installation.checkCommand);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Detect which target CLIs are currently installed
+   * @returns Array of installed target IDs
+   */
+  async detectInstalledTargets(): Promise<string[]> {
+    const installed: string[] = [];
+
+    for (const installation of TARGET_INSTALLATIONS) {
+      if (await this.isInstalled(installation.id)) {
+        installed.push(installation.id);
+      }
+    }
+
+    return installed;
+  }
+
+  /**
+   * Prompt user to select a target to install
+   * @returns Selected target ID
+   * @throws {UserCancelledError} If user cancels the prompt
+   */
+  async promptForTargetSelection(): Promise<string> {
+    try {
+      const { targetId } = await inquirer.prompt([
+        {
+          type: 'list',
+          name: 'targetId',
+          message: 'No AI CLI detected. Which would you like to use?',
+          choices: TARGET_INSTALLATIONS.map((t) => ({
+            name: t.name,
+            value: t.id,
+          })),
+          default: 'claude-code',
+        },
+      ]);
+
+      return targetId;
+    } catch (error: any) {
+      // Handle user cancellation (Ctrl+C)
+      if (error.name === 'ExitPromptError' || error.message?.includes('force closed')) {
+        throw new UserCancelledError('Target selection cancelled');
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Install a target CLI using detected package manager
+   * @param targetId - Target ID to install
+   * @param autoConfirm - Skip confirmation prompt if true
+   * @returns True if installation successful, false otherwise
+   * @throws {UserCancelledError} If user cancels installation
+   */
+  async install(targetId: string, autoConfirm: boolean = false): Promise<boolean> {
+    const installation = TARGET_INSTALLATIONS.find((t) => t.id === targetId);
+    if (!installation) {
+      console.log(chalk.red(`✗ Unknown target: ${targetId}`));
+      return false;
+    }
+
+    // Special handling for Cursor (not npm-installable)
+    if (targetId === 'cursor') {
+      console.log(chalk.yellow('\n⚠️  Cursor requires manual installation'));
+      console.log(chalk.cyan('   Visit https://cursor.sh to download and install\n'));
+      return false;
+    }
+
+    // Confirm installation unless auto-confirm is enabled
+    if (!autoConfirm) {
+      try {
+        const { confirmInstall } = await inquirer.prompt([
+          {
+            type: 'confirm',
+            name: 'confirmInstall',
+            message: `Install ${installation.name}?`,
+            default: true,
+          },
+        ]);
+
+        if (!confirmInstall) {
+          console.log(chalk.yellow('\n⚠️  Installation cancelled\n'));
+          return false;
+        }
+      } catch (error: any) {
+        // Handle user cancellation (Ctrl+C)
+        if (error.name === 'ExitPromptError' || error.message?.includes('force closed')) {
+          throw new UserCancelledError('Installation cancelled');
+        }
+        throw error;
+      }
+    }
+
+    const spinner = ora(`Installing ${installation.name}...`).start();
+
+    try {
+      const installCmd = installation.installCommand(this.packageManager);
+      await execAsync(installCmd);
+
+      spinner.succeed(chalk.green(`✓ ${installation.name} installed successfully`));
+      return true;
+    } catch (error) {
+      spinner.fail(chalk.red(`✗ Failed to install ${installation.name}`));
+
+      const installCmd = installation.installCommand(this.packageManager);
+      console.log(chalk.yellow('\n⚠️  Auto-install failed. Please run manually:'));
+      console.log(chalk.cyan(`   ${installCmd}\n`));
+
+      return false;
+    }
+  }
+
+  /**
+   * Auto-detect installed targets or prompt to install one
+   * @returns Target ID if found or installed, null if installation failed
+   * @throws {UserCancelledError} If user cancels selection or installation
+   */
+  async autoDetectAndInstall(): Promise<string | null> {
+    console.log(chalk.cyan('🔍 Detecting installed AI CLIs...\n'));
+
+    const installedTargets = await this.detectInstalledTargets();
+
+    // If we found installed targets, return the first one (priority order)
+    if (installedTargets.length > 0) {
+      const targetId = installedTargets[0];
+      const installation = TARGET_INSTALLATIONS.find((t) => t.id === targetId);
+      console.log(chalk.green(`✓ Found ${installation?.name}\n`));
+      return targetId;
+    }
+
+    // No targets found - prompt user to select one
+    console.log(chalk.yellow('⚠️  No AI CLI detected\n'));
+    const selectedTargetId = await this.promptForTargetSelection();
+
+    // Try to install the selected target
+    console.log();
+    const installed = await this.install(selectedTargetId, false);
+
+    if (!installed) {
+      return null;
+    }
+
+    return selectedTargetId;
+  }
+
+  /**
+   * Get installation metadata for a target
+   * @param targetId - Target ID to get info for
+   * @returns Installation info or undefined if target not found
+   */
+  getInstallationInfo(targetId: string): TargetInstallation | undefined {
+    return TARGET_INSTALLATIONS.find((t) => t.id === targetId);
+  }
+}

package/src/targets/claude-code.ts

@@ -3,8 +3,8 @@ import fs from 'node:fs';
 import fsPromises from 'node:fs/promises';
 import path from 'node:path';
 import chalk from 'chalk';
-import { FileInstaller } from '../core/installers/file-installer.js';
-import { MCPInstaller } from '../core/installers/mcp-installer.js';
+import { installToDirectory } from '../core/installers/file-installer.js';
+import { createMCPInstaller } from '../core/installers/mcp-installer.js';
 import type { AgentMetadata } from '../types/target-config.types.js';
 import type { CommonOptions, MCPServerConfigUnion, SetupResult, Target } from '../types.js';
 import { CLIError } from '../utils/error-handler.js';
@@ -432,10 +432,9 @@ Please begin your response with a comprehensive summary of all the instructions
    */
   async setupAgents(cwd: string, options: CommonOptions): Promise<SetupResult> {
     const { enhanceAgentContent } = await import('../utils/agent-enhancer.js');
-    const installer = new FileInstaller();
     const agentsDir = path.join(cwd, this.config.agentDir);
 
-    const results = await installer.installToDirectory(
+    const results = await installToDirectory(
       getAgentsDir(),
       agentsDir,
       async (content, sourcePath) => {
@@ -491,7 +490,7 @@ Please begin your response with a comprehensive summary of all the instructions
    * Select, configure, install, and approve MCP servers
    */
   async setupMCP(cwd: string, options: CommonOptions): Promise<SetupResult> {
-    const installer = new MCPInstaller(this);
+    const installer = createMCPInstaller(this);
     const result = await installer.setupMCP({ ...options, quiet: true });
 
     // Approve servers in Claude Code settings
@@ -513,10 +512,9 @@ Please begin your response with a comprehensive summary of all the instructions
       return { count: 0 };
     }
 
-    const installer = new FileInstaller();
     const slashCommandsDir = path.join(cwd, this.config.slashCommandsDir);
 
-    const results = await installer.installToDirectory(
+    const results = await installToDirectory(
       getSlashCommandsDir(),
       slashCommandsDir,
       async (content) => {