@sylphx/flow 1.8.2 → 2.1.0

package/src/utils/__tests__/package-manager-detector.test.ts

@@ -0,0 +1,163 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import {
+  detectPackageManagerFromUserAgent,
+  detectPackageManagerFromLockFiles,
+  detectPackageManager,
+  getPackageManagerInfo,
+  getUpgradeCommand,
+} from '../package-manager-detector';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+describe('Package Manager Detection', () => {
+  const originalEnv = process.env;
+
+  beforeEach(() => {
+    process.env = { ...originalEnv };
+  });
+
+  afterEach(() => {
+    process.env = originalEnv;
+  });
+
+  describe('detectPackageManagerFromUserAgent', () => {
+    it('should detect bun from user agent', () => {
+      process.env.npm_config_user_agent = 'bun/1.0.0';
+      expect(detectPackageManagerFromUserAgent()).toBe('bun');
+    });
+
+    it('should detect pnpm from user agent', () => {
+      process.env.npm_config_user_agent = 'pnpm/8.0.0 npm/? node/v18.0.0';
+      expect(detectPackageManagerFromUserAgent()).toBe('pnpm');
+    });
+
+    it('should detect yarn from user agent', () => {
+      process.env.npm_config_user_agent = 'yarn/1.22.0 npm/? node/v18.0.0';
+      expect(detectPackageManagerFromUserAgent()).toBe('yarn');
+    });
+
+    it('should detect npm from user agent', () => {
+      process.env.npm_config_user_agent = 'npm/9.0.0 node/v18.0.0';
+      expect(detectPackageManagerFromUserAgent()).toBe('npm');
+    });
+
+    it('should return null when no user agent', () => {
+      delete process.env.npm_config_user_agent;
+      expect(detectPackageManagerFromUserAgent()).toBe(null);
+    });
+  });
+
+  describe('detectPackageManagerFromLockFiles', () => {
+    let tempDir: string;
+
+    beforeEach(() => {
+      tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pm-test-'));
+    });
+
+    afterEach(() => {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    });
+
+    it('should detect bun from bun.lockb', () => {
+      fs.writeFileSync(path.join(tempDir, 'bun.lockb'), '');
+      expect(detectPackageManagerFromLockFiles(tempDir)).toBe('bun');
+    });
+
+    it('should detect bun from bun.lock', () => {
+      fs.writeFileSync(path.join(tempDir, 'bun.lock'), '');
+      expect(detectPackageManagerFromLockFiles(tempDir)).toBe('bun');
+    });
+
+    it('should detect pnpm from pnpm-lock.yaml', () => {
+      fs.writeFileSync(path.join(tempDir, 'pnpm-lock.yaml'), '');
+      expect(detectPackageManagerFromLockFiles(tempDir)).toBe('pnpm');
+    });
+
+    it('should detect yarn from yarn.lock', () => {
+      fs.writeFileSync(path.join(tempDir, 'yarn.lock'), '');
+      expect(detectPackageManagerFromLockFiles(tempDir)).toBe('yarn');
+    });
+
+    it('should detect npm from package-lock.json', () => {
+      fs.writeFileSync(path.join(tempDir, 'package-lock.json'), '');
+      expect(detectPackageManagerFromLockFiles(tempDir)).toBe('npm');
+    });
+
+    it('should prioritize bun over others', () => {
+      fs.writeFileSync(path.join(tempDir, 'bun.lock'), '');
+      fs.writeFileSync(path.join(tempDir, 'package-lock.json'), '');
+      expect(detectPackageManagerFromLockFiles(tempDir)).toBe('bun');
+    });
+
+    it('should return null when no lock files', () => {
+      expect(detectPackageManagerFromLockFiles(tempDir)).toBe(null);
+    });
+  });
+
+  describe('detectPackageManager', () => {
+    it('should prioritize user agent over lock files', () => {
+      process.env.npm_config_user_agent = 'pnpm/8.0.0';
+      const result = detectPackageManager();
+      expect(result).toBe('pnpm');
+    });
+
+    it('should default to npm when no detection methods work', () => {
+      delete process.env.npm_config_user_agent;
+      const result = detectPackageManager('/nonexistent');
+      expect(result).toBe('npm');
+    });
+  });
+
+  describe('getPackageManagerInfo', () => {
+    it('should return correct info for npm', () => {
+      const info = getPackageManagerInfo('npm');
+      expect(info.name).toBe('npm');
+      expect(info.installCommand).toBe('npm install');
+      expect(info.globalInstallCommand('foo')).toBe('npm install -g foo');
+    });
+
+    it('should return correct info for bun', () => {
+      const info = getPackageManagerInfo('bun');
+      expect(info.name).toBe('bun');
+      expect(info.installCommand).toBe('bun install');
+      expect(info.globalInstallCommand('foo')).toBe('bun install -g foo');
+    });
+
+    it('should return correct info for pnpm', () => {
+      const info = getPackageManagerInfo('pnpm');
+      expect(info.name).toBe('pnpm');
+      expect(info.installCommand).toBe('pnpm install');
+      expect(info.globalInstallCommand('foo')).toBe('pnpm install -g foo');
+    });
+
+    it('should return correct info for yarn', () => {
+      const info = getPackageManagerInfo('yarn');
+      expect(info.name).toBe('yarn');
+      expect(info.installCommand).toBe('yarn install');
+      expect(info.globalInstallCommand('foo')).toBe('yarn global add foo');
+    });
+  });
+
+  describe('getUpgradeCommand', () => {
+    it('should return correct upgrade command for npm', () => {
+      const cmd = getUpgradeCommand('my-package', 'npm');
+      expect(cmd).toBe('npm install -g my-package@latest');
+    });
+
+    it('should return correct upgrade command for bun', () => {
+      const cmd = getUpgradeCommand('my-package', 'bun');
+      expect(cmd).toBe('bun install -g my-package@latest');
+    });
+
+    it('should return correct upgrade command for pnpm', () => {
+      const cmd = getUpgradeCommand('my-package', 'pnpm');
+      expect(cmd).toBe('pnpm install -g my-package@latest');
+    });
+
+    it('should return correct upgrade command for yarn', () => {
+      const cmd = getUpgradeCommand('my-package', 'yarn');
+      expect(cmd).toBe('yarn global add my-package@latest');
+    });
+  });
+});

package/src/utils/agent-enhancer.ts

@@ -18,17 +18,20 @@ import { yamlUtils } from './config/target-utils.js';
 /**
  * Load and combine rules and output styles
  */
-export async function loadRulesAndStyles(ruleNames?: string[]): Promise<string> {
+export async function loadRulesAndStyles(
+  ruleNames?: string[],
+  outputStyleNames?: string[]
+): Promise<string> {
   const sections: string[] = [];
 
-  // Load rules (either specified rules or default to 'core')
+  // Load rules (either specified rules or default to all)
   const rulesContent = await loadRules(ruleNames);
   if (rulesContent) {
     sections.push(rulesContent);
   }
 
-  // Load output styles
-  const stylesContent = await loadOutputStyles();
+  // Load output styles (either specified or all)
+  const stylesContent = await loadOutputStyles(outputStyleNames);
   if (stylesContent) {
     sections.push(stylesContent);
   }
@@ -69,26 +72,36 @@ async function loadRules(ruleNames?: string[]): Promise<string> {
 
 /**
  * Load output styles from assets/output-styles/
+ * @param styleNames - Array of style file names (without .md extension). If not provided, loads all styles.
  */
-async function loadOutputStyles(): Promise<string> {
+async function loadOutputStyles(styleNames?: string[]): Promise<string> {
   try {
     const outputStylesDir = getOutputStylesDir();
-    const files = await fs.readdir(outputStylesDir);
-    const mdFiles = files.filter((f) => f.endsWith('.md'));
-
-    if (mdFiles.length === 0) {
-      return '';
-    }
-
     const sections: string[] = [];
 
-    for (const file of mdFiles) {
-      const filePath = path.join(outputStylesDir, file);
-      const content = await fs.readFile(filePath, 'utf8');
-
-      // Strip YAML front matter
-      const stripped = await yamlUtils.stripFrontMatter(content);
-      sections.push(stripped);
+    // If specific styles are requested, load only those
+    if (styleNames && styleNames.length > 0) {
+      for (const styleName of styleNames) {
+        const filePath = path.join(outputStylesDir, `${styleName}.md`);
+        try {
+          const content = await fs.readFile(filePath, 'utf8');
+          const stripped = await yamlUtils.stripFrontMatter(content);
+          sections.push(stripped);
+        } catch (error) {
+          console.warn(`Warning: Output style file not found: ${styleName}.md`);
+        }
+      }
+    } else {
+      // Load all styles
+      const files = await fs.readdir(outputStylesDir);
+      const mdFiles = files.filter((f) => f.endsWith('.md'));
+
+      for (const file of mdFiles) {
+        const filePath = path.join(outputStylesDir, file);
+        const content = await fs.readFile(filePath, 'utf8');
+        const stripped = await yamlUtils.stripFrontMatter(content);
+        sections.push(stripped);
+      }
     }
 
     return sections.join('\n\n');
@@ -101,10 +114,15 @@ async function loadOutputStyles(): Promise<string> {
 /**
  * Enhance agent content by appending rules and output styles
  * @param agentContent - The agent markdown content
- * @param ruleNames - Optional array of rule file names to include (defaults to ['core'])
+ * @param ruleNames - Optional array of rule file names to include
+ * @param outputStyleNames - Optional array of output style file names to include
  */
-export async function enhanceAgentContent(agentContent: string, ruleNames?: string[]): Promise<string> {
-  const rulesAndStyles = await loadRulesAndStyles(ruleNames);
+export async function enhanceAgentContent(
+  agentContent: string,
+  ruleNames?: string[],
+  outputStyleNames?: string[]
+): Promise<string> {
+  const rulesAndStyles = await loadRulesAndStyles(ruleNames, outputStyleNames);
 
   if (!rulesAndStyles) {
     return agentContent;

package/src/utils/errors.ts

@@ -0,0 +1,9 @@
+/**
+ * Custom error for user cancellation (Ctrl+C)
+ */
+export class UserCancelledError extends Error {
+  constructor(message = 'Operation cancelled by user') {
+    super(message);
+    this.name = 'UserCancelledError';
+  }
+}

package/src/utils/package-manager-detector.ts

@@ -0,0 +1,139 @@
+/**
+ * Package Manager Detection
+ * Detects which package manager is being used (npm, bun, pnpm, yarn)
+ * Based on lock files and environment variables
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+export type PackageManager = 'npm' | 'bun' | 'pnpm' | 'yarn';
+
+export interface PackageManagerInfo {
+  name: PackageManager;
+  installCommand: string;
+  globalInstallCommand: (packageName: string) => string;
+  version?: string;
+}
+
+/**
+ * Detect package manager from environment variable (npm_config_user_agent)
+ * This is set when running through npm/bun/pnpm/yarn scripts
+ */
+export function detectPackageManagerFromUserAgent(): PackageManager | null {
+  const userAgent = process.env.npm_config_user_agent;
+
+  if (!userAgent) {
+    return null;
+  }
+
+  if (userAgent.includes('bun')) return 'bun';
+  if (userAgent.includes('pnpm')) return 'pnpm';
+  if (userAgent.includes('yarn')) return 'yarn';
+  if (userAgent.includes('npm')) return 'npm';
+
+  return null;
+}
+
+/**
+ * Detect package manager from lock files in directory
+ */
+export function detectPackageManagerFromLockFiles(dir: string = process.cwd()): PackageManager | null {
+  const lockFiles: Record<PackageManager, string[]> = {
+    bun: ['bun.lockb', 'bun.lock'],
+    pnpm: ['pnpm-lock.yaml'],
+    yarn: ['yarn.lock'],
+    npm: ['package-lock.json'],
+  };
+
+  // Check in priority order: bun > pnpm > yarn > npm
+  const priority: PackageManager[] = ['bun', 'pnpm', 'yarn', 'npm'];
+
+  for (const pm of priority) {
+    const files = lockFiles[pm];
+    for (const file of files) {
+      if (fs.existsSync(path.join(dir, file))) {
+        return pm;
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Detect which package manager to use
+ * Priority: user agent > lock files > npm (default)
+ */
+export function detectPackageManager(dir: string = process.cwd()): PackageManager {
+  // 1. Try user agent (most reliable when running as script)
+  const fromUserAgent = detectPackageManagerFromUserAgent();
+  if (fromUserAgent) {
+    return fromUserAgent;
+  }
+
+  // 2. Try lock files
+  const fromLockFiles = detectPackageManagerFromLockFiles(dir);
+  if (fromLockFiles) {
+    return fromLockFiles;
+  }
+
+  // 3. Default to npm
+  return 'npm';
+}
+
+/**
+ * Get package manager info with commands
+ */
+export function getPackageManagerInfo(pm?: PackageManager): PackageManagerInfo {
+  const detected = pm || detectPackageManager();
+
+  const info: Record<PackageManager, PackageManagerInfo> = {
+    npm: {
+      name: 'npm',
+      installCommand: 'npm install',
+      globalInstallCommand: (pkg) => `npm install -g ${pkg}`,
+    },
+    bun: {
+      name: 'bun',
+      installCommand: 'bun install',
+      globalInstallCommand: (pkg) => `bun install -g ${pkg}`,
+    },
+    pnpm: {
+      name: 'pnpm',
+      installCommand: 'pnpm install',
+      globalInstallCommand: (pkg) => `pnpm install -g ${pkg}`,
+    },
+    yarn: {
+      name: 'yarn',
+      installCommand: 'yarn install',
+      globalInstallCommand: (pkg) => `yarn global add ${pkg}`,
+    },
+  };
+
+  return info[detected];
+}
+
+/**
+ * Get upgrade command for a package
+ */
+export function getUpgradeCommand(packageName: string, pm?: PackageManager): string {
+  const pmInfo = getPackageManagerInfo(pm);
+  return pmInfo.globalInstallCommand(`${packageName}@latest`);
+}
+
+/**
+ * Check if package manager is available in system
+ */
+export async function isPackageManagerAvailable(pm: PackageManager): Promise<boolean> {
+  const { exec } = await import('node:child_process');
+  const { promisify } = await import('node:util');
+  const execAsync = promisify(exec);
+
+  try {
+    await execAsync(`${pm} --version`);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/utils/prompt-helpers.ts

@@ -0,0 +1,48 @@
+/**
+ * Prompt Helpers
+ * Utilities for handling user prompts and error handling
+ */
+
+import { UserCancelledError } from './errors.js';
+
+/**
+ * Check if error is a user cancellation (Ctrl+C or force closed)
+ * @param error - Error to check
+ * @returns True if error represents user cancellation
+ */
+export function isUserCancellation(error: any): boolean {
+  return error?.name === 'ExitPromptError' || error?.message?.includes('force closed');
+}
+
+/**
+ * Handle inquirer prompt errors with consistent error handling
+ * Throws UserCancelledError for user cancellations, re-throws other errors
+ * @param error - Error from inquirer prompt
+ * @param message - Custom cancellation message
+ * @throws {UserCancelledError} If user cancelled the prompt
+ * @throws Original error if not a cancellation
+ */
+export function handlePromptError(error: any, message: string): never {
+  if (isUserCancellation(error)) {
+    throw new UserCancelledError(message);
+  }
+  throw error;
+}
+
+/**
+ * Wrap an inquirer prompt with consistent error handling
+ * @param promptFn - Function that returns a promise from inquirer
+ * @param errorMessage - Message to use if user cancels
+ * @returns Promise with the prompt result
+ * @throws {UserCancelledError} If user cancels the prompt
+ */
+export async function withPromptErrorHandling<T>(
+  promptFn: () => Promise<T>,
+  errorMessage: string
+): Promise<T> {
+  try {
+    return await promptFn();
+  } catch (error) {
+    handlePromptError(error, errorMessage);
+  }
+}

package/src/utils/target-selection.ts

@@ -0,0 +1,169 @@
+/**
+ * Target Selection Utilities
+ * Shared logic for target selection UI across settings and execution flows
+ */
+
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { TargetInstaller } from '../services/target-installer.js';
+import { handlePromptError } from './prompt-helpers.js';
+
+/**
+ * Represents a target CLI choice with installation status
+ */
+export interface TargetChoice {
+  /** Display name of the target */
+  name: string;
+  /** Target identifier */
+  value: 'claude-code' | 'opencode' | 'cursor';
+  /** Whether the target is currently installed */
+  installed: boolean;
+}
+
+/**
+ * Build list of available targets with installation status
+ * @param installedTargets - List of currently installed target IDs
+ * @returns Array of target choices with installation status
+ */
+export function buildAvailableTargets(installedTargets: string[]): TargetChoice[] {
+  return [
+    {
+      name: 'Claude Code',
+      value: 'claude-code',
+      installed: installedTargets.includes('claude-code'),
+    },
+    {
+      name: 'OpenCode',
+      value: 'opencode',
+      installed: installedTargets.includes('opencode'),
+    },
+    {
+      name: 'Cursor',
+      value: 'cursor',
+      installed: installedTargets.includes('cursor'),
+    },
+  ];
+}
+
+/**
+ * Format target choice for display in prompts
+ * @param target - Target choice to format
+ * @param context - Context where choice is displayed (affects status message)
+ * @returns Formatted string with target name and installation status
+ */
+export function formatTargetChoice(target: TargetChoice, context: 'execution' | 'settings'): string {
+  const status = target.installed
+    ? chalk.green(' ✓ installed')
+    : context === 'execution'
+      ? chalk.dim(' (will auto-install)')
+      : chalk.dim(' (not installed - will auto-install on first use)');
+
+  return `${target.name}${status}`;
+}
+
+/**
+ * Prompt user to select a target
+ * @param installedTargets - List of currently installed target IDs
+ * @param message - Prompt message to display
+ * @param context - Context where prompt is shown (affects status formatting)
+ * @returns Selected target ID
+ * @throws {UserCancelledError} If user cancels the prompt
+ */
+export async function promptForTargetSelection(
+  installedTargets: string[],
+  message: string,
+  context: 'execution' | 'settings'
+): Promise<string> {
+  const availableTargets = buildAvailableTargets(installedTargets);
+
+  try {
+    const { targetId } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'targetId',
+        message,
+        choices: availableTargets.map((target) => ({
+          name: formatTargetChoice(target, context),
+          value: target.value,
+        })),
+      },
+    ]);
+
+    return targetId;
+  } catch (error) {
+    handlePromptError(error, 'Target selection cancelled');
+  }
+}
+
+/**
+ * Prompt for default target with "Ask me every time" option
+ * @param installedTargets - List of currently installed target IDs
+ * @param currentDefault - Current default target (if any)
+ * @returns Selected default target ID or 'ask-every-time'
+ * @throws {UserCancelledError} If user cancels the prompt
+ */
+export async function promptForDefaultTarget(
+  installedTargets: string[],
+  currentDefault?: string
+): Promise<string> {
+  const availableTargets = buildAvailableTargets(installedTargets);
+
+  try {
+    const { defaultTarget } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'defaultTarget',
+        message: 'Select default target platform:',
+        choices: [
+          ...availableTargets.map((target) => ({
+            name: formatTargetChoice(target, 'settings'),
+            value: target.value,
+          })),
+          new inquirer.Separator(),
+          {
+            name: 'Ask me every time',
+            value: 'ask-every-time',
+          },
+        ],
+        default: currentDefault || 'ask-every-time',
+      },
+    ]);
+
+    return defaultTarget;
+  } catch (error) {
+    handlePromptError(error, 'Target selection cancelled');
+  }
+}
+
+/**
+ * Ensure target is installed, auto-installing if needed
+ * @param targetId - Target ID to ensure is installed
+ * @param targetInstaller - TargetInstaller instance to use
+ * @param installedTargets - List of currently installed target IDs
+ * @returns True if target is installed (or successfully installed), false otherwise
+ */
+export async function ensureTargetInstalled(
+  targetId: string,
+  targetInstaller: TargetInstaller,
+  installedTargets: string[]
+): Promise<boolean> {
+  const installation = targetInstaller.getInstallationInfo(targetId);
+
+  // Already installed - nothing to do
+  if (installedTargets.includes(targetId)) {
+    return true;
+  }
+
+  // Not installed - try to install
+  console.log();
+  const installed = await targetInstaller.install(targetId, true);
+
+  if (!installed) {
+    console.log(chalk.red(`\n✗ Failed to install ${installation?.name}`));
+    console.log(chalk.yellow('   Please install manually and try again.\n'));
+    return false;
+  }
+
+  console.log();
+  return true;
+}