@sylphx/flow 1.8.2 → 2.0.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;
+  }
+}