@sylphx/flow 2.0.0 → 2.1.1

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,
     };
   }
@@ -407,7 +420,9 @@ ${rules}
   }
 
   /**
-   * Attach single files (CLAUDE.md, .cursorrules, etc.)
+   * Attach single files (output styles like silent.md)
+   * NOTE: These files are placed in the target config directory (.claude/ or .opencode/),
+   * NOT in the project root directory.
    */
   private async attachSingleFiles(
     projectPath: string,
@@ -415,33 +430,22 @@ ${rules}
     result: AttachResult,
     manifest: BackupManifest
   ): Promise<void> {
+    // Get target from manifest to determine correct directory
+    const target = manifest.target;
+    const targetDir = this.projectManager.getTargetConfigDir(projectPath, target);
+
     for (const file of singleFiles) {
-      const filePath = path.join(projectPath, file.path);
+      // Write to target config directory, not project root
+      const filePath = path.join(targetDir, file.path);
       const existed = existsSync(filePath);
 
       if (existed) {
-        // User has file, append Flow content
-        const userContent = await fs.readFile(filePath, 'utf-8');
-
-        // Check if already appended
-        if (userContent.includes('<!-- Sylphx Flow Enhancement -->')) {
-          continue;
-        }
-
-        const merged = `${userContent}
-
----
-
-**Sylphx Flow Enhancement:**
-
-${file.content}
-`;
-
-        await fs.writeFile(filePath, merged);
+        // User has file, overwrite with Flow content (backed up already)
+        await fs.writeFile(filePath, file.content);
 
         manifest.backup.singleFiles[file.path] = {
           existed: true,
-          originalSize: userContent.length,
+          originalSize: (await fs.readFile(filePath, 'utf-8')).length,
           flowContentAdded: true,
         };
       } else {

package/src/core/flow-executor.ts

@@ -169,6 +169,7 @@ export class FlowExecutor {
 
   /**
    * Clear user settings in replace mode
+   * This ensures a clean slate for Flow's configuration
    */
   private async clearUserSettings(
     projectPath: string,
@@ -188,7 +189,7 @@ export class FlowExecutor {
       ? { agents: 'agents', commands: 'commands' }
       : { agents: 'agent', commands: 'command' };
 
-    // Clear agents directory
+    // 1. Clear agents directory (including AGENTS.md rules file)
     const agentsDir = path.join(targetDir, dirs.agents);
     if (existsSync(agentsDir)) {
       const files = await fs.readdir(agentsDir);
@@ -197,7 +198,7 @@ export class FlowExecutor {
       }
     }
 
-    // Clear commands directory
+    // 2. Clear commands directory
     const commandsDir = path.join(targetDir, dirs.commands);
     if (existsSync(commandsDir)) {
       const files = await fs.readdir(commandsDir);
@@ -206,31 +207,69 @@ export class FlowExecutor {
       }
     }
 
-    // Clear MCP configuration
+    // 3. Clear hooks directory
+    const hooksDir = path.join(targetDir, 'hooks');
+    if (existsSync(hooksDir)) {
+      const files = await fs.readdir(hooksDir);
+      for (const file of files) {
+        await fs.unlink(path.join(hooksDir, file));
+      }
+    }
+
+    // 4. Clear MCP configuration completely
     const configPath = target === 'claude-code'
       ? path.join(targetDir, 'settings.json')
       : path.join(targetDir, '.mcp.json');
 
     if (existsSync(configPath)) {
-      // Clear MCP servers section only, keep other settings
-      const config = JSON.parse(await fs.readFile(configPath, 'utf-8'));
       if (target === 'claude-code') {
-        if (config.mcp?.servers) {
-          config.mcp.servers = {};
+        // 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
+        // For OpenCode, clear the entire .mcp.json file
         await fs.writeFile(configPath, JSON.stringify({ servers: {} }, null, 2));
       }
     }
 
-    // Clear hooks directory if exists
-    const hooksDir = path.join(targetDir, 'hooks');
-    if (existsSync(hooksDir)) {
-      const files = await fs.readdir(hooksDir);
-      for (const file of files) {
-        await fs.unlink(path.join(hooksDir, file));
+    // 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');
+      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
+    const singleFiles = ['silent.md']; // Add other known single files here
+    for (const fileName of singleFiles) {
+      const filePath = path.join(targetDir, fileName);
+      if (existsSync(filePath)) {
+        await fs.unlink(filePath);
+      }
+    }
+
+    // 7. Clean up any Flow-created files in project root (legacy bug cleanup)
+    // This handles files that were incorrectly created in project root
+    const legacySingleFiles = ['silent.md'];
+    for (const fileName of legacySingleFiles) {
+      const filePath = path.join(projectPath, fileName);
+      if (existsSync(filePath)) {
+        // Only delete if it looks like a Flow-created file
+        try {
+          const content = await fs.readFile(filePath, 'utf-8');
+          if (content.includes('Sylphx Flow') || content.includes('Silent Execution Style')) {
+            await fs.unlink(filePath);
+          }
+        } catch {
+          // Ignore errors - file might not be readable
+        }
       }
     }
   }

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;